@visactor/vseed 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -24,12 +24,624 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    squared: ()=>squared
+    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 squared = (n)=>n * n;
-exports.squared = __webpack_exports__.squared;
+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 === [
-    "squared"
+    "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

package/dist/index.d.ts

@@ -1 +1,5 @@
-export declare const squared: (n: number) => number;
+export { Builder } from './builder';
+export { registerColumn, registerAll, registerBar } from './builder/register';
+export * from './types';
+export * from './pipeline';
+export * from './dataReshape';