@visactor/vseed 0.0.2 → 0.0.4

package/dist/types/{properties/vseed.d.ts → vseed.d.ts}

@@ -1,8 +1,20 @@
 import { z } from 'zod';
-import type { ChartType } from './chartType';
-import type { Dataset } from './dataset';
-import type { Dimensions } from './dimensions';
-import type { Measures } from './measures';
+import type { Bar } from './chartType/bar';
+import type { BarParallel } from './chartType/barParallel';
+import type { Column } from './chartType/column';
+import type { ColumnParallel } from './chartType/columnParallel';
+import type { ColumnPercent } from './chartType/columnPercent';
+import type { Line } from './chartType/line';
+import type { Table } from './chartType/table';
+import type { Rose } from './chartType/rose';
+import type { BarPercent } from './chartType/barPercent';
+import type { PivotTable } from './chartType/pivotTable';
+import type { Pie } from './chartType/pie';
+import type { Donut } from './chartType/donut';
+import type { DualAxis } from './chartType/dualAxis';
+import type { Area } from './chartType/area';
+import type { AreaPercent } from './chartType/areaPercent';
+export type VSeed = Table | PivotTable | Line | Column | ColumnParallel | ColumnPercent | Bar | BarParallel | BarPercent | Area | AreaPercent | DualAxis | Rose | Pie | Donut;
 export declare const zVSeed: z.ZodObject<{
     chartType: z.ZodEnum<{
         table: "table";
@@ -84,11 +96,6 @@ export declare const zVSeed: z.ZodObject<{
             suffix: z.ZodDefault<z.ZodOptional<z.ZodString>>;
         }, z.core.$strip>>;
     }, z.core.$strip>]>>>;
+    backgroundColor: z.ZodOptional<z.ZodDefault<z.ZodString>>;
 }, z.core.$strip>;
-export type VSeed = {
-    chartType: ChartType;
-    dataset: Dataset;
-    dimensions?: Dimensions;
-    measures?: Measures;
-};
 export declare const VSeedJSONSchema: z.core.JSONSchema.JSONSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visactor/vseed",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "exports": {
     ".": {
@@ -15,6 +15,7 @@
     "dist"
   ],
   "dependencies": {
+    "remeda": "^2.28.0",
     "zod": "4.0.14"
   },
   "peerDependencies": {

package/dist/builder/register/register.d.ts

@@ -1,3 +0,0 @@
-export declare const registerAll: () => void;
-export declare const registerColumn: () => void;
-export declare const registerBar: () => void;

package/dist/index.cjs

@@ -1,648 +0,0 @@
-"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__, {
-    registerAll: ()=>registerAll,
-    dataReshapeFor1D1M: ()=>dataReshapeFor1D1M,
-    zDatasetReshapeInfo: ()=>zDatasetReshapeInfo,
-    barAdvancedPipeline: ()=>barAdvancedPipeline,
-    zDatum: ()=>zDatum,
-    zFoldInfo: ()=>zFoldInfo,
-    execPipeline: ()=>execPipeline,
-    zDataset: ()=>zDataset,
-    zMeasureGroup: ()=>zMeasureGroup,
-    columnAdvancedPipeline: ()=>columnAdvancedPipeline,
-    dataReshapeFor2D1M: ()=>dataReshapeFor2D1M,
-    foldMeasures: ()=>foldMeasures,
-    zUnfoldInfo: ()=>zUnfoldInfo,
-    registerColumn: ()=>registerColumn,
-    zChartType: ()=>zChartType,
-    zDimension: ()=>zDimension,
-    zMeasures: ()=>zMeasures,
-    zMeasure: ()=>zMeasure,
-    zDimensions: ()=>zDimensions,
-    zVSeed: ()=>zVSeed,
-    barSpecPipeline: ()=>barSpecPipeline,
-    zEncoding: ()=>zEncoding,
-    unfoldDimensions: ()=>unfoldDimensions,
-    VSeedJSONSchema: ()=>VSeedJSONSchema,
-    Builder: ()=>Builder,
-    columnSpecPipeline: ()=>columnSpecPipeline,
-    zAdvancedVSeed: ()=>zAdvancedVSeed,
-    registerBar: ()=>registerBar
-});
-const execPipeline = (pipeline, context, initialValue = {})=>{
-    const result = pipeline.reduce((prev, cur)=>cur(prev, context), initialValue);
-    return result;
-};
-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
-    };
-    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)=>{
-    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;
-    static _advancedPipelineMap = {};
-    static _specPipelineMap = {};
-    static from = (vseed)=>new Builder(vseed);
-    constructor(vseed){
-        this._vseed = vseed;
-        this._advancedVSeed = null;
-    }
-    build = ()=>build(this);
-    buildSpec = (advanced)=>buildSpec(this, advanced);
-    buildAdvanced = ()=>buildAdvanced(this);
-    getAdvancedPipeline = (chartType)=>Builder._advancedPipelineMap[chartType];
-    getSpecPipeline = (chartType)=>Builder._specPipelineMap[chartType];
-    get vseed() {
-        return this._vseed;
-    }
-    set vseed(value) {
-        this._vseed = value;
-    }
-    get advancedVSeed() {
-        return this._advancedVSeed;
-    }
-    set advancedVSeed(value) {
-        this._advancedVSeed = value;
-    }
-}
-const FoldMeasureName = '__MeaName__';
-const FoldMeasureValue = '__MeaValue__';
-const FoldMeasureId = '__MeaId__';
-const FoldDimensionGroup = '__DimGroup__';
-const Separator = '-';
-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 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 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 reshapeTo2D1M = (advancedVSeed, context)=>{
-    const result = {
-        ...advancedVSeed
-    };
-    const { vseed } = context;
-    const { dimensions, measures, dataset } = vseed;
-    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 encodingCartesian = (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 columnAdvancedPipeline = [
-    reshapeTo2D1M,
-    encodingCartesian
-];
-const initColumn = (spec, context)=>{
-    const result = {
-        ...spec
-    };
-    const { advancedVSeed } = context;
-    const { encoding } = advancedVSeed;
-    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.data = {
-        values: advancedVSeed.dataset
-    };
-    return result;
-};
-const dataset_dataset = (spec, context)=>{
-    const { advancedVSeed } = context;
-    return {
-        ...spec,
-        data: {
-            values: advancedVSeed.dataset
-        }
-    };
-};
-const xBand = (spec)=>{
-    const result = {
-        ...spec
-    };
-    if (!result.axes) result.axes = [];
-    result.axes = [
-        ...result.axes,
-        {
-            visible: true,
-            type: 'band',
-            orient: 'bottom'
-        }
-    ];
-    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 columnSpecPipeline = [
-    initColumn,
-    dataset_dataset,
-    xBand,
-    yLinear
-];
-const barAdvancedPipeline = [
-    reshapeTo2D1M,
-    encodingCartesian
-];
-const initBar = (spec, context)=>{
-    const result = {
-        ...spec
-    };
-    const { advancedVSeed } = context;
-    const { encoding } = advancedVSeed;
-    result.type = 'bar';
-    result.direction = 'horizontal';
-    result.yField = encoding[0].x?.[0];
-    result.xField = encoding[0].y?.[0];
-    result.seriesField = encoding[0].group?.[0];
-    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 barSpecPipeline = [
-    initBar,
-    dataset_dataset,
-    xLinear,
-    yBand
-];
-const registerAll = ()=>{
-    registerColumn();
-    registerBar();
-};
-const registerColumn = ()=>{
-    Builder._advancedPipelineMap.column = columnAdvancedPipeline;
-    Builder._specPipelineMap.column = columnSpecPipeline;
-};
-const registerBar = ()=>{
-    Builder._advancedPipelineMap.bar = barAdvancedPipeline;
-    Builder._specPipelineMap.bar = barSpecPipeline;
-};
-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 zVSeed = external_zod_namespaceObject.z.object({
-    chartType: zChartType,
-    dataset: zDataset,
-    dimensions: zDimensions,
-    measures: zMeasures
-});
-const VSeedJSONSchema = external_zod_namespaceObject.z.toJSONSchema(zVSeed);
-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 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.object({
-    foldInfo: zFoldInfo,
-    unfoldInfo: zUnfoldInfo
-});
-const zAdvancedVSeed = external_zod_namespaceObject.z.object({
-    chartType: zChartType,
-    dataset: zDataset,
-    datasetReshapeInfo: zDatasetReshapeInfo,
-    dimensions: zDimensions,
-    measures: zMeasures,
-    encoding: zEncoding
-});
-const dataReshapeFor1D1M_emptyReshapeResult = {
-    dataset: [],
-    foldInfo: {
-        foldMap: {},
-        measureId: '',
-        measureName: '',
-        measureValue: ''
-    },
-    unfoldInfo: {
-        groupName: '',
-        colorItems: []
-    }
-};
-const 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
-        };
-    }
-};
-exports.Builder = __webpack_exports__.Builder;
-exports.VSeedJSONSchema = __webpack_exports__.VSeedJSONSchema;
-exports.barAdvancedPipeline = __webpack_exports__.barAdvancedPipeline;
-exports.barSpecPipeline = __webpack_exports__.barSpecPipeline;
-exports.columnAdvancedPipeline = __webpack_exports__.columnAdvancedPipeline;
-exports.columnSpecPipeline = __webpack_exports__.columnSpecPipeline;
-exports.dataReshapeFor1D1M = __webpack_exports__.dataReshapeFor1D1M;
-exports.dataReshapeFor2D1M = __webpack_exports__.dataReshapeFor2D1M;
-exports.execPipeline = __webpack_exports__.execPipeline;
-exports.foldMeasures = __webpack_exports__.foldMeasures;
-exports.registerAll = __webpack_exports__.registerAll;
-exports.registerBar = __webpack_exports__.registerBar;
-exports.registerColumn = __webpack_exports__.registerColumn;
-exports.unfoldDimensions = __webpack_exports__.unfoldDimensions;
-exports.zAdvancedVSeed = __webpack_exports__.zAdvancedVSeed;
-exports.zChartType = __webpack_exports__.zChartType;
-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.zMeasure = __webpack_exports__.zMeasure;
-exports.zMeasureGroup = __webpack_exports__.zMeasureGroup;
-exports.zMeasures = __webpack_exports__.zMeasures;
-exports.zUnfoldInfo = __webpack_exports__.zUnfoldInfo;
-exports.zVSeed = __webpack_exports__.zVSeed;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "Builder",
-    "VSeedJSONSchema",
-    "barAdvancedPipeline",
-    "barSpecPipeline",
-    "columnAdvancedPipeline",
-    "columnSpecPipeline",
-    "dataReshapeFor1D1M",
-    "dataReshapeFor2D1M",
-    "execPipeline",
-    "foldMeasures",
-    "registerAll",
-    "registerBar",
-    "registerColumn",
-    "unfoldDimensions",
-    "zAdvancedVSeed",
-    "zChartType",
-    "zDataset",
-    "zDatasetReshapeInfo",
-    "zDatum",
-    "zDimension",
-    "zDimensions",
-    "zEncoding",
-    "zFoldInfo",
-    "zMeasure",
-    "zMeasureGroup",
-    "zMeasures",
-    "zUnfoldInfo",
-    "zVSeed"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});