@visactor/vseed 0.0.4 → 0.0.5

package/dist/index.js

@@ -0,0 +1,1134 @@
+import { clone as external_remeda_clone, mergeDeep as external_remeda_mergeDeep, pick as external_remeda_pick } from "remeda";
+import { z } from "zod";
+const FoldMeasureName = '__MeaName__';
+const FoldMeasureValue = '__MeaValue__';
+const FoldMeasureId = '__MeaId__';
+const FoldDimensionGroup = '__DimGroup__';
+const Separator = '-';
+const unfoldDimensions = (dataset, dimensions, measures, unfoldStartIndex = 0, foldGroupName = FoldDimensionGroup, 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 = colorItems;
+    return {
+        dataset,
+        unfoldInfo
+    };
+};
+const generateDimGroupName = (dimensionsToBeGrouped, datum, dimensionsSeparator)=>dimensionsToBeGrouped.map((dim)=>String(datum[dim.id])).join(dimensionsSeparator);
+const foldMeasures = (dataset, measures, measureId = FoldMeasureId, measureName = FoldMeasureName, measureValue = 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)=>{
+    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, FoldDimensionGroup);
+        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, FoldDimensionGroup);
+        return {
+            dataset: finalDataset,
+            foldInfo,
+            unfoldInfo
+        };
+    }
+};
+const dataReshapeFor1D1M_emptyReshapeResult = {
+    dataset: [],
+    foldInfo: {
+        foldMap: {},
+        measureId: '',
+        measureName: '',
+        measureValue: ''
+    },
+    unfoldInfo: {
+        groupName: '',
+        colorItems: []
+    }
+};
+const dataReshapeFor1D1M_dataReshapeFor1D1M = (dataset, dimensions, measures)=>{
+    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, FoldDimensionGroup);
+        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, FoldDimensionGroup);
+        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: {
+            foldInfo,
+            unfoldInfo
+        },
+        dimensions,
+        measures
+    };
+};
+const encodingXY = (advancedVSeed)=>{
+    const result = {
+        ...advancedVSeed
+    };
+    const { datasetReshapeInfo, dimensions } = advancedVSeed;
+    if (!datasetReshapeInfo || !dimensions) return result;
+    const { foldInfo, unfoldInfo } = datasetReshapeInfo;
+    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
+    ];
+    const encoding = [
+        {
+            x,
+            y,
+            group,
+            color
+        }
+    ];
+    return {
+        ...result,
+        encoding
+    };
+};
+const encodingYX = (advancedVSeed)=>{
+    const result = {
+        ...advancedVSeed
+    };
+    const { datasetReshapeInfo, dimensions } = advancedVSeed;
+    if (!datasetReshapeInfo || !dimensions) return result;
+    const { foldInfo, unfoldInfo } = datasetReshapeInfo;
+    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
+    ];
+    const encoding = [
+        {
+            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 lineAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    reshapeTo2D1M,
+    encodingXY,
+    vchartBaseConfig,
+    vchartTheme
+];
+const barAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    reshapeTo2D1M,
+    encodingYX,
+    vchartBaseConfig,
+    vchartTheme
+];
+const barParallelAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    reshapeTo2D1M,
+    encodingYX,
+    vchartBaseConfig,
+    vchartTheme
+];
+const barPercentAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    reshapeTo2D1M,
+    encodingYX,
+    vchartBaseConfig,
+    vchartTheme
+];
+const columnAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    reshapeTo2D1M,
+    encodingXY,
+    vchartBaseConfig,
+    vchartTheme
+];
+const columnParallelAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    reshapeTo2D1M,
+    encodingXY,
+    vchartBaseConfig,
+    vchartTheme
+];
+const columnPercentAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    reshapeTo2D1M,
+    encodingXY,
+    vchartBaseConfig,
+    vchartTheme
+];
+const areaAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    reshapeTo2D1M,
+    encodingXY,
+    vchartBaseConfig,
+    vchartTheme
+];
+const areaPercentAdvancedPipeline = [
+    initAdvancedVSeed,
+    autoMeasures,
+    autoDimensions,
+    reshapeTo2D1M,
+    encodingXY,
+    vchartBaseConfig,
+    vchartTheme
+];
+const dataset_dataset = (spec, context)=>{
+    const { advancedVSeed } = context;
+    return {
+        ...spec,
+        data: {
+            values: advancedVSeed.dataset
+        }
+    };
+};
+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;
+    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;
+    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 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'
+        }
+    ];
+    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'
+        }
+    ];
+    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 color_color = (spec, context)=>{
+    const result = {
+        ...spec
+    };
+    const { advancedVSeed } = context;
+    const { datasetReshapeInfo } = advancedVSeed;
+    const { unfoldInfo } = datasetReshapeInfo;
+    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 lineSpecPipeline = [
+    initLine,
+    color_color,
+    background_backgroundColor,
+    dataset_dataset,
+    xBand,
+    yLinear,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const columnSpecPipeline = [
+    initColumn,
+    color_color,
+    background_backgroundColor,
+    dataset_dataset,
+    xBand,
+    yLinear,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const columnParallelSpecPipeline = [
+    initColumnParallel,
+    color_color,
+    background_backgroundColor,
+    dataset_dataset,
+    xBand,
+    yLinear,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const columnPercentSpecPipeline = [
+    initColumn,
+    color_color,
+    background_backgroundColor,
+    percent,
+    dataset_dataset,
+    xBand,
+    yLinear,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const barSpecPipeline = [
+    initBar,
+    color_color,
+    background_backgroundColor,
+    dataset_dataset,
+    xLinear,
+    yBand,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const barParallelSpecPipeline = [
+    initBarParallel,
+    color_color,
+    background_backgroundColor,
+    dataset_dataset,
+    xLinear,
+    yBand,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const barPercentSpecPipeline = [
+    initBar,
+    color_color,
+    background_backgroundColor,
+    percent,
+    dataset_dataset,
+    xLinear,
+    yBand,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const areaSpecPipeline = [
+    initArea,
+    color_color,
+    background_backgroundColor,
+    stack,
+    dataset_dataset,
+    xBand,
+    yLinear,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+const areaPercentSpecPipeline = [
+    initArea,
+    color_color,
+    background_backgroundColor,
+    percent,
+    dataset_dataset,
+    xBand,
+    yLinear,
+    label_label,
+    tooltip_tooltip,
+    legend_legend
+];
+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 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.object({
+    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