@visactor/vseed 0.0.4 → 0.0.6

package/dist/index.js

@@ -0,0 +1,1545 @@
+import { clone as external_remeda_clone, mergeDeep as external_remeda_mergeDeep, pick as external_remeda_pick, unique } from "remeda";
+import { z } from "zod";
+const constant_FoldMeasureName = '__MeaName__';
+const constant_FoldMeasureValue = '__MeaValue__';
+const constant_FoldMeasureId = '__MeaId__';
+const constant_UnfoldDimensionGroup = '__DimGroup__';
+const Separator = '-';
+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 = 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 = external_remeda_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 = external_remeda_mergeDeep(themeConfig, external_remeda_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 isVTable = (chartType)=>[
+        'table',
+        'pivotTable'
+    ].includes(chartType);
+const isVChart = (chartType)=>!isVTable(chartType);
+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 = 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 = 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 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 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 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 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 zChartType = z["enum"]([
+    'table',
+    'pivotTable',
+    'line',
+    'column',
+    'columnPercent',
+    'columnParallel',
+    'bar',
+    'barPercent',
+    'barParallel',
+    'area',
+    'areaPercent',
+    'rose',
+    'pie',
+    'donut',
+    'dualAxis'
+]);
+const zDatum = z.record(z.string().or(z.number()), z.any());
+const zDataset = z.array(zDatum);
+const zDimension = z.object({
+    id: z.string(),
+    alias: z.string().optional(),
+    visible: z.boolean().default(true).optional(),
+    location: z["enum"]([
+        'dimension',
+        'rowDimension',
+        'columnDimension'
+    ])
+});
+const zDimensions = z.array(zDimension).optional();
+const zMeasure = z.object({
+    id: z.string(),
+    alias: z.string().optional(),
+    visible: z.boolean().default(true).optional(),
+    autoFormat: z.boolean().default(true).optional(),
+    format: z.object({
+        type: z["enum"]([
+            'number',
+            'percent',
+            'permille'
+        ]).optional().default('number'),
+        ratio: z.number().optional().default(1),
+        symbol: z.string().optional().default(''),
+        thousandSeparator: z.boolean().optional().default(false),
+        decimalPlaces: z.number().optional().default(2),
+        round: z["enum"]([
+            'round',
+            'floor',
+            'ceil'
+        ]).optional().default('round'),
+        prefix: z.string().optional().default(''),
+        suffix: z.string().optional().default('')
+    }).optional()
+});
+const zMeasureGroup = z.object({
+    id: z.string(),
+    alias: z.string().optional(),
+    visible: z.boolean().default(true).optional(),
+    get children () {
+        return z.array(zMeasureGroup.or(zMeasure)).optional();
+    }
+});
+const zMeasures = z.array(zMeasureGroup.or(zMeasure)).optional();
+const zFoldInfo = z.object({
+    foldMap: z.record(z.string(), z.string().or(z.undefined())),
+    measureId: z.string(),
+    measureName: z.string(),
+    measureValue: z.string()
+});
+const zUnfoldInfo = z.object({
+    colorItems: z.array(z.string()),
+    groupName: z.string()
+});
+const zDatasetReshapeInfo = z.array(z.object({
+    id: z.string(),
+    foldInfo: zFoldInfo,
+    unfoldInfo: zUnfoldInfo
+}));
+const zEncoding = z.array(z.object({
+    x: z.array(z.string()).optional(),
+    y: z.array(z.string()).optional(),
+    color: z.array(z.string()).optional(),
+    group: z.array(z.string()).optional(),
+    angle: z.array(z.string()).optional(),
+    radius: z.array(z.string()).optional(),
+    tooltip: z.array(z.string()).optional()
+}));
+const zBackgroundColor = z.string().default('transparent').optional();
+const zLabel = z.object({
+    enable: z.boolean().default(true).optional()
+});
+const zColor = z.object({
+    colorScheme: z.array(z.string()).optional(),
+    colorMapping: z.record(z.string(), z.string()).optional()
+});
+const zTooltip = z.object({
+    enable: z.boolean().default(true).optional()
+});
+const zLegend = z.object({
+    enable: z.boolean().default(true).optional()
+});
+const zVChartBaseConfig = z.object({
+    backgroundColor: zBackgroundColor,
+    label: zLabel.optional(),
+    color: zColor.optional(),
+    tooltip: zTooltip.optional(),
+    legend: zLegend.optional()
+});
+const zVTableBaseConfig = z.object({
+    backgroundColor: zBackgroundColor
+});
+const zBaseConfig = z.object({
+    vchart: zVChartBaseConfig.optional(),
+    vtable: zVTableBaseConfig.optional()
+});
+const zCustomThemeConfig = z.object({
+    baseConfig: zBaseConfig.optional()
+});
+const zCustomTheme = z.record(z.string(), zCustomThemeConfig).optional();
+const zTheme = z.string();
+export { Builder, areaAdvancedPipeline, areaPercentAdvancedPipeline, areaPercentSpecPipeline, areaSpecPipeline, barAdvancedPipeline, barParallelAdvancedPipeline, barParallelSpecPipeline, barPercentAdvancedPipeline, barPercentSpecPipeline, barSpecPipeline, columnAdvancedPipeline, columnParallelAdvancedPipeline, columnParallelSpecPipeline, columnPercentAdvancedPipeline, columnPercentSpecPipeline, columnSpecPipeline, darkTheme, dataReshapeFor1D1M_dataReshapeFor1D1M as dataReshapeFor1D1M, dataReshapeFor2D1M, execPipeline, foldMeasures, isVChart, isVTable, lightTheme, lineAdvancedPipeline, lineSpecPipeline, all_registerAll as 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 };
+
+//# sourceMappingURL=index.js.map