@visactor/vseed 0.0.4 → 0.0.6

package/dist/index.cjs

@@ -0,0 +1,1762 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    columnPercentSpecPipeline: ()=>columnPercentSpecPipeline,
+    isVChart: ()=>isVChart,
+    registerAll: ()=>all_registerAll,
+    execPipeline: ()=>execPipeline,
+    areaSpecPipeline: ()=>areaSpecPipeline,
+    registerCustomTheme: ()=>registerCustomTheme,
+    registerLine: ()=>registerLine,
+    zColor: ()=>zColor,
+    zMeasureGroup: ()=>zMeasureGroup,
+    zUnfoldInfo: ()=>zUnfoldInfo,
+    zMeasures: ()=>zMeasures,
+    darkTheme: ()=>darkTheme,
+    columnPercentAdvancedPipeline: ()=>columnPercentAdvancedPipeline,
+    isVTable: ()=>isVTable,
+    columnSpecPipeline: ()=>columnSpecPipeline,
+    zFoldInfo: ()=>zFoldInfo,
+    zDatasetReshapeInfo: ()=>zDatasetReshapeInfo,
+    columnParallelSpecPipeline: ()=>columnParallelSpecPipeline,
+    columnAdvancedPipeline: ()=>columnAdvancedPipeline,
+    zLabel: ()=>zLabel,
+    registerColumn: ()=>registerColumn,
+    zDimension: ()=>zDimension,
+    lightTheme: ()=>lightTheme,
+    registerColumnParallel: ()=>registerColumnParallel,
+    zCustomTheme: ()=>zCustomTheme,
+    dataReshapeFor1D1M: ()=>dataReshapeFor1D1M_dataReshapeFor1D1M,
+    registerArea: ()=>registerArea,
+    zDataset: ()=>zDataset,
+    barPercentAdvancedPipeline: ()=>barPercentAdvancedPipeline,
+    areaPercentAdvancedPipeline: ()=>areaPercentAdvancedPipeline,
+    zBackgroundColor: ()=>zBackgroundColor,
+    registerBarParallel: ()=>registerBarParallel,
+    zMeasure: ()=>zMeasure,
+    zDimensions: ()=>zDimensions,
+    zLegend: ()=>zLegend,
+    zTheme: ()=>zTheme,
+    zEncoding: ()=>zEncoding,
+    registerAreaPercent: ()=>registerAreaPercent,
+    zDatum: ()=>zDatum,
+    barAdvancedPipeline: ()=>barAdvancedPipeline,
+    zCustomThemeConfig: ()=>zCustomThemeConfig,
+    columnParallelAdvancedPipeline: ()=>columnParallelAdvancedPipeline,
+    registerColumnPercent: ()=>registerColumnPercent,
+    registerBarPercent: ()=>registerBarPercent,
+    foldMeasures: ()=>foldMeasures,
+    dataReshapeFor2D1M: ()=>dataReshapeFor2D1M,
+    registerLightTheme: ()=>registerLightTheme,
+    registerDarkTheme: ()=>registerDarkTheme,
+    zChartType: ()=>zChartType,
+    barParallelAdvancedPipeline: ()=>barParallelAdvancedPipeline,
+    barPercentSpecPipeline: ()=>barPercentSpecPipeline,
+    lineAdvancedPipeline: ()=>lineAdvancedPipeline,
+    zTooltip: ()=>zTooltip,
+    barSpecPipeline: ()=>barSpecPipeline,
+    lineSpecPipeline: ()=>lineSpecPipeline,
+    zBaseConfig: ()=>zBaseConfig,
+    unfoldDimensions: ()=>unfoldDimensions,
+    areaAdvancedPipeline: ()=>areaAdvancedPipeline,
+    areaPercentSpecPipeline: ()=>areaPercentSpecPipeline,
+    Builder: ()=>Builder,
+    barParallelSpecPipeline: ()=>barParallelSpecPipeline,
+    registerBar: ()=>registerBar
+});
+const constant_FoldMeasureName = '__MeaName__';
+const constant_FoldMeasureValue = '__MeaValue__';
+const constant_FoldMeasureId = '__MeaId__';
+const constant_UnfoldDimensionGroup = '__DimGroup__';
+const Separator = '-';
+const external_remeda_namespaceObject = require("remeda");
+const unfoldDimensions = (dataset, dimensions, measures, unfoldStartIndex = 0, foldGroupName = constant_UnfoldDimensionGroup, dimensionsSeparator = Separator)=>{
+    if (unfoldStartIndex < 0 || unfoldStartIndex >= dimensions.length) throw new Error('unfoldStartIndex is out of range');
+    const dimensionsToBeUnfolded = dimensions.slice(unfoldStartIndex);
+    const unfoldInfo = {
+        groupName: foldGroupName,
+        colorItems: []
+    };
+    if (0 === dimensions.length || 0 === measures.length) return {
+        dataset,
+        unfoldInfo: {
+            groupName: foldGroupName,
+            colorItems: []
+        }
+    };
+    const colorItems = [];
+    for(let i = 0; i < dataset.length; i++){
+        const datum = dataset[i];
+        const colorItem = generateDimGroupName(dimensionsToBeUnfolded, datum, dimensionsSeparator);
+        datum[foldGroupName] = colorItem;
+        colorItems.push(colorItem);
+    }
+    unfoldInfo.colorItems = (0, external_remeda_namespaceObject.unique)(colorItems);
+    return {
+        dataset,
+        unfoldInfo
+    };
+};
+const generateDimGroupName = (dimensionsToBeGrouped, datum, dimensionsSeparator)=>dimensionsToBeGrouped.map((dim)=>String(datum[dim.id])).join(dimensionsSeparator);
+const foldMeasures = (dataset, measures, measureId = constant_FoldMeasureId, measureName = constant_FoldMeasureName, measureValue = constant_FoldMeasureValue)=>{
+    const foldInfo = {
+        measureId,
+        measureName,
+        measureValue,
+        foldMap: {}
+    };
+    const result = new Array(dataset.length * measures.length);
+    let index = 0;
+    for(let i = 0; i < dataset.length; i++)for(let j = 0; j < measures.length; j++){
+        const datum = {
+            ...dataset[i]
+        };
+        const measure = measures[j];
+        const { id, alias } = measure;
+        datum[measureId] = id;
+        datum[measureName] = alias;
+        datum[measureValue] = dataset[i][id];
+        foldInfo.foldMap[id] = alias;
+        result[index++] = datum;
+    }
+    return {
+        dataset: result,
+        foldInfo
+    };
+};
+const emptyReshapeResult = {
+    dataset: [],
+    foldInfo: {
+        foldMap: {},
+        measureId: '',
+        measureName: '',
+        measureValue: ''
+    },
+    unfoldInfo: {
+        colorItems: [],
+        groupName: ''
+    }
+};
+const dataReshapeFor2D1M = (dataset, dimensions, measures, options)=>{
+    const { foldMeasureId = constant_FoldMeasureId, foldMeasureName = constant_FoldMeasureName, foldMeasureValue = constant_FoldMeasureValue, unfoldDimensionGroup = constant_UnfoldDimensionGroup } = options || {};
+    if (0 === dimensions.length && 0 === measures.length) return emptyReshapeResult;
+    const { dataset: foldedDataset, foldInfo } = foldMeasures(dataset, measures, foldMeasureId, foldMeasureName, foldMeasureValue);
+    if (0 === dimensions.length) {
+        const { dataset: finalDataset, unfoldInfo } = unfoldDimensions(foldedDataset, [
+            {
+                id: foldMeasureId,
+                alias: "\u6307\u6807Id",
+                location: 'dimension'
+            },
+            {
+                id: foldMeasureName,
+                alias: "\u6307\u6807\u540D\u79F0",
+                location: 'dimension'
+            }
+        ], [
+            {
+                id: foldMeasureValue,
+                alias: "\u6307\u6807\u503C"
+            }
+        ], 1, unfoldDimensionGroup);
+        return {
+            dataset: finalDataset,
+            foldInfo,
+            unfoldInfo
+        };
+    }
+    {
+        const { dataset: finalDataset, unfoldInfo } = unfoldDimensions(foldedDataset, [
+            ...dimensions,
+            {
+                id: foldMeasureName,
+                alias: "\u6307\u6807\u540D\u79F0",
+                location: 'dimension'
+            }
+        ], [
+            {
+                id: foldMeasureValue,
+                alias: "\u6307\u6807\u503C"
+            }
+        ], 1, unfoldDimensionGroup);
+        return {
+            dataset: finalDataset,
+            foldInfo,
+            unfoldInfo
+        };
+    }
+};
+const dataReshapeFor1D1M_emptyReshapeResult = {
+    dataset: [],
+    foldInfo: {
+        foldMap: {},
+        measureId: '',
+        measureName: '',
+        measureValue: ''
+    },
+    unfoldInfo: {
+        groupName: '',
+        colorItems: []
+    }
+};
+const dataReshapeFor1D1M_dataReshapeFor1D1M = (dataset, dimensions, measures, options)=>{
+    const { foldMeasureId = constant_FoldMeasureId, foldMeasureName = constant_FoldMeasureName, foldMeasureValue = constant_FoldMeasureValue, unfoldDimensionGroup = constant_UnfoldDimensionGroup } = options || {};
+    if (0 === dimensions.length && 0 === measures.length) return dataReshapeFor1D1M_emptyReshapeResult;
+    const { dataset: foldedDataset, foldInfo } = foldMeasures(dataset, measures, foldMeasureId, foldMeasureName, foldMeasureValue);
+    if (0 === dimensions.length) {
+        const { dataset: finalDataset, unfoldInfo } = unfoldDimensions(foldedDataset, [
+            {
+                id: foldMeasureName,
+                alias: "\u6307\u6807\u540D\u79F0",
+                location: 'dimension'
+            }
+        ], [
+            {
+                id: foldMeasureValue,
+                alias: "\u6307\u6807\u503C"
+            }
+        ], 0, unfoldDimensionGroup);
+        return {
+            dataset: finalDataset,
+            foldInfo,
+            unfoldInfo
+        };
+    }
+    {
+        const { dataset: finalDataset, unfoldInfo } = unfoldDimensions(foldedDataset, [
+            ...dimensions,
+            {
+                id: foldMeasureName,
+                alias: "\u6307\u6807\u540D\u79F0",
+                location: 'dimension'
+            }
+        ], [
+            {
+                id: foldMeasureValue,
+                alias: "\u6307\u6807\u503C"
+            }
+        ], 0, unfoldDimensionGroup);
+        return {
+            dataset: finalDataset,
+            foldInfo,
+            unfoldInfo
+        };
+    }
+};
+const reshapeTo2D1M = (advancedVSeed, context)=>{
+    const result = {
+        ...advancedVSeed
+    };
+    const { vseed } = context;
+    const { dataset } = vseed;
+    const { dimensions, measures } = advancedVSeed;
+    if (!measures || !dimensions || !dataset) return result;
+    if (0 === measures.length) throw new Error('measures can not be empty');
+    const { dataset: newDatasets, foldInfo, unfoldInfo } = dataReshapeFor2D1M(dataset, dimensions, measures);
+    return {
+        ...result,
+        dataset: newDatasets,
+        datasetReshapeInfo: [
+            {
+                id: '2D1M',
+                foldInfo,
+                unfoldInfo
+            }
+        ],
+        dimensions,
+        measures
+    };
+};
+const pivotReshapeTo2D1M = (advancedVSeed, context)=>{
+    const result = {
+        ...advancedVSeed
+    };
+    const { vseed } = context;
+    const { dataset } = vseed;
+    const { dimensions, measures } = advancedVSeed;
+    if (!measures || !dimensions) return result;
+    const measureGroups = [];
+    if (measures) measures.forEach((measure)=>{
+        if (measure.children && measure.children.length > 0) measureGroups.push(measure);
+    });
+    const newDatasets = [];
+    const datasetReshapeInfo = [];
+    measureGroups.forEach((measureGroup)=>{
+        const measures = measureGroup.children;
+        if (!measures) return;
+        const groupId = measureGroup.id;
+        const { dataset: newSubDataset, foldInfo, unfoldInfo } = dataReshapeFor2D1M(dataset, dimensions, measures, {
+            foldMeasureId: constant_FoldMeasureId + groupId,
+            foldMeasureName: constant_FoldMeasureName + groupId,
+            foldMeasureValue: constant_FoldMeasureValue + groupId,
+            unfoldDimensionGroup: constant_UnfoldDimensionGroup + groupId
+        });
+        const reshapeInfo = {
+            id: groupId,
+            foldInfo,
+            unfoldInfo
+        };
+        newDatasets.push(newSubDataset);
+        datasetReshapeInfo.push(reshapeInfo);
+    });
+    return {
+        ...result,
+        dataset: newDatasets,
+        datasetReshapeInfo: datasetReshapeInfo
+    };
+};
+const encodingXY = (advancedVSeed)=>{
+    const result = {
+        ...advancedVSeed
+    };
+    const { datasetReshapeInfo, dimensions } = advancedVSeed;
+    if (!datasetReshapeInfo || !dimensions) return result;
+    const encoding = datasetReshapeInfo.reduce((prev, cur)=>{
+        const { foldInfo, unfoldInfo } = cur;
+        const isSingleDimension = 0 === dimensions.length;
+        const x = [
+            isSingleDimension ? foldInfo.measureName : dimensions[0].id
+        ];
+        const y = [
+            foldInfo.measureValue
+        ];
+        const group = [
+            isSingleDimension ? foldInfo.measureName : unfoldInfo.groupName
+        ];
+        const color = [
+            foldInfo.measureName
+        ];
+        return [
+            ...prev,
+            {
+                x,
+                y,
+                group,
+                color
+            }
+        ];
+    }, []);
+    return {
+        ...result,
+        encoding
+    };
+};
+const encodingYX = (advancedVSeed)=>{
+    const result = {
+        ...advancedVSeed
+    };
+    const { datasetReshapeInfo, dimensions } = advancedVSeed;
+    if (!datasetReshapeInfo || !dimensions) return result;
+    const encoding = datasetReshapeInfo.reduce((prev, cur)=>{
+        const { foldInfo, unfoldInfo } = cur;
+        const isSingleDimension = 0 === dimensions.length;
+        const y = [
+            isSingleDimension ? foldInfo.measureName : dimensions[0].id
+        ];
+        const x = [
+            foldInfo.measureValue
+        ];
+        const group = [
+            isSingleDimension ? foldInfo.measureName : unfoldInfo.groupName
+        ];
+        const color = [
+            foldInfo.measureName
+        ];
+        return [
+            ...prev,
+            {
+                x,
+                y,
+                group,
+                color
+            }
+        ];
+    }, []);
+    return {
+        ...result,
+        encoding
+    };
+};
+const initAdvancedVSeed = (advancedVSeed, context)=>{
+    const { vseed } = context;
+    const { chartType = 'table' } = vseed;
+    return {
+        ...advancedVSeed,
+        chartType
+    };
+};
+const autoMeasures = (advancedVSeed, context)=>{
+    const result = {
+        ...advancedVSeed
+    };
+    const { vseed } = context;
+    const { measures, dataset } = vseed;
+    if (!dataset) throw new Error('dataset is required');
+    if (0 === dataset.length) return result;
+    if (measures) {
+        result.measures = measures;
+        return result;
+    }
+    const top100dataset = dataset.slice(0, 100);
+    const sample = top100dataset.reduce((prev, cur)=>({
+            ...prev,
+            ...cur
+        }), {});
+    result.measures = Object.keys(sample).filter((key)=>top100dataset.some((item)=>'number' == typeof item[key]) && ![
+            '',
+            null,
+            void 0
+        ].includes(key)).map((measure)=>({
+            id: measure,
+            alias: measure
+        }));
+    return result;
+};
+const autoDimensions = (advancedVSeed, context)=>{
+    const result = {
+        ...advancedVSeed
+    };
+    const { vseed } = context;
+    const { dimensions, dataset } = vseed;
+    const { measures = [] } = advancedVSeed;
+    if (!dataset) throw new Error('dataset is required');
+    if (0 === dataset.length) return result;
+    if (dimensions) {
+        result.dimensions = dimensions;
+        return result;
+    }
+    const top100dataset = dataset.slice(0, 100);
+    const sample = top100dataset.reduce((prev, cur)=>({
+            ...prev,
+            ...cur
+        }), {});
+    result.dimensions = Object.keys(sample).filter((key)=>top100dataset.some((item)=>'string' == typeof item[key]) && ![
+            '',
+            null,
+            void 0
+        ].includes(key) && !measures.some((measure)=>measure.id === key)).map((dim)=>({
+            id: dim,
+            alias: dim,
+            location: 'dimension'
+        }));
+    return result;
+};
+const vchartBaseConfig = (advancedVSeed, context)=>{
+    const { vseed } = context;
+    const result = {
+        ...advancedVSeed
+    };
+    const config = (0, external_remeda_namespaceObject.pick)(vseed, [
+        'backgroundColor',
+        'color',
+        'label',
+        'legend',
+        'tooltip'
+    ]);
+    result.baseConfig = {
+        vchart: {
+            ...config
+        }
+    };
+    return result;
+};
+const vchartTheme = (advancedVSeed, context)=>{
+    const { customTheme, vseed } = context;
+    const { theme = 'light' } = vseed;
+    const result = {
+        ...advancedVSeed
+    };
+    if (!customTheme || !customTheme[theme]) return result;
+    const config = result.baseConfig?.vchart;
+    const themeConfig = customTheme?.[theme].baseConfig?.vchart;
+    if (!themeConfig || !config) return result;
+    const mergedConfig = (0, external_remeda_namespaceObject.mergeDeep)(themeConfig, (0, external_remeda_namespaceObject.clone)(config));
+    result.baseConfig = {
+        vchart: mergedConfig
+    };
+    return result;
+};
+const execPipeline = (pipeline, context, initialValue = {})=>{
+    const result = pipeline.reduce((prev, cur)=>cur(prev, context), initialValue);
+    return result;
+};
+const pivotAdapter = (pipeline, pivotPipeline)=>(advancedVSeed, context)=>{
+        const { vseed } = context;
+        const { measures } = vseed;
+        if (measures && measures.find((measure)=>measure && measure.children)) return execPipeline(pivotPipeline, context, advancedVSeed);
+        return execPipeline(pipeline, context, advancedVSeed);
+    };
+const lineAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    pivotAdapter([
+        reshapeTo2D1M
+    ], [
+        pivotReshapeTo2D1M
+    ]),
+    encodingXY,
+    vchartBaseConfig,
+    vchartTheme
+];
+const barAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    pivotAdapter([
+        reshapeTo2D1M
+    ], [
+        pivotReshapeTo2D1M
+    ]),
+    encodingYX,
+    vchartBaseConfig,
+    vchartTheme
+];
+const barParallelAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    pivotAdapter([
+        reshapeTo2D1M
+    ], [
+        pivotReshapeTo2D1M
+    ]),
+    encodingYX,
+    vchartBaseConfig,
+    vchartTheme
+];
+const barPercentAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    pivotAdapter([
+        reshapeTo2D1M
+    ], [
+        pivotReshapeTo2D1M
+    ]),
+    encodingYX,
+    vchartBaseConfig,
+    vchartTheme
+];
+const columnAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    pivotAdapter([
+        reshapeTo2D1M
+    ], [
+        pivotReshapeTo2D1M
+    ]),
+    encodingXY,
+    vchartBaseConfig,
+    vchartTheme
+];
+const columnParallelAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    pivotAdapter([
+        reshapeTo2D1M
+    ], [
+        pivotReshapeTo2D1M
+    ]),
+    encodingXY,
+    vchartBaseConfig,
+    vchartTheme
+];
+const columnPercentAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    pivotAdapter([
+        reshapeTo2D1M
+    ], [
+        pivotReshapeTo2D1M
+    ]),
+    encodingXY,
+    vchartBaseConfig,
+    vchartTheme
+];
+const areaAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    pivotAdapter([
+        reshapeTo2D1M
+    ], [
+        pivotReshapeTo2D1M
+    ]),
+    encodingXY,
+    vchartBaseConfig,
+    vchartTheme
+];
+const areaPercentAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    pivotAdapter([
+        reshapeTo2D1M
+    ], [
+        pivotReshapeTo2D1M
+    ]),
+    encodingXY,
+    vchartBaseConfig,
+    vchartTheme
+];
+const dataset_dataset = (spec, context)=>{
+    const { advancedVSeed } = context;
+    return {
+        ...spec,
+        data: {
+            values: advancedVSeed.dataset
+        }
+    };
+};
+const datasetPivot = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const { dataset, datasetReshapeInfo } = advancedVSeed;
+    const records = dataset.reduce((pre, cur, index)=>{
+        const id = datasetReshapeInfo[index].id;
+        pre[id] = cur;
+        return pre;
+    }, {});
+    return {
+        ...result,
+        records: records
+    };
+};
+const datasetPivotPlaceholder = (spec)=>({
+        ...spec,
+        data: {
+            id: 'placeholderDataId'
+        }
+    });
+const initColumn = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const { encoding } = advancedVSeed;
+    if (!encoding[0].y || !encoding[0].x || !encoding[0].group) return result;
+    result.type = 'bar';
+    result.direction = 'vertical';
+    result.xField = encoding[0].x[0];
+    result.yField = encoding[0].y[0];
+    result.seriesField = encoding[0].group[0];
+    result.padding = 0;
+    return result;
+};
+const initBar = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const { encoding } = advancedVSeed;
+    if (!encoding[0].y || !encoding[0].x || !encoding[0].group) return result;
+    result.type = 'bar';
+    result.direction = 'horizontal';
+    result.yField = encoding[0].y?.[0];
+    result.xField = encoding[0].x?.[0];
+    result.seriesField = encoding[0].group?.[0];
+    result.padding = 0;
+    return result;
+};
+const initBarParallel = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const { encoding, datasetReshapeInfo } = advancedVSeed;
+    const { unfoldInfo } = datasetReshapeInfo[0];
+    if (!encoding[0].y || !encoding[0].x || !encoding[0].group) return result;
+    result.type = 'bar';
+    result.direction = 'horizontal';
+    result.yField = [
+        encoding[0].y[0],
+        unfoldInfo.groupName
+    ];
+    result.xField = encoding[0].x[0];
+    result.seriesField = encoding[0].group[0];
+    result.padding = 0;
+    return result;
+};
+const initArea = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const { encoding } = advancedVSeed;
+    if (!encoding[0].y || !encoding[0].x || !encoding[0].group) return result;
+    result.type = 'area';
+    result.direction = 'vertical';
+    result.xField = encoding[0].x[0];
+    result.yField = encoding[0].y[0];
+    result.seriesField = encoding[0].group[0];
+    result.padding = 0;
+    return result;
+};
+const initLine = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const { encoding } = advancedVSeed;
+    if (!encoding[0].y || !encoding[0].x || !encoding[0].group) return result;
+    result.type = 'line';
+    result.direction = 'vertical';
+    result.xField = encoding[0].x[0];
+    result.yField = encoding[0].y[0];
+    result.seriesField = encoding[0].group[0];
+    result.padding = 0;
+    return result;
+};
+const initColumnParallel = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const { encoding, datasetReshapeInfo } = advancedVSeed;
+    const { unfoldInfo } = datasetReshapeInfo[0];
+    if (!encoding[0].y || !encoding[0].x || !encoding[0].group) return result;
+    result.type = 'bar';
+    result.direction = 'vertical';
+    result.xField = [
+        encoding[0].x[0],
+        unfoldInfo.groupName
+    ];
+    result.yField = encoding[0].y[0];
+    result.seriesField = encoding[0].group[0];
+    result.padding = 0;
+    return result;
+};
+const initPivot = (spec)=>{
+    const result = {
+        ...spec
+    };
+    return {
+        ...result,
+        rows: [],
+        columns: [],
+        indicators: [],
+        records: [],
+        widthMode: 'adaptive',
+        heightMode: 'adaptive',
+        indicatorsAsCol: false
+    };
+};
+const xBand = (spec)=>{
+    const result = {
+        ...spec
+    };
+    if (!result.axes) result.axes = [];
+    result.axes = [
+        ...result.axes,
+        {
+            visible: true,
+            type: 'band',
+            orient: 'bottom'
+        }
+    ];
+    return result;
+};
+const xLinear = (spec)=>{
+    const result = {
+        ...spec
+    };
+    if (!result.axes) result.axes = [];
+    result.axes = [
+        ...result.axes,
+        {
+            visible: true,
+            type: 'linear',
+            orient: 'bottom',
+            nice: true,
+            zero: true
+        }
+    ];
+    return result;
+};
+const yBand = (spec)=>{
+    const result = {
+        ...spec
+    };
+    if (!result.axes) result.axes = [];
+    result.axes = [
+        ...result.axes,
+        {
+            visible: true,
+            type: 'band',
+            orient: 'left'
+        }
+    ];
+    return result;
+};
+const yLinear = (spec)=>{
+    const result = {
+        ...spec
+    };
+    if (!result.axes) result.axes = [];
+    result.axes = [
+        ...result.axes,
+        {
+            visible: true,
+            type: 'linear',
+            orient: 'left',
+            nice: true,
+            zero: true
+        }
+    ];
+    return result;
+};
+const percent = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    result.percent = true;
+    return result;
+};
+const stack = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    result.stack = true;
+    return result;
+};
+const background_backgroundColor = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const { baseConfig } = advancedVSeed;
+    if (!baseConfig?.vchart) return result;
+    const { backgroundColor } = baseConfig.vchart;
+    return {
+        ...result,
+        background: backgroundColor
+    };
+};
+const defaultTooltip = {
+    enable: true
+};
+const tooltip_tooltip = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const baseConfig = advancedVSeed.baseConfig.vchart;
+    const { tooltip = defaultTooltip } = baseConfig;
+    const { enable } = tooltip;
+    result.tooltip = {
+        visible: enable
+    };
+    return result;
+};
+const label_label = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const baseConfig = advancedVSeed.baseConfig.vchart;
+    if (!baseConfig || !baseConfig.label) return result;
+    const { label } = baseConfig;
+    const { enable } = label;
+    result.label = {
+        visible: enable
+    };
+    return result;
+};
+const defaultLegend = {
+    enable: true
+};
+const legend_legend = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const baseConfig = advancedVSeed.baseConfig.vchart;
+    if (!baseConfig || !baseConfig.legend) return result;
+    const { legend = defaultLegend } = baseConfig;
+    const { enable } = legend;
+    result.legends = {
+        visible: enable
+    };
+    return result;
+};
+const pivotLegend = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const baseConfig = advancedVSeed.baseConfig.vchart;
+    if (!baseConfig || !baseConfig.legend) return result;
+    const { datasetReshapeInfo } = advancedVSeed;
+    const colorItems = (0, external_remeda_namespaceObject.unique)(datasetReshapeInfo.flatMap((d)=>d.unfoldInfo.colorItems));
+    const { legend, color } = baseConfig;
+    const { enable } = legend;
+    const { colorScheme } = color;
+    result.legends = {
+        visible: enable,
+        alignSelf: 'end',
+        type: 'discrete',
+        position: 'start',
+        data: colorItems.map((d, index)=>({
+                label: d,
+                shape: {
+                    symbolType: 'square',
+                    fill: colorScheme[index]
+                }
+            })),
+        orient: 'bottom'
+    };
+    return result;
+};
+const color_color = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const { datasetReshapeInfo } = advancedVSeed;
+    const { unfoldInfo } = datasetReshapeInfo[0];
+    const baseConfig = advancedVSeed.baseConfig.vchart;
+    if (!baseConfig || !baseConfig.color) return result;
+    const { color } = baseConfig;
+    const { colorScheme, colorMapping } = color;
+    result.color = {
+        type: 'ordinal',
+        domain: unfoldInfo.colorItems,
+        range: colorScheme,
+        specified: colorMapping
+    };
+    return result;
+};
+const pivotAdapter_pivotAdapter = (pipeline, pivotPipeline)=>(spec, context)=>{
+        const { advancedVSeed } = context;
+        const { measures } = advancedVSeed;
+        if (measures && measures.find((measure)=>measure && measure.children)) return execPipeline(pivotPipeline, context, spec);
+        return execPipeline(pipeline, context, spec);
+    };
+const pivotIndicators = (chartPipeline)=>(spec, context)=>{
+        const result = {
+            ...spec
+        };
+        const { advancedVSeed } = context;
+        const { measures, datasetReshapeInfo, encoding } = advancedVSeed;
+        const colorItems = (0, external_remeda_namespaceObject.unique)(datasetReshapeInfo.flatMap((d)=>d.unfoldInfo.colorItems));
+        const indicators = datasetReshapeInfo.map((reshapeInfo, index)=>{
+            const measure = measures?.find((d)=>d.id === reshapeInfo.id);
+            const newEncoding = [
+                encoding[index]
+            ];
+            const newDatasetReshapeInfo = [
+                {
+                    ...reshapeInfo,
+                    unfoldInfo: {
+                        ...reshapeInfo.unfoldInfo,
+                        colorItems
+                    }
+                }
+            ];
+            const newContext = {
+                ...context,
+                advancedVSeed: {
+                    ...advancedVSeed,
+                    datasetReshapeInfo: newDatasetReshapeInfo,
+                    encoding: newEncoding
+                }
+            };
+            const chartSpec = execPipeline(chartPipeline, newContext, {});
+            return {
+                indicatorKey: reshapeInfo.id,
+                title: measure?.alias,
+                cellType: 'chart',
+                chartModule: 'vchart',
+                chartSpec: chartSpec,
+                style: {
+                    padding: [
+                        1,
+                        1,
+                        0,
+                        1
+                    ]
+                }
+            };
+        });
+        return {
+            ...result,
+            indicators: indicators
+        };
+    };
+const pivotIndicators_pivotIndicatorsAsRow = (spec)=>{
+    const result = {
+        ...spec
+    };
+    return {
+        ...result,
+        indicatorsAsCol: false
+    };
+};
+const pivotIndicators_pivotIndicatorsAsCol = (spec)=>{
+    const result = {
+        ...spec
+    };
+    return {
+        ...result,
+        indicatorsAsCol: true
+    };
+};
+const line = [
+    initLine,
+    color_color,
+    background_backgroundColor,
+    dataset_dataset,
+    xBand,
+    yLinear,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const pivotLine = [
+    initPivot,
+    pivotIndicators_pivotIndicatorsAsRow,
+    datasetPivot,
+    pivotIndicators([
+        initLine,
+        color_color,
+        background_backgroundColor,
+        datasetPivotPlaceholder,
+        xBand,
+        yLinear,
+        label_label,
+        tooltip_tooltip
+    ]),
+    pivotLegend
+];
+const lineSpecPipeline = [
+    pivotAdapter_pivotAdapter(line, pivotLine)
+];
+const column = [
+    initColumn,
+    color_color,
+    background_backgroundColor,
+    dataset_dataset,
+    xBand,
+    yLinear,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const pivotColumn = [
+    initPivot,
+    pivotIndicators_pivotIndicatorsAsRow,
+    datasetPivot,
+    pivotIndicators([
+        initColumn,
+        color_color,
+        background_backgroundColor,
+        datasetPivotPlaceholder,
+        xBand,
+        yLinear,
+        label_label,
+        tooltip_tooltip
+    ]),
+    pivotLegend
+];
+const columnSpecPipeline = [
+    pivotAdapter_pivotAdapter(column, pivotColumn)
+];
+const columnParallel = [
+    initColumnParallel,
+    color_color,
+    background_backgroundColor,
+    dataset_dataset,
+    xBand,
+    yLinear,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const pivotColumnParallel = [
+    initPivot,
+    pivotIndicators_pivotIndicatorsAsRow,
+    datasetPivot,
+    pivotIndicators([
+        initColumnParallel,
+        color_color,
+        background_backgroundColor,
+        datasetPivotPlaceholder,
+        xBand,
+        yLinear,
+        label_label,
+        tooltip_tooltip
+    ]),
+    pivotLegend
+];
+const columnParallelSpecPipeline = [
+    pivotAdapter_pivotAdapter(columnParallel, pivotColumnParallel)
+];
+const columnPercent = [
+    initColumn,
+    color_color,
+    background_backgroundColor,
+    percent,
+    dataset_dataset,
+    xBand,
+    yLinear,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const pivotColumnPercent = [
+    initPivot,
+    pivotIndicators_pivotIndicatorsAsRow,
+    datasetPivot,
+    pivotIndicators([
+        initColumn,
+        color_color,
+        percent,
+        background_backgroundColor,
+        datasetPivotPlaceholder,
+        xBand,
+        yLinear,
+        label_label,
+        tooltip_tooltip
+    ]),
+    pivotLegend
+];
+const columnPercentSpecPipeline = [
+    pivotAdapter_pivotAdapter(columnPercent, pivotColumnPercent)
+];
+const bar = [
+    initBar,
+    color_color,
+    background_backgroundColor,
+    dataset_dataset,
+    xLinear,
+    yBand,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const pivotBar = [
+    initPivot,
+    pivotIndicators_pivotIndicatorsAsCol,
+    datasetPivot,
+    pivotIndicators([
+        initBar,
+        color_color,
+        background_backgroundColor,
+        datasetPivotPlaceholder,
+        yBand,
+        label_label,
+        label_label,
+        tooltip_tooltip
+    ]),
+    pivotLegend
+];
+const barSpecPipeline = [
+    pivotAdapter_pivotAdapter(bar, pivotBar)
+];
+const barParallel = [
+    initBarParallel,
+    color_color,
+    background_backgroundColor,
+    dataset_dataset,
+    xLinear,
+    yBand,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const pivotBarParallel = [
+    initPivot,
+    pivotIndicators_pivotIndicatorsAsCol,
+    datasetPivot,
+    pivotIndicators([
+        initBarParallel,
+        color_color,
+        background_backgroundColor,
+        datasetPivotPlaceholder,
+        yBand,
+        xLinear,
+        label_label,
+        tooltip_tooltip
+    ]),
+    pivotLegend
+];
+const barParallelSpecPipeline = [
+    pivotAdapter_pivotAdapter(barParallel, pivotBarParallel)
+];
+const barPercent = [
+    initBar,
+    color_color,
+    background_backgroundColor,
+    percent,
+    dataset_dataset,
+    xLinear,
+    yBand,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const pivotBarPercent = [
+    initPivot,
+    pivotIndicators_pivotIndicatorsAsCol,
+    datasetPivot,
+    pivotIndicators([
+        initBar,
+        color_color,
+        background_backgroundColor,
+        percent,
+        datasetPivotPlaceholder,
+        yBand,
+        xLinear,
+        label_label,
+        tooltip_tooltip
+    ]),
+    pivotLegend
+];
+const barPercentSpecPipeline = [
+    pivotAdapter_pivotAdapter(barPercent, pivotBarPercent)
+];
+const area_area = [
+    initArea,
+    color_color,
+    background_backgroundColor,
+    stack,
+    dataset_dataset,
+    xBand,
+    yLinear,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const pivotArea = [
+    initPivot,
+    pivotIndicators_pivotIndicatorsAsRow,
+    datasetPivot,
+    pivotIndicators([
+        initArea,
+        color_color,
+        background_backgroundColor,
+        stack,
+        datasetPivotPlaceholder,
+        xBand,
+        yLinear,
+        label_label,
+        tooltip_tooltip
+    ]),
+    pivotLegend
+];
+const areaSpecPipeline = [
+    pivotAdapter_pivotAdapter(area_area, pivotArea)
+];
+const areaPercent = [
+    initArea,
+    color_color,
+    background_backgroundColor,
+    percent,
+    dataset_dataset,
+    xBand,
+    yLinear,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const pivotAreaPercent = [
+    initPivot,
+    pivotIndicators_pivotIndicatorsAsRow,
+    datasetPivot,
+    pivotIndicators([
+        initArea,
+        color_color,
+        background_backgroundColor,
+        percent,
+        datasetPivotPlaceholder,
+        xBand,
+        yLinear,
+        label_label,
+        tooltip_tooltip
+    ]),
+    pivotLegend
+];
+const areaPercentSpecPipeline = [
+    pivotAdapter_pivotAdapter(areaPercent, pivotAreaPercent)
+];
+const isVTable = (chartType)=>[
+        'table',
+        'pivotTable'
+    ].includes(chartType);
+const isVChart = (chartType)=>!isVTable(chartType);
+const buildAdvanced = (builder)=>{
+    const { chartType } = builder.vseed;
+    if (!chartType) throw new Error('chartType is nil in buildAdvanced');
+    const pipeline = builder.getAdvancedPipeline(chartType);
+    if (!pipeline) throw new Error(`no advanced pipeline for chartType ${chartType}`);
+    const context = {
+        vseed: builder.vseed,
+        customTheme: builder.getThemeMap()
+    };
+    try {
+        return execPipeline(pipeline, context);
+    } catch (e) {
+        console.error(e);
+        throw new Error("buildAdvanced error, see error info in console");
+    }
+};
+const buildSpec = (builder, advancedVSeed)=>{
+    const { chartType } = builder.vseed;
+    if (!chartType) throw new Error('chartType is nil in buildSpec');
+    const pipeline = builder.getSpecPipeline(chartType);
+    if (!pipeline) throw new Error(`no spec pipeline for chartType ${chartType}`);
+    const context = {
+        vseed: builder.vseed,
+        advancedVSeed
+    };
+    try {
+        return execPipeline(pipeline, context);
+    } catch (e) {
+        console.error(e);
+        throw new Error("buildSpec error, see error info in console");
+    }
+};
+const build = (builder)=>{
+    console.log('debug vseed', builder.vseed);
+    const advancedVSeed = builder.buildAdvanced();
+    console.log('debug advancedVSeed', advancedVSeed);
+    if (!advancedVSeed) throw new Error('advancedVSeed is null');
+    const spec = builder.buildSpec(advancedVSeed);
+    console.log('debug spec', spec);
+    return spec;
+};
+class Builder {
+    _vseed;
+    _advancedVSeed = null;
+    constructor(vseed){
+        this._vseed = vseed;
+    }
+    build = ()=>build(this);
+    buildSpec = (advanced)=>buildSpec(this, advanced);
+    buildAdvanced = ()=>buildAdvanced(this);
+    getAdvancedPipeline = (chartType)=>Builder._advancedPipelineMap[chartType];
+    getSpecPipeline = (chartType)=>Builder._specPipelineMap[chartType];
+    getTheme = (themeKey)=>Builder._themeMap[themeKey];
+    getThemeMap = ()=>Builder._themeMap;
+    get vseed() {
+        return this._vseed;
+    }
+    set vseed(value) {
+        this._vseed = value;
+    }
+    get advancedVSeed() {
+        return this._advancedVSeed;
+    }
+    set advancedVSeed(value) {
+        this._advancedVSeed = value;
+    }
+    static _advancedPipelineMap = {};
+    static _specPipelineMap = {};
+    static _themeMap = {};
+    static from = (vseed)=>new Builder(vseed);
+}
+const registerColumn = ()=>{
+    Builder._advancedPipelineMap.column = columnAdvancedPipeline;
+    Builder._specPipelineMap.column = columnSpecPipeline;
+};
+const registerBar = ()=>{
+    Builder._advancedPipelineMap.bar = barAdvancedPipeline;
+    Builder._specPipelineMap.bar = barSpecPipeline;
+};
+const registerLine = ()=>{
+    Builder._advancedPipelineMap.line = lineAdvancedPipeline;
+    Builder._specPipelineMap.line = lineSpecPipeline;
+};
+const registerArea = ()=>{
+    Builder._advancedPipelineMap.area = areaAdvancedPipeline;
+    Builder._specPipelineMap.area = areaSpecPipeline;
+};
+const registerAreaPercent = ()=>{
+    Builder._advancedPipelineMap.areaPercent = areaPercentAdvancedPipeline;
+    Builder._specPipelineMap.areaPercent = areaPercentSpecPipeline;
+};
+const registerBarPercent = ()=>{
+    Builder._advancedPipelineMap.barPercent = barPercentAdvancedPipeline;
+    Builder._specPipelineMap.barPercent = barPercentSpecPipeline;
+};
+const registerColumnPercent = ()=>{
+    Builder._advancedPipelineMap.columnPercent = columnPercentAdvancedPipeline;
+    Builder._specPipelineMap.columnPercent = columnPercentSpecPipeline;
+};
+const registerColumnParallel = ()=>{
+    Builder._advancedPipelineMap.columnParallel = columnParallelAdvancedPipeline;
+    Builder._specPipelineMap.columnParallel = columnParallelSpecPipeline;
+};
+const registerBarParallel = ()=>{
+    Builder._advancedPipelineMap.barParallel = barParallelAdvancedPipeline;
+    Builder._specPipelineMap.barParallel = barParallelSpecPipeline;
+};
+const lightTheme = ()=>({
+        baseConfig: {
+            vtable: {
+                backgroundColor: '#ffffff'
+            },
+            vchart: {
+                backgroundColor: '#ffffff',
+                color: {
+                    colorScheme: [
+                        '#8D72F6',
+                        '#5766EC',
+                        '#66A3FE',
+                        '#51D5E6',
+                        '#4EC0B3',
+                        '#F9DF90',
+                        '#F9AD71',
+                        '#ED8888',
+                        '#E9A0C3',
+                        '#D77DD3'
+                    ]
+                },
+                label: {
+                    enable: true
+                },
+                tooltip: {
+                    enable: true
+                },
+                legend: {
+                    enable: true
+                }
+            }
+        }
+    });
+const darkTheme = ()=>({
+        baseConfig: {
+            vtable: {
+                backgroundColor: '#141414'
+            },
+            vchart: {
+                backgroundColor: '#141414',
+                color: {
+                    colorScheme: [
+                        '#2E62F1',
+                        '#4DC36A',
+                        '#FF8406',
+                        '#FFCC00',
+                        '#4F44CF',
+                        '#5AC8FA',
+                        '#003A8C',
+                        '#B08AE2',
+                        '#FF6341',
+                        '#98DD62'
+                    ]
+                },
+                label: {
+                    enable: true
+                },
+                tooltip: {
+                    enable: true
+                },
+                legend: {
+                    enable: true
+                }
+            }
+        }
+    });
+const registerCustomTheme = (key, themeConfig)=>{
+    Builder._themeMap[key] = themeConfig;
+};
+const registerLightTheme = ()=>{
+    registerCustomTheme('light', lightTheme());
+};
+const registerDarkTheme = ()=>{
+    registerCustomTheme('dark', darkTheme());
+};
+const all_registerAll = ()=>{
+    registerLine();
+    registerColumn();
+    registerColumnParallel();
+    registerColumnPercent();
+    registerBar();
+    registerBarParallel();
+    registerBarPercent();
+    registerArea();
+    registerAreaPercent();
+    registerLightTheme();
+    registerDarkTheme();
+};
+const external_zod_namespaceObject = require("zod");
+const zChartType = external_zod_namespaceObject.z["enum"]([
+    'table',
+    'pivotTable',
+    'line',
+    'column',
+    'columnPercent',
+    'columnParallel',
+    'bar',
+    'barPercent',
+    'barParallel',
+    'area',
+    'areaPercent',
+    'rose',
+    'pie',
+    'donut',
+    'dualAxis'
+]);
+const zDatum = external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string().or(external_zod_namespaceObject.z.number()), external_zod_namespaceObject.z.any());
+const zDataset = external_zod_namespaceObject.z.array(zDatum);
+const zDimension = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    alias: external_zod_namespaceObject.z.string().optional(),
+    visible: external_zod_namespaceObject.z.boolean().default(true).optional(),
+    location: external_zod_namespaceObject.z["enum"]([
+        'dimension',
+        'rowDimension',
+        'columnDimension'
+    ])
+});
+const zDimensions = external_zod_namespaceObject.z.array(zDimension).optional();
+const zMeasure = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    alias: external_zod_namespaceObject.z.string().optional(),
+    visible: external_zod_namespaceObject.z.boolean().default(true).optional(),
+    autoFormat: external_zod_namespaceObject.z.boolean().default(true).optional(),
+    format: external_zod_namespaceObject.z.object({
+        type: external_zod_namespaceObject.z["enum"]([
+            'number',
+            'percent',
+            'permille'
+        ]).optional().default('number'),
+        ratio: external_zod_namespaceObject.z.number().optional().default(1),
+        symbol: external_zod_namespaceObject.z.string().optional().default(''),
+        thousandSeparator: external_zod_namespaceObject.z.boolean().optional().default(false),
+        decimalPlaces: external_zod_namespaceObject.z.number().optional().default(2),
+        round: external_zod_namespaceObject.z["enum"]([
+            'round',
+            'floor',
+            'ceil'
+        ]).optional().default('round'),
+        prefix: external_zod_namespaceObject.z.string().optional().default(''),
+        suffix: external_zod_namespaceObject.z.string().optional().default('')
+    }).optional()
+});
+const zMeasureGroup = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    alias: external_zod_namespaceObject.z.string().optional(),
+    visible: external_zod_namespaceObject.z.boolean().default(true).optional(),
+    get children () {
+        return external_zod_namespaceObject.z.array(zMeasureGroup.or(zMeasure)).optional();
+    }
+});
+const zMeasures = external_zod_namespaceObject.z.array(zMeasureGroup.or(zMeasure)).optional();
+const zFoldInfo = external_zod_namespaceObject.z.object({
+    foldMap: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.string().or(external_zod_namespaceObject.z.undefined())),
+    measureId: external_zod_namespaceObject.z.string(),
+    measureName: external_zod_namespaceObject.z.string(),
+    measureValue: external_zod_namespaceObject.z.string()
+});
+const zUnfoldInfo = external_zod_namespaceObject.z.object({
+    colorItems: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
+    groupName: external_zod_namespaceObject.z.string()
+});
+const zDatasetReshapeInfo = external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    foldInfo: zFoldInfo,
+    unfoldInfo: zUnfoldInfo
+}));
+const zEncoding = external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.object({
+    x: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
+    y: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
+    color: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
+    group: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
+    angle: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
+    radius: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
+    tooltip: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional()
+}));
+const zBackgroundColor = external_zod_namespaceObject.z.string().default('transparent').optional();
+const zLabel = external_zod_namespaceObject.z.object({
+    enable: external_zod_namespaceObject.z.boolean().default(true).optional()
+});
+const zColor = external_zod_namespaceObject.z.object({
+    colorScheme: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
+    colorMapping: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.string()).optional()
+});
+const zTooltip = external_zod_namespaceObject.z.object({
+    enable: external_zod_namespaceObject.z.boolean().default(true).optional()
+});
+const zLegend = external_zod_namespaceObject.z.object({
+    enable: external_zod_namespaceObject.z.boolean().default(true).optional()
+});
+const zVChartBaseConfig = external_zod_namespaceObject.z.object({
+    backgroundColor: zBackgroundColor,
+    label: zLabel.optional(),
+    color: zColor.optional(),
+    tooltip: zTooltip.optional(),
+    legend: zLegend.optional()
+});
+const zVTableBaseConfig = external_zod_namespaceObject.z.object({
+    backgroundColor: zBackgroundColor
+});
+const zBaseConfig = external_zod_namespaceObject.z.object({
+    vchart: zVChartBaseConfig.optional(),
+    vtable: zVTableBaseConfig.optional()
+});
+const zCustomThemeConfig = external_zod_namespaceObject.z.object({
+    baseConfig: zBaseConfig.optional()
+});
+const zCustomTheme = external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), zCustomThemeConfig).optional();
+const zTheme = external_zod_namespaceObject.z.string();
+exports.Builder = __webpack_exports__.Builder;
+exports.areaAdvancedPipeline = __webpack_exports__.areaAdvancedPipeline;
+exports.areaPercentAdvancedPipeline = __webpack_exports__.areaPercentAdvancedPipeline;
+exports.areaPercentSpecPipeline = __webpack_exports__.areaPercentSpecPipeline;
+exports.areaSpecPipeline = __webpack_exports__.areaSpecPipeline;
+exports.barAdvancedPipeline = __webpack_exports__.barAdvancedPipeline;
+exports.barParallelAdvancedPipeline = __webpack_exports__.barParallelAdvancedPipeline;
+exports.barParallelSpecPipeline = __webpack_exports__.barParallelSpecPipeline;
+exports.barPercentAdvancedPipeline = __webpack_exports__.barPercentAdvancedPipeline;
+exports.barPercentSpecPipeline = __webpack_exports__.barPercentSpecPipeline;
+exports.barSpecPipeline = __webpack_exports__.barSpecPipeline;
+exports.columnAdvancedPipeline = __webpack_exports__.columnAdvancedPipeline;
+exports.columnParallelAdvancedPipeline = __webpack_exports__.columnParallelAdvancedPipeline;
+exports.columnParallelSpecPipeline = __webpack_exports__.columnParallelSpecPipeline;
+exports.columnPercentAdvancedPipeline = __webpack_exports__.columnPercentAdvancedPipeline;
+exports.columnPercentSpecPipeline = __webpack_exports__.columnPercentSpecPipeline;
+exports.columnSpecPipeline = __webpack_exports__.columnSpecPipeline;
+exports.darkTheme = __webpack_exports__.darkTheme;
+exports.dataReshapeFor1D1M = __webpack_exports__.dataReshapeFor1D1M;
+exports.dataReshapeFor2D1M = __webpack_exports__.dataReshapeFor2D1M;
+exports.execPipeline = __webpack_exports__.execPipeline;
+exports.foldMeasures = __webpack_exports__.foldMeasures;
+exports.isVChart = __webpack_exports__.isVChart;
+exports.isVTable = __webpack_exports__.isVTable;
+exports.lightTheme = __webpack_exports__.lightTheme;
+exports.lineAdvancedPipeline = __webpack_exports__.lineAdvancedPipeline;
+exports.lineSpecPipeline = __webpack_exports__.lineSpecPipeline;
+exports.registerAll = __webpack_exports__.registerAll;
+exports.registerArea = __webpack_exports__.registerArea;
+exports.registerAreaPercent = __webpack_exports__.registerAreaPercent;
+exports.registerBar = __webpack_exports__.registerBar;
+exports.registerBarParallel = __webpack_exports__.registerBarParallel;
+exports.registerBarPercent = __webpack_exports__.registerBarPercent;
+exports.registerColumn = __webpack_exports__.registerColumn;
+exports.registerColumnParallel = __webpack_exports__.registerColumnParallel;
+exports.registerColumnPercent = __webpack_exports__.registerColumnPercent;
+exports.registerCustomTheme = __webpack_exports__.registerCustomTheme;
+exports.registerDarkTheme = __webpack_exports__.registerDarkTheme;
+exports.registerLightTheme = __webpack_exports__.registerLightTheme;
+exports.registerLine = __webpack_exports__.registerLine;
+exports.unfoldDimensions = __webpack_exports__.unfoldDimensions;
+exports.zBackgroundColor = __webpack_exports__.zBackgroundColor;
+exports.zBaseConfig = __webpack_exports__.zBaseConfig;
+exports.zChartType = __webpack_exports__.zChartType;
+exports.zColor = __webpack_exports__.zColor;
+exports.zCustomTheme = __webpack_exports__.zCustomTheme;
+exports.zCustomThemeConfig = __webpack_exports__.zCustomThemeConfig;
+exports.zDataset = __webpack_exports__.zDataset;
+exports.zDatasetReshapeInfo = __webpack_exports__.zDatasetReshapeInfo;
+exports.zDatum = __webpack_exports__.zDatum;
+exports.zDimension = __webpack_exports__.zDimension;
+exports.zDimensions = __webpack_exports__.zDimensions;
+exports.zEncoding = __webpack_exports__.zEncoding;
+exports.zFoldInfo = __webpack_exports__.zFoldInfo;
+exports.zLabel = __webpack_exports__.zLabel;
+exports.zLegend = __webpack_exports__.zLegend;
+exports.zMeasure = __webpack_exports__.zMeasure;
+exports.zMeasureGroup = __webpack_exports__.zMeasureGroup;
+exports.zMeasures = __webpack_exports__.zMeasures;
+exports.zTheme = __webpack_exports__.zTheme;
+exports.zTooltip = __webpack_exports__.zTooltip;
+exports.zUnfoldInfo = __webpack_exports__.zUnfoldInfo;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "Builder",
+    "areaAdvancedPipeline",
+    "areaPercentAdvancedPipeline",
+    "areaPercentSpecPipeline",
+    "areaSpecPipeline",
+    "barAdvancedPipeline",
+    "barParallelAdvancedPipeline",
+    "barParallelSpecPipeline",
+    "barPercentAdvancedPipeline",
+    "barPercentSpecPipeline",
+    "barSpecPipeline",
+    "columnAdvancedPipeline",
+    "columnParallelAdvancedPipeline",
+    "columnParallelSpecPipeline",
+    "columnPercentAdvancedPipeline",
+    "columnPercentSpecPipeline",
+    "columnSpecPipeline",
+    "darkTheme",
+    "dataReshapeFor1D1M",
+    "dataReshapeFor2D1M",
+    "execPipeline",
+    "foldMeasures",
+    "isVChart",
+    "isVTable",
+    "lightTheme",
+    "lineAdvancedPipeline",
+    "lineSpecPipeline",
+    "registerAll",
+    "registerArea",
+    "registerAreaPercent",
+    "registerBar",
+    "registerBarParallel",
+    "registerBarPercent",
+    "registerColumn",
+    "registerColumnParallel",
+    "registerColumnPercent",
+    "registerCustomTheme",
+    "registerDarkTheme",
+    "registerLightTheme",
+    "registerLine",
+    "unfoldDimensions",
+    "zBackgroundColor",
+    "zBaseConfig",
+    "zChartType",
+    "zColor",
+    "zCustomTheme",
+    "zCustomThemeConfig",
+    "zDataset",
+    "zDatasetReshapeInfo",
+    "zDatum",
+    "zDimension",
+    "zDimensions",
+    "zEncoding",
+    "zFoldInfo",
+    "zLabel",
+    "zLegend",
+    "zMeasure",
+    "zMeasureGroup",
+    "zMeasures",
+    "zTheme",
+    "zTooltip",
+    "zUnfoldInfo"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+//# sourceMappingURL=index.cjs.map