How to use the echarts/lib/echarts.util function in echarts

this.setTriangleIndices(this._triangleOffset++, [i4, i3, i2]);
                }
            }

            // Close top and bottom
            this.setTriangleIndices(this._triangleOffset++, [endIndices[0][0], endIndices[0][2], endIndices[0][1]]);
            this.setTriangleIndices(this._triangleOffset++, [endIndices[0][0], endIndices[0][3], endIndices[0][2]]);
            this.setTriangleIndices(this._triangleOffset++, [endIndices[1][0], endIndices[1][1], endIndices[1][2]]);
            this.setTriangleIndices(this._triangleOffset++, [endIndices[1][0], endIndices[1][2], endIndices[1][3]]);

            this._vertexOffset = vertexOffset;
        };
    })()
});

echarts.util.defaults(BarsGeometry.prototype, dynamicConvertMixin);
echarts.util.defaults(BarsGeometry.prototype, trianglesSortMixin);

export default BarsGeometry;

// Minimum interval
    // minInterval: null

    axisPointer: {
        label: {
        }
    }
}, defaultOption);

// FIXME
var timeAxis = echarts.util.defaults({
    scale: true,
    min: 'dataMin',
    max: 'dataMax'
}, valueAxis);
var logAxis = echarts.util.defaults({
    logBase: 10
}, valueAxis);
logAxis.scale = true;

export default {
    categoryAxis3D: categoryAxis,
    valueAxis3D: valueAxis,
    timeAxis3D: timeAxis,
    logAxis3D: logAxis
};

fontSize: 16
    },
    // 文字与轴线距离
    nameGap: 20,

    axisPointer: {},

    axisLine: {},
    // 坐标轴小标记
    axisTick: {},
    axisLabel: {},
    // 分隔区域
    splitArea: {}
};

var categoryAxis = echarts.util.merge({
    // 类目起始和结束两端空白策略
    boundaryGap: true,
    // splitArea: {
        // show: false
    // },
    // 坐标轴小标记
    axisTick: {
        // If tick is align with label when boundaryGap is true
        // Default with axisTick
        alignWithLabel: false,
        interval: 'auto'
    },
    // 坐标轴文本标签，详见axis.axisLabel
    axisLabel: {
        interval: 'auto'
    },

var mesh = new graphicGL.Mesh({
                name: 'Polygon',
                material: new graphicGL.Material({
                    shader: self._shadersMap.lambert
                }),
                geometry: new graphicGL.Geometry({
                    sortTriangles: true,
                    dynamic: true
                }),
                // TODO Disable culling
                culling: false,
                ignorePicking: true,
                // Render normal in normal pass
                renderNormal: true
            });
            echarts.util.extend(mesh.geometry, trianglesSortMixin);
            return mesh;
        }

import BoundingBox from 'claygl/src/math/BoundingBox';
import Frustum from 'claygl/src/math/Frustum';

import animatableMixin from './animatableMixin';
// Some common shaders

import utilGLSL from 'claygl/src/shader/source/util.glsl.js';
import prezGLSL from 'claygl/src/shader/source/prez.glsl.js';
import commonGLSL from './shader/common.glsl.js';
import colorGLSL from './shader/color.glsl.js';
import lambertGLSL from './shader/lambert.glsl.js';
import realisticGLSL from './shader/realistic.glsl.js';
import hatchingGLSL from './shader/hatching.glsl.js';
import shadowGLSL from './shader/shadow.glsl.js';

echarts.util.extend(Node3D.prototype, animatableMixin);

Shader.import(utilGLSL);
Shader.import(prezGLSL);
Shader.import(commonGLSL);
Shader.import(colorGLSL);
Shader.import(lambertGLSL);
Shader.import(realisticGLSL);
Shader.import(hatchingGLSL);
Shader.import(shadowGLSL);

function isValueNone(value) {
    return !value || value === 'none';
}

function isValueImage(value) {
    return value instanceof HTMLCanvasElement

export default function (option) {
    echarts.util.each(option.series, function (series) {
        if (echarts.util.indexOf(GL_SERIES, series.type) >= 0) {
            convertNormalEmphasisForEach(series);

            // Compatitable with original mapbox
            if (series.coordinateSystem === 'mapbox') {
                series.coordinateSystem = 'mapbox3D';
                option.mapbox3D = option.mapbox;
            }
        }
    });

    removeTextStyleInAxis(option.xAxis3D);
    removeTextStyleInAxis(option.yAxis3D);
    removeTextStyleInAxis(option.zAxis3D);
    removeTextStyleInAxis(option.grid3D);

attributes.position.set(vertexOffset + i, position);
        }
        // 3----2
        // 0----1
        var texcoordAttr = attributes.texcoord;

        texcoordAttr.set(vertexOffset, [coords[0][0], coords[0][1]]);
        texcoordAttr.set(vertexOffset + 1, [coords[1][0], coords[0][1]]);
        texcoordAttr.set(vertexOffset + 2, [coords[1][0], coords[1][1]]);
        texcoordAttr.set(vertexOffset + 3, [coords[0][0], coords[1][1]]);

        this.setSpriteAlign(spriteOffset, size, align, verticalAlign, screenMargin);
    }
});

echarts.util.defaults(SpritesGeometry.prototype, dynamicConvertMixin);

export default SpritesGeometry;

function createLayerMap(layers) {
            return echarts.util.reduce(layers, function (obj, layerOption, idx) {
                defaultId(layerOption, idx);
                obj[layerOption.id] = layerOption;
                return obj;
            }, {});
        }
        if (oldLayers && oldLayers.length) {

},

    /**
     * Get maptalks instance
     */
    getMaptalks: function () {
        return this._maptalks;
    },

    setMaptalks: function (maptalks) {
        this._maptalks = maptalks;
    }
});

echarts.util.merge(Maptalks3DModel.prototype, componentPostEffectMixin);
echarts.util.merge(Maptalks3DModel.prototype, componentLightMixin);

export default Maptalks3DModel;

padding: 3,
                borderRadius: 3
            }
        },

        emphasis: {
            label: {
                show: true
            }
        },

        animationDurationUpdate: 500
    }
});

echarts.util.merge(Bar3DSeries.prototype, componentShadingMixin);

export default Bar3DSeries;