@visactor/vseed 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,2 +1,533 @@
-const squared = (n)=>n * n;
-export { squared };
+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 { 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 barAdvancedPipeline = [
+    reshapeTo2D1M,
+    encodingCartesian
+];
+const columnAdvancedPipeline = [
+    reshapeTo2D1M,
+    encodingCartesian
+];
+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;
+    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 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 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 columnSpecPipeline = [
+    initColumn,
+    dataset_dataset,
+    xBand,
+    yLinear
+];
+const barSpecPipeline = [
+    initBar,
+    dataset_dataset,
+    xLinear,
+    yBand
+];
+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 registerAll = ()=>{
+    registerColumn();
+    registerBar();
+};
+const registerColumn = ()=>{
+    Builder._advancedPipelineMap.column = columnAdvancedPipeline;
+    Builder._specPipelineMap.column = columnSpecPipeline;
+};
+const registerBar = ()=>{
+    Builder._advancedPipelineMap.bar = barAdvancedPipeline;
+    Builder._specPipelineMap.bar = barSpecPipeline;
+};
+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 zVSeed = z.object({
+    chartType: zChartType,
+    dataset: zDataset,
+    dimensions: zDimensions,
+    measures: zMeasures
+});
+const VSeedJSONSchema = z.toJSONSchema(zVSeed);
+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 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 zAdvancedVSeed = z.object({
+    chartType: zChartType,
+    dataset: zDataset,
+    datasetReshapeInfo: zDatasetReshapeInfo,
+    dimensions: zDimensions,
+    measures: zMeasures,
+    encoding: zEncoding
+});
+export { Builder, VSeedJSONSchema, barAdvancedPipeline, barSpecPipeline, columnAdvancedPipeline, columnSpecPipeline, dataReshapeFor1D1M_dataReshapeFor1D1M as dataReshapeFor1D1M, dataReshapeFor2D1M, execPipeline, foldMeasures, registerAll, registerBar, registerColumn, unfoldDimensions, zAdvancedVSeed, zChartType, zDataset, zDatasetReshapeInfo, zDatum, zDimension, zDimensions, zEncoding, zFoldInfo, zMeasure, zMeasureGroup, zMeasures, zUnfoldInfo, zVSeed };

package/dist/pipeline/advanced/index.d.ts

@@ -0,0 +1 @@
+export * from './pipeline';

package/dist/pipeline/advanced/pipeline/bar.d.ts

@@ -0,0 +1,2 @@
+import type { AdvancedPipeline } from '../../../types';
+export declare const barAdvancedPipeline: AdvancedPipeline;

package/dist/pipeline/advanced/pipeline/column.d.ts

@@ -0,0 +1,2 @@
+import type { AdvancedPipeline } from '../../../types';
+export declare const columnAdvancedPipeline: AdvancedPipeline;

package/dist/pipeline/advanced/pipeline/index.d.ts

@@ -0,0 +1,2 @@
+export { barAdvancedPipeline } from './bar';
+export { columnAdvancedPipeline } from './column';

package/dist/pipeline/advanced/pipes/encoding/encodingCartesian.d.ts

@@ -0,0 +1,2 @@
+import type { AdvancedPipe } from '../../../../types';
+export declare const encodingCartesian: AdvancedPipe;

package/dist/pipeline/advanced/pipes/encoding/index.d.ts

@@ -0,0 +1 @@
+export { encodingCartesian } from './encodingCartesian';

package/dist/pipeline/advanced/pipes/index.d.ts

@@ -0,0 +1,2 @@
+export * from './reshape';
+export * from './encoding';

package/dist/pipeline/advanced/pipes/reshape/index.d.ts

@@ -0,0 +1,2 @@
+export { reshapeTo2D1M } from './reshapeTo2D1M';
+export { reshapeTo1D1M } from './reshapeTo1D1M';

package/dist/pipeline/advanced/pipes/reshape/reshapeTo1D1M.d.ts

@@ -0,0 +1,8 @@
+import type { AdvancedPipe } from '../../../../types';
+/**
+ * 数据重塑, 将任意维度、任意指标, 重塑为2个维度1个指标.
+ * @param advancedVSeed
+ * @param context
+ * @returns
+ */
+export declare const reshapeTo1D1M: AdvancedPipe;

package/dist/pipeline/advanced/pipes/reshape/reshapeTo2D1M.d.ts

@@ -0,0 +1,8 @@
+import type { AdvancedPipe } from '../../../../types';
+/**
+ * 数据重塑, 将任意维度、任意指标, 重塑为2个维度1个指标.
+ * @param advancedVSeed
+ * @param context
+ * @returns
+ */
+export declare const reshapeTo2D1M: AdvancedPipe;

package/dist/pipeline/index.d.ts

@@ -0,0 +1,3 @@
+export * from './advanced';
+export * from './spec';
+export * from './utils';

package/dist/pipeline/spec/index.d.ts

@@ -0,0 +1 @@
+export * from './pipeline';

package/dist/pipeline/spec/pipeline/bar.d.ts

@@ -0,0 +1,2 @@
+import type { SpecPipeline } from '../../../types';
+export declare const barSpecPipeline: SpecPipeline;

package/dist/pipeline/spec/pipeline/column.d.ts

@@ -0,0 +1,2 @@
+import type { SpecPipeline } from '../../../types';
+export declare const columnSpecPipeline: SpecPipeline;

package/dist/pipeline/spec/pipeline/index.d.ts

@@ -0,0 +1,2 @@
+export { columnSpecPipeline } from './column';
+export { barSpecPipeline } from './bar';

package/dist/pipeline/spec/pipes/axes/index.d.ts

@@ -0,0 +1,4 @@
+export { xBand } from './xBand';
+export { xLinear } from './xLinear';
+export { yBand } from './yBand';
+export { yLinear } from './yLinear';

package/dist/pipeline/spec/pipes/axes/xBand.d.ts

@@ -0,0 +1,2 @@
+import type { SpecPipe } from '../../../../types';
+export declare const xBand: SpecPipe;

package/dist/pipeline/spec/pipes/axes/xLinear.d.ts

@@ -0,0 +1,2 @@
+import type { SpecPipe } from '../../../../types';
+export declare const xLinear: SpecPipe;

package/dist/pipeline/spec/pipes/axes/yBand.d.ts

@@ -0,0 +1,2 @@
+import type { SpecPipe } from '../../../../types';
+export declare const yBand: SpecPipe;

package/dist/pipeline/spec/pipes/axes/yLinear.d.ts

@@ -0,0 +1,2 @@
+import type { SpecPipe } from '../../../../types';
+export declare const yLinear: SpecPipe;

package/dist/pipeline/spec/pipes/dataset/dataset.d.ts

@@ -0,0 +1,2 @@
+import type { SpecPipe } from '../../../../types';
+export declare const dataset: SpecPipe;

package/dist/pipeline/spec/pipes/dataset/index.d.ts

@@ -0,0 +1 @@
+export { dataset } from './dataset';

package/dist/pipeline/spec/pipes/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dataset';
+export * from './init';
+export * from './axes';

package/dist/pipeline/spec/pipes/init/bar.d.ts

@@ -0,0 +1,2 @@
+import type { SpecPipe } from '../../../../types';
+export declare const initBar: SpecPipe;

package/dist/pipeline/spec/pipes/init/column.d.ts

@@ -0,0 +1,2 @@
+import type { SpecPipe } from '../../../../types';
+export declare const initColumn: SpecPipe;

package/dist/pipeline/spec/pipes/init/index.d.ts

@@ -0,0 +1,2 @@
+export { initColumn } from './column';
+export { initBar } from './bar';

package/dist/pipeline/utils/index.d.ts

@@ -0,0 +1 @@
+export { execPipeline } from './pipeline';

package/dist/pipeline/utils/pipeline.d.ts

@@ -0,0 +1,9 @@
+import type { ExecPipelineType } from '../../types';
+/**
+ * 执行pipeline, 每个pipe负责构建结果的一部分, 构建完成后得到完整的目标结果
+ * @param pipeline pipeline数组, 每个pipe负责构建结果的一部分
+ * @param initialValue 初始值
+ * @param context 上下文
+ * @returns 执行后的结果
+ */
+export declare const execPipeline: ExecPipelineType;

package/dist/types/builder/builder.d.ts

@@ -0,0 +1,10 @@
+import type { ISpec } from '@visactor/vchart';
+import type { AdvancedVSeed, VSeed } from '../properties';
+export interface VSeedBuilder {
+    build: () => ISpec;
+    buildAdvanced: () => AdvancedVSeed | null;
+    buildSpec: (advancedVSeed: AdvancedVSeed) => ISpec;
+    get vseed(): VSeed;
+    get advancedVSeed(): VSeed | null;
+    set advancedVSeed(value: VSeed | null);
+}