@visactor/vbi 0.4.15 → 0.4.17

package/dist/index.cjs

@@ -24,102 +24,268 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    preorderTraverse: ()=>vseed_namespaceObject.preorderTraverse,
+    HavingFilterBuilder: ()=>HavingFilterBuilder,
+    WhereFilterBuilder: ()=>WhereFilterBuilder,
     isVBIHavingGroup: ()=>isVBIHavingGroup,
+    VBIBuilder: ()=>VBIBuilder,
+    VBI: ()=>VBI,
+    isVBIHavingFilter: ()=>isVBIHavingFilter,
+    findTreeNodesBy: ()=>vseed_namespaceObject.findTreeNodesBy,
+    ThemeBuilder: ()=>ThemeBuilder,
+    id: ()=>id_id,
     MeasuresBuilder: ()=>MeasuresBuilder,
+    LimitBuilder: ()=>LimitBuilder,
     DimensionsBuilder: ()=>DimensionsBuilder,
-    VBIBuilder: ()=>VBIBuilder,
     ChartTypeBuilder: ()=>ChartTypeBuilder,
     isVBIFilter: ()=>isVBIFilter,
-    VBI: ()=>VBI,
     isVBIWhereGroup: ()=>isVBIWhereGroup,
-    isVBIHavingFilter: ()=>isVBIHavingFilter,
+    preorderTraverse: ()=>vseed_namespaceObject.preorderTraverse,
     buildVQuery: ()=>buildVQuery,
-    findTreeNodesBy: ()=>vseed_namespaceObject.findTreeNodesBy,
-    id: ()=>id_id
+    LocaleBuilder: ()=>LocaleBuilder,
+    UndoManager: ()=>UndoManager
 });
+const connectorMap = new Map();
+const registerConnector = (id, connector)=>{
+    connectorMap.set(id, connector);
+};
+const getConnector = async (id)=>{
+    const connector = connectorMap.get(id);
+    if (!connector) throw new Error(`connector ${id} not registered`);
+    if ('function' == typeof connector) return connector();
+    return connector;
+};
 const external_yjs_namespaceObject = require("yjs");
-class DimensionNodeBuilder {
-    yMap;
-    constructor(yMap){
-        this.yMap = yMap;
-    }
-    getField() {
-        return this.yMap.get('field');
-    }
-    setAlias(alias) {
-        this.yMap.set('alias', alias);
-        return this;
-    }
-    toJson() {
-        return this.yMap.toJSON();
-    }
+const applyUpdateToDoc = (doc, update, transactionOrigin)=>{
+    external_yjs_namespaceObject.applyUpdate(doc, update, transactionOrigin);
+};
+const encodeDocStateAsUpdate = (doc, targetStateVector)=>external_yjs_namespaceObject.encodeStateAsUpdate(doc, targetStateVector);
+const buildVBIDSL = (dsl)=>dsl.toJSON();
+const external_remeda_namespaceObject = require("remeda");
+const buildSelect = (queryDSL, context)=>{
+    const { vbiDSL } = context;
+    const measures = vbiDSL.measures;
+    const dimensions = vbiDSL.dimensions;
+    const result = {
+        ...queryDSL
+    };
+    const measureNodes = measures.filter((measure)=>MeasuresBuilder.isMeasureNode(measure));
+    const measureSelects = measureNodes.map((measure)=>({
+            field: measure.field,
+            alias: measure.alias,
+            aggr: measure.aggregate
+        }));
+    const dimensionNodes = dimensions.filter((dimension)=>DimensionsBuilder.isDimensionNode(dimension));
+    const dimensionSelects = dimensionNodes.map((dimension)=>({
+            field: dimension.field,
+            alias: dimension.alias
+        }));
+    result.select = measureSelects.concat(dimensionSelects);
+    return result;
+};
+const buildGroupBy = (queryDSL, context)=>{
+    const result = {
+        ...queryDSL
+    };
+    const { vbiDSL } = context;
+    const dimensions = vbiDSL.dimensions;
+    const dimensionNodes = dimensions.filter((dimension)=>DimensionsBuilder.isDimensionNode(dimension));
+    result.groupBy = dimensionNodes.map((dimension)=>dimension.field);
+    return result;
+};
+const buildWhere = (queryDSL, context)=>{
+    const { vbiDSL } = context;
+    const whereFilter = vbiDSL.whereFilter;
+    if (!whereFilter || 0 === whereFilter.conditions.length) return queryDSL;
+    const result = {
+        ...queryDSL
+    };
+    result.where = mapGroupToCondition(whereFilter);
+    return result;
+};
+function isWhereGroup(clause) {
+    return 'op' in clause && 'conditions' in clause;
 }
-class DimensionsBuilder {
-    dsl;
-    constructor(_doc, dsl){
-        this.dsl = dsl;
-    }
-    add(field, callback) {
-        const dimension = {
-            alias: field,
-            field
-        };
-        const yMap = new external_yjs_namespaceObject.Map();
-        for (const [key, value] of Object.entries(dimension))yMap.set(key, value);
-        this.dsl.get('dimensions').push([
-            yMap
-        ]);
-        const node = new DimensionNodeBuilder(yMap);
-        callback(node);
-        return this;
-    }
-    remove(field) {
-        const dimensions = this.dsl.get('dimensions');
-        const index = dimensions.toArray().findIndex((item)=>item.get('field') === field);
-        if (-1 !== index) this.dsl.get('dimensions').delete(index, 1);
-        return this;
-    }
-    update(field, callback) {
-        const dimensions = this.dsl.get('dimensions');
-        const index = dimensions.toArray().findIndex((item)=>item.get('field') === field);
-        if (-1 === index) throw new Error(`Dimension with field "${field}" not found`);
-        const dimensionYMap = dimensions.get(index);
-        const node = new DimensionNodeBuilder(dimensionYMap);
-        callback(node);
-        return this;
-    }
-    find(field) {
-        const dimensions = this.dsl.get('dimensions');
-        const index = dimensions.toArray().findIndex((item)=>item.get('field') === field);
-        if (-1 === index) return;
-        return new DimensionNodeBuilder(dimensions.get(index));
-    }
-    findAll() {
-        const dimensions = this.dsl.get('dimensions');
-        return dimensions.toArray().map((yMap)=>new DimensionNodeBuilder(yMap));
-    }
-    toJson() {
-        return this.dsl.get('dimensions').toJSON();
-    }
-    observe(callback) {
-        this.dsl.get('dimensions').observe(callback);
-        return ()=>{
-            this.dsl.get('dimensions').unobserve(callback);
-        };
-    }
-    static isDimensionNode(node) {
-        return 'alias' in node && !('children' in node);
+function mapClauseToCondition(clause) {
+    if (isWhereGroup(clause)) return [
+        mapGroupToCondition(clause)
+    ];
+    return mapFilterToCondition(clause);
+}
+function mapGroupToCondition(group) {
+    return {
+        op: group.op,
+        conditions: group.conditions.flatMap(mapClauseToCondition)
+    };
+}
+function mapFilterToCondition(filter) {
+    if ('between' === filter.op || 'not between' === filter.op) return handleBetweenFilter(filter);
+    return handleSimpleFilter(filter);
+}
+function handleBetweenFilter(filter) {
+    const value = normalizeBetweenValue(filter.value);
+    const lowerCondition = void 0 !== value.min && null !== value.min && '' !== value.min ? {
+        field: filter.field,
+        op: '<' === value.leftOp ? '>' : '>=',
+        value: value.min
+    } : void 0;
+    const upperCondition = void 0 !== value.max && null !== value.max && '' !== value.max ? {
+        field: filter.field,
+        op: '<' === value.rightOp ? '<' : '<=',
+        value: value.max
+    } : void 0;
+    if ('not between' === filter.op) {
+        const outsideConditions = [
+            lowerCondition && invertLowerBound(lowerCondition),
+            upperCondition && invertUpperBound(upperCondition)
+        ].filter(Boolean);
+        if (outsideConditions.length <= 1) return outsideConditions;
+        return [
+            {
+                op: 'or',
+                conditions: outsideConditions
+            }
+        ];
     }
-    static isDimensionGroup(node) {
-        return 'children' in node;
+    return [
+        lowerCondition,
+        upperCondition
+    ].filter(Boolean);
+}
+function normalizeBetweenValue(value) {
+    if (Array.isArray(value)) return {
+        min: value[0],
+        max: value[1],
+        leftOp: '<=',
+        rightOp: '<='
+    };
+    if ('object' == typeof value && null !== value) return value;
+    return {};
+}
+function invertLowerBound(condition) {
+    return {
+        field: condition.field,
+        op: '>' === condition.op ? '<=' : '<',
+        value: condition.value
+    };
+}
+function invertUpperBound(condition) {
+    return {
+        field: condition.field,
+        op: '<' === condition.op ? '>=' : '>',
+        value: condition.value
+    };
+}
+function handleSimpleFilter(filter) {
+    let mappedOp = filter.op ?? '=';
+    const value = filter.value;
+    if (Array.isArray(value)) {
+        if ('=' === mappedOp) mappedOp = 'in';
+        if ('!=' === mappedOp) mappedOp = 'not in';
     }
+    return [
+        {
+            field: filter.field,
+            op: mappedOp,
+            value
+        }
+    ];
+}
+const buildHaving = (queryDSL, context)=>{
+    const { vbiDSL } = context;
+    const havingFilter = vbiDSL.havingFilter;
+    if (!havingFilter || 0 === havingFilter.conditions.length) return queryDSL;
+    const result = {
+        ...queryDSL
+    };
+    result.having = {
+        op: havingFilter.op,
+        conditions: havingFilter.conditions.flatMap(buildHaving_mapClauseToCondition)
+    };
+    return result;
+};
+function isHavingGroup(clause) {
+    return 'op' in clause && 'conditions' in clause;
+}
+function buildHaving_mapClauseToCondition(clause) {
+    if (isHavingGroup(clause)) return [
+        buildHaving_mapGroupToCondition(clause)
+    ];
+    return buildHaving_mapFilterToCondition(clause);
+}
+function buildHaving_mapGroupToCondition(group) {
+    return {
+        op: group.op,
+        conditions: group.conditions.flatMap(buildHaving_mapClauseToCondition)
+    };
+}
+function buildHaving_mapFilterToCondition(filter) {
+    const mappedOp = filter.op ?? '=';
+    return [
+        {
+            field: filter.field,
+            op: mappedOp,
+            value: filter.value
+        }
+    ];
 }
+const buildLimit = (queryDSL, context)=>{
+    const result = {
+        ...queryDSL
+    };
+    const limit = context.vbiDSL.limit ?? 1000;
+    result.limit = limit;
+    return result;
+};
+const buildVQuery = (vbiDSL, builder)=>{
+    const wrapper = (processor)=>(queryDSL)=>processor(queryDSL, {
+                vbiDSL,
+                builder
+            });
+    return (0, external_remeda_namespaceObject.pipe)({}, wrapper(buildSelect), wrapper(buildGroupBy), wrapper(buildWhere), wrapper(buildHaving), wrapper(buildLimit));
+};
+const buildVQueryDSL = (dsl, builder)=>{
+    const vbiDSL = buildVBIDSL(dsl);
+    return buildVQuery(vbiDSL, builder);
+};
+const buildVSeedDSL = async ({ vbiDSL, queryDSL })=>{
+    const connectorId = vbiDSL.connectorId;
+    const connector = await getConnector(connectorId);
+    const schema = await connector.discoverSchema();
+    const queryResult = await connector.query({
+        queryDSL,
+        schema,
+        connectorId
+    });
+    return {
+        chartType: vbiDSL.chartType,
+        dataset: queryResult.dataset,
+        theme: vbiDSL.theme,
+        locale: vbiDSL.locale
+    };
+};
+const getCollectionLength = (value)=>{
+    if (value instanceof external_yjs_namespaceObject.Array) return value.length;
+    if (Array.isArray(value)) return value.length;
+    return 0;
+};
+const isEmptyVBIDSL = (dsl)=>{
+    const dimensionsLength = getCollectionLength(dsl.get('dimensions'));
+    const measuresLength = getCollectionLength(dsl.get('measures'));
+    return 0 === dimensionsLength && 0 === measuresLength;
+};
+const getBuilderSchema = async (dsl)=>{
+    const connectorId = dsl.get('connectorId');
+    const connector = await getConnector(connectorId);
+    return connector.discoverSchema();
+};
 class MeasureNodeBuilder {
     yMap;
     constructor(yMap){
         this.yMap = yMap;
     }
+    getId() {
+        return this.yMap.get('id');
+    }
     getField() {
         return this.yMap.get('field');
     }
@@ -135,17 +301,52 @@ class MeasureNodeBuilder {
         this.yMap.set('aggregate', aggregate);
         return this;
     }
-    toJson() {
+    toJSON() {
         return this.yMap.toJSON();
     }
 }
+const vseed_namespaceObject = require("@visactor/vseed");
+const external_uuid_namespaceObject = require("uuid");
+const id_id = {
+    uuid: ()=>(0, external_uuid_namespaceObject.v4)()
+};
+function isVBIFilter(clause) {
+    return 'field' in clause;
+}
+function isVBIWhereGroup(clause) {
+    return 'conditions' in clause;
+}
+function isVBIHavingFilter(clause) {
+    return 'field' in clause;
+}
+function isVBIHavingGroup(clause) {
+    return 'conditions' in clause;
+}
+const getOrCreateMeasures = (dsl)=>{
+    const measures = dsl.get('measures');
+    if (measures instanceof external_yjs_namespaceObject.Array) return measures;
+    const yMeasures = new external_yjs_namespaceObject.Array();
+    dsl.set('measures', yMeasures);
+    return yMeasures;
+};
+const normalizeMeasureNodeIds = (measures)=>{
+    measures.toArray().forEach((item)=>{
+        if (item instanceof external_yjs_namespaceObject.Map && 'string' == typeof item.get('field') && !item.get('id')) item.set('id', id_id.uuid());
+    });
+};
+const locateMeasureIndexById = (measures, measureId)=>measures.toArray().findIndex((item)=>item.get('id') === measureId);
 class MeasuresBuilder {
     dsl;
-    constructor(_doc, dsl){
+    constructor(doc, dsl){
         this.dsl = dsl;
+        doc.transact(()=>{
+            const measures = getOrCreateMeasures(this.dsl);
+            normalizeMeasureNodeIds(measures);
+        });
     }
     add(field, callback) {
         const measure = {
+            id: id_id.uuid(),
             alias: field,
             field,
             encoding: 'yAxis',
@@ -155,45 +356,50 @@ class MeasuresBuilder {
         };
         const yMap = new external_yjs_namespaceObject.Map();
         for (const [key, value] of Object.entries(measure))yMap.set(key, value);
-        this.dsl.get('measures').push([
+        const measures = getOrCreateMeasures(this.dsl);
+        measures.push([
             yMap
         ]);
         const node = new MeasureNodeBuilder(yMap);
         callback(node);
         return this;
     }
-    remove(field) {
-        const measures = this.dsl.get('measures');
-        const index = measures.toArray().findIndex((item)=>item.get('field') === field);
-        if (-1 !== index) this.dsl.get('measures').delete(index, 1);
+    remove(id) {
+        const measures = getOrCreateMeasures(this.dsl);
+        const index = locateMeasureIndexById(measures, id);
+        if (-1 !== index) measures.delete(index, 1);
         return this;
     }
-    update(field, callback) {
-        const measures = this.dsl.get('measures');
-        const index = measures.toArray().findIndex((item)=>item.get('field') === field);
-        if (-1 === index) throw new Error(`Measure with field "${field}" not found`);
+    update(id, callback) {
+        const measures = getOrCreateMeasures(this.dsl);
+        const index = locateMeasureIndexById(measures, id);
+        if (-1 === index) throw new Error(`Measure with id "${id}" not found`);
         const measureYMap = measures.get(index);
         const node = new MeasureNodeBuilder(measureYMap);
         callback(node);
         return this;
     }
-    find(field) {
-        const measures = this.dsl.get('measures');
-        const index = measures.toArray().findIndex((item)=>item.get('field') === field);
-        if (-1 === index) return;
-        return new MeasureNodeBuilder(measures.get(index));
+    find(predicate) {
+        const measures = getOrCreateMeasures(this.dsl);
+        const items = measures.toArray();
+        for(let index = 0; index < items.length; index++){
+            const node = new MeasureNodeBuilder(items[index]);
+            if (predicate(node, index)) return node;
+        }
     }
     findAll() {
-        const measures = this.dsl.get('measures');
+        const measures = getOrCreateMeasures(this.dsl);
         return measures.toArray().map((yMap)=>new MeasureNodeBuilder(yMap));
     }
-    toJson() {
-        return this.dsl.get('measures').toJSON();
+    toJSON() {
+        const measures = getOrCreateMeasures(this.dsl);
+        return measures.toJSON();
     }
     observe(callback) {
-        this.dsl.get('measures').observe(callback);
+        const measures = getOrCreateMeasures(this.dsl);
+        measures.observe(callback);
         return ()=>{
-            this.dsl.get('measures').unobserve(callback);
+            measures.unobserve(callback);
         };
     }
     static isMeasureNode(node) {
@@ -203,12 +409,7 @@ class MeasuresBuilder {
         return 'children' in node;
     }
 }
-const vseed_namespaceObject = require("@visactor/vseed");
-const external_uuid_namespaceObject = require("uuid");
-const id_id = {
-    uuid: ()=>(0, external_uuid_namespaceObject.v4)()
-};
-class HavingFiltersNodeBuilder {
+class DimensionNodeBuilder {
     yMap;
     constructor(yMap){
         this.yMap = yMap;
@@ -219,26 +420,210 @@ class HavingFiltersNodeBuilder {
     getField() {
         return this.yMap.get('field');
     }
-    getOperator() {
-        return this.yMap.get('op');
-    }
-    setValue(value) {
-        this.yMap.set('value', value);
+    setAlias(alias) {
+        this.yMap.set('alias', alias);
+        return this;
+    }
+    toJSON() {
+        return this.yMap.toJSON();
+    }
+}
+const getOrCreateDimensions = (dsl)=>{
+    const dimensions = dsl.get('dimensions');
+    if (dimensions instanceof external_yjs_namespaceObject.Array) return dimensions;
+    const yDimensions = new external_yjs_namespaceObject.Array();
+    dsl.set('dimensions', yDimensions);
+    return yDimensions;
+};
+const normalizeDimensionNodeIds = (dimensions)=>{
+    dimensions.toArray().forEach((item)=>{
+        if (item instanceof external_yjs_namespaceObject.Map && 'string' == typeof item.get('field') && !item.get('id')) item.set('id', id_id.uuid());
+    });
+};
+const locateDimensionIndexById = (dimensions, dimensionId)=>dimensions.toArray().findIndex((item)=>item.get('id') === dimensionId);
+class DimensionsBuilder {
+    dsl;
+    constructor(doc, dsl){
+        this.dsl = dsl;
+        doc.transact(()=>{
+            const dimensions = getOrCreateDimensions(this.dsl);
+            normalizeDimensionNodeIds(dimensions);
+        });
+    }
+    add(field, callback) {
+        const dimension = {
+            id: id_id.uuid(),
+            alias: field,
+            field
+        };
+        const yMap = new external_yjs_namespaceObject.Map();
+        for (const [key, value] of Object.entries(dimension))yMap.set(key, value);
+        const dimensions = getOrCreateDimensions(this.dsl);
+        dimensions.push([
+            yMap
+        ]);
+        const node = new DimensionNodeBuilder(yMap);
+        callback(node);
+        return this;
+    }
+    remove(id) {
+        const dimensions = getOrCreateDimensions(this.dsl);
+        const index = locateDimensionIndexById(dimensions, id);
+        if (-1 !== index) dimensions.delete(index, 1);
         return this;
     }
+    update(id, callback) {
+        const dimensions = getOrCreateDimensions(this.dsl);
+        const index = locateDimensionIndexById(dimensions, id);
+        if (-1 === index) throw new Error(`Dimension with id "${id}" not found`);
+        const dimensionYMap = dimensions.get(index);
+        const node = new DimensionNodeBuilder(dimensionYMap);
+        callback(node);
+        return this;
+    }
+    find(predicate) {
+        const dimensions = getOrCreateDimensions(this.dsl);
+        const items = dimensions.toArray();
+        for(let index = 0; index < items.length; index++){
+            const node = new DimensionNodeBuilder(items[index]);
+            if (predicate(node, index)) return node;
+        }
+    }
+    findAll() {
+        const dimensions = getOrCreateDimensions(this.dsl);
+        return dimensions.toArray().map((yMap)=>new DimensionNodeBuilder(yMap));
+    }
+    toJSON() {
+        const dimensions = getOrCreateDimensions(this.dsl);
+        return dimensions.toJSON();
+    }
+    observe(callback) {
+        const dimensions = getOrCreateDimensions(this.dsl);
+        dimensions.observe(callback);
+        return ()=>{
+            dimensions.unobserve(callback);
+        };
+    }
+    static isDimensionNode(node) {
+        return 'alias' in node && !('children' in node);
+    }
+    static isDimensionGroup(node) {
+        return 'children' in node;
+    }
+}
+class ChartTypeBuilder {
+    dsl;
+    constructor(_doc, dsl){
+        this.dsl = dsl;
+    }
+    observe(callback) {
+        const wrapper = (e, trans)=>{
+            if (e.keysChanged.has('chartType')) callback(e, trans);
+        };
+        this.dsl.observe(wrapper);
+        return ()=>{
+            this.dsl.unobserve(wrapper);
+        };
+    }
+    changeChartType(chartType) {
+        this.dsl.set('chartType', chartType);
+    }
+    getChartType() {
+        return this.dsl.get('chartType') || 'table';
+    }
+    toJSON() {
+        return this.dsl.get('chartType') || 'table';
+    }
+    getAvailableChartTypes() {
+        return [
+            vseed_namespaceObject.ChartTypeEnum.Table,
+            vseed_namespaceObject.ChartTypeEnum.PivotTable,
+            vseed_namespaceObject.ChartTypeEnum.Line,
+            vseed_namespaceObject.ChartTypeEnum.Column,
+            vseed_namespaceObject.ChartTypeEnum.ColumnPercent,
+            vseed_namespaceObject.ChartTypeEnum.ColumnParallel,
+            vseed_namespaceObject.ChartTypeEnum.BarPercent,
+            vseed_namespaceObject.ChartTypeEnum.BarParallel,
+            vseed_namespaceObject.ChartTypeEnum.Area,
+            vseed_namespaceObject.ChartTypeEnum.AreaPercent,
+            vseed_namespaceObject.ChartTypeEnum.DualAxis,
+            vseed_namespaceObject.ChartTypeEnum.Scatter,
+            vseed_namespaceObject.ChartTypeEnum.Rose,
+            vseed_namespaceObject.ChartTypeEnum.RoseParallel,
+            vseed_namespaceObject.ChartTypeEnum.Pie,
+            vseed_namespaceObject.ChartTypeEnum.Donut,
+            vseed_namespaceObject.ChartTypeEnum.Radar,
+            vseed_namespaceObject.ChartTypeEnum.Funnel,
+            vseed_namespaceObject.ChartTypeEnum.Heatmap,
+            vseed_namespaceObject.ChartTypeEnum.Boxplot,
+            vseed_namespaceObject.ChartTypeEnum.Histogram
+        ];
+    }
+}
+function createWhereGroup(op = 'and', groupId = 'root') {
+    const yMap = new external_yjs_namespaceObject.Map();
+    yMap.set('id', groupId);
+    yMap.set('op', op);
+    yMap.set('conditions', new external_yjs_namespaceObject.Array());
+    return yMap;
+}
+function where_utils_isWhereGroup(yMap) {
+    return void 0 !== yMap.get('op') && void 0 !== yMap.get('conditions');
+}
+function findEntry(collection, entryId) {
+    const items = collection.toArray();
+    for(let index = 0; index < items.length; index++){
+        const item = items[index];
+        if (item.get('id') === entryId) return {
+            collection,
+            index,
+            item
+        };
+        if (where_utils_isWhereGroup(item)) {
+            const nestedCollection = item.get('conditions');
+            const nestedMatch = findEntry(nestedCollection, entryId);
+            if (nestedMatch) return nestedMatch;
+        }
+    }
+}
+class WhereFilterNodeBuilder {
+    yMap;
+    constructor(yMap){
+        this.yMap = yMap;
+    }
+    getId() {
+        return this.yMap.get('id');
+    }
+    getField() {
+        return this.yMap.get('field');
+    }
+    setField(field) {
+        this.yMap.set('field', field);
+        return this;
+    }
+    getOperator() {
+        return this.yMap.get('op');
+    }
     setOperator(operator) {
         this.yMap.set('op', operator);
         return this;
     }
-    toJson() {
+    setValue(value) {
+        this.yMap.set('value', value);
+        return this;
+    }
+    toJSON() {
         return this.yMap.toJSON();
     }
 }
-class HavingGroupBuilder {
+class WhereGroupBuilder {
     yMap;
     constructor(yMap){
         this.yMap = yMap;
     }
+    getConditions() {
+        return this.yMap.get('conditions');
+    }
     getId() {
         return this.yMap.get('id');
     }
@@ -253,29 +638,24 @@ class HavingGroupBuilder {
         const yMap = new external_yjs_namespaceObject.Map();
         yMap.set('id', id_id.uuid());
         yMap.set('field', field);
-        const conditions = this.yMap.get('conditions');
-        conditions.push([
+        this.getConditions().push([
             yMap
         ]);
-        const node = new HavingFiltersNodeBuilder(yMap);
+        const node = new WhereFilterNodeBuilder(yMap);
         callback(node);
         return this;
     }
     addGroup(op, callback) {
-        const yMap = new external_yjs_namespaceObject.Map();
-        yMap.set('id', id_id.uuid());
-        yMap.set('op', op);
-        yMap.set('conditions', new external_yjs_namespaceObject.Array());
-        const conditions = this.yMap.get('conditions');
-        conditions.push([
+        const yMap = createWhereGroup(op, id_id.uuid());
+        this.getConditions().push([
             yMap
         ]);
-        const group = new HavingGroupBuilder(yMap);
+        const group = new WhereGroupBuilder(yMap);
         callback(group);
         return this;
     }
     remove(idOrIndex) {
-        const conditions = this.yMap.get('conditions');
+        const conditions = this.getConditions();
         if ('number' == typeof idOrIndex) {
             if (idOrIndex >= 0 && idOrIndex < conditions.length) conditions.delete(idOrIndex, 1);
         } else {
@@ -285,154 +665,146 @@ class HavingGroupBuilder {
         return this;
     }
     clear() {
-        const conditions = this.yMap.get('conditions');
+        const conditions = this.getConditions();
         conditions.delete(0, conditions.length);
         return this;
     }
-    toJson() {
+    toJSON() {
         return this.yMap.toJSON();
     }
 }
-class HavingFiltersBuilder {
-    dsl;
-    doc;
+class WhereFilterBuilder {
+    whereFilter;
     constructor(doc, dsl){
-        this.doc = doc;
-        this.dsl = dsl;
-        if (!this.dsl.get('havingFilters')) this.doc.transact(()=>{
-            this.dsl.set('havingFilters', new external_yjs_namespaceObject.Array());
+        doc.transact(()=>{
+            const existingWhereFilter = dsl.get('whereFilter');
+            if (existingWhereFilter instanceof external_yjs_namespaceObject.Map) this.whereFilter = existingWhereFilter;
+            else {
+                this.whereFilter = createWhereGroup();
+                dsl.set('whereFilter', this.whereFilter);
+            }
+            if (!(this.whereFilter.get('conditions') instanceof external_yjs_namespaceObject.Array)) this.whereFilter.set('conditions', new external_yjs_namespaceObject.Array());
+            if (!this.whereFilter.get('id')) this.whereFilter.set('id', 'root');
+            if (!this.whereFilter.get('op')) this.whereFilter.set('op', 'and');
         });
     }
+    getConditions() {
+        return this.whereFilter.get('conditions');
+    }
     add(field, callback) {
         const yMap = new external_yjs_namespaceObject.Map();
         yMap.set('id', id_id.uuid());
         yMap.set('field', field);
-        this.dsl.get('havingFilters').push([
+        this.getConditions().push([
             yMap
         ]);
-        const node = new HavingFiltersNodeBuilder(yMap);
+        const node = new WhereFilterNodeBuilder(yMap);
         callback(node);
         return this;
     }
     addGroup(op, callback) {
-        const yMap = new external_yjs_namespaceObject.Map();
-        yMap.set('id', id_id.uuid());
-        yMap.set('op', op);
-        yMap.set('conditions', new external_yjs_namespaceObject.Array());
-        this.dsl.get('havingFilters').push([
+        const yMap = createWhereGroup(op, id_id.uuid());
+        this.getConditions().push([
             yMap
         ]);
-        const group = new HavingGroupBuilder(yMap);
+        const group = new WhereGroupBuilder(yMap);
         callback(group);
         return this;
     }
     update(id, callback) {
-        const havingFilters = this.dsl.get('havingFilters');
-        const index = havingFilters.toArray().findIndex((item)=>item.get('id') === id);
-        if (-1 === index) throw new Error(`Having filter with id ${id} not found`);
-        const filterYMap = havingFilters.get(index);
-        const node = new HavingFiltersNodeBuilder(filterYMap);
+        const conditions = this.getConditions();
+        const match = findEntry(conditions, id);
+        if (!match) throw new Error(`Where filter with id ${id} not found`);
+        if (!WhereFilterBuilder.isNode(match.item)) throw new Error(`Item with id ${id} is not a filter`);
+        const filterYMap = match.item;
+        const node = new WhereFilterNodeBuilder(filterYMap);
         callback(node);
         return this;
     }
     updateGroup(id, callback) {
-        const havingFilters = this.dsl.get('havingFilters');
-        const index = havingFilters.toArray().findIndex((item)=>item.get('id') === id);
-        if (-1 === index) throw new Error(`Having group with id ${id} not found`);
-        const yMap = havingFilters.get(index);
-        if (!HavingFiltersBuilder.isGroup(yMap)) throw new Error(`Item with id ${id} is not a group`);
-        const group = new HavingGroupBuilder(yMap);
+        const conditions = this.getConditions();
+        const match = findEntry(conditions, id);
+        if (!match) throw new Error(`Where group with id ${id} not found`);
+        const yMap = match.item;
+        if (!WhereFilterBuilder.isGroup(yMap)) throw new Error(`Item with id ${id} is not a group`);
+        const group = new WhereGroupBuilder(yMap);
         callback(group);
         return this;
     }
     remove(idOrIndex) {
-        const havingFilters = this.dsl.get('havingFilters');
+        const conditions = this.getConditions();
         if ('number' == typeof idOrIndex) {
-            if (idOrIndex >= 0 && idOrIndex < havingFilters.length) havingFilters.delete(idOrIndex, 1);
+            if (idOrIndex >= 0 && idOrIndex < conditions.length) conditions.delete(idOrIndex, 1);
         } else {
-            const index = havingFilters.toArray().findIndex((item)=>item.get('id') === idOrIndex);
-            if (-1 !== index) havingFilters.delete(index, 1);
+            const match = findEntry(conditions, idOrIndex);
+            if (match) match.collection.delete(match.index, 1);
         }
         return this;
     }
-    find(id) {
-        const havingFilters = this.dsl.get('havingFilters');
-        const yMap = havingFilters.toArray().find((item)=>item.get('id') === id);
-        if (!yMap) return;
-        if (HavingFiltersBuilder.isGroup(yMap)) return new HavingGroupBuilder(yMap);
-        return new HavingFiltersNodeBuilder(yMap);
+    find(predicate) {
+        const traverse = (collection)=>{
+            const items = collection.toArray();
+            for(let index = 0; index < items.length; index++){
+                const yMap = items[index];
+                const entry = WhereFilterBuilder.isGroup(yMap) ? new WhereGroupBuilder(yMap) : new WhereFilterNodeBuilder(yMap);
+                if (predicate(entry, index)) return entry;
+                if (WhereFilterBuilder.isGroup(yMap)) {
+                    const nestedCollection = yMap.get('conditions');
+                    const nestedMatch = traverse(nestedCollection);
+                    if (nestedMatch) return nestedMatch;
+                }
+            }
+        };
+        return traverse(this.getConditions());
     }
     clear() {
-        const havingFilters = this.dsl.get('havingFilters');
-        havingFilters.delete(0, havingFilters.length);
+        const conditions = this.getConditions();
+        conditions.delete(0, conditions.length);
         return this;
     }
-    toJson() {
-        return this.dsl.get('havingFilters').toJSON();
+    toJSON() {
+        return this.whereFilter.toJSON();
     }
     observe(callback) {
-        this.dsl.get('havingFilters').observe(callback);
+        this.whereFilter.observeDeep(callback);
         return ()=>{
-            this.dsl.get('havingFilters').unobserve(callback);
+            this.whereFilter.unobserveDeep(callback);
         };
     }
     static isGroup(yMap) {
-        return void 0 !== yMap.get('op') && void 0 !== yMap.get('conditions');
+        return where_utils_isWhereGroup(yMap);
     }
     static isNode(yMap) {
         return void 0 !== yMap.get('field');
     }
 }
-class ChartTypeBuilder {
-    dsl;
-    constructor(_doc, dsl){
-        this.dsl = dsl;
-    }
-    observe(callback) {
-        const wrapper = (e, trans)=>{
-            if (e.keysChanged.has('chartType')) callback(e, trans);
-        };
-        this.dsl.observe(wrapper);
-        return ()=>{
-            this.dsl.unobserve(wrapper);
+function createHavingGroup(op = 'and', groupId = 'root') {
+    const yMap = new external_yjs_namespaceObject.Map();
+    yMap.set('id', groupId);
+    yMap.set('op', op);
+    yMap.set('conditions', new external_yjs_namespaceObject.Array());
+    return yMap;
+}
+function having_utils_isHavingGroup(yMap) {
+    return void 0 !== yMap.get('op') && void 0 !== yMap.get('conditions');
+}
+function having_utils_findEntry(collection, entryId) {
+    const items = collection.toArray();
+    for(let index = 0; index < items.length; index++){
+        const item = items[index];
+        if (item.get('id') === entryId) return {
+            collection,
+            index,
+            item
         };
-    }
-    changeChartType(chartType) {
-        this.dsl.set('chartType', chartType);
-    }
-    getChartType() {
-        return this.dsl.get('chartType') || 'table';
-    }
-    toJson() {
-        return this.dsl.get('chartType') || 'table';
-    }
-    getAvailableChartTypes() {
-        return [
-            vseed_namespaceObject.ChartTypeEnum.Table,
-            vseed_namespaceObject.ChartTypeEnum.PivotTable,
-            vseed_namespaceObject.ChartTypeEnum.Line,
-            vseed_namespaceObject.ChartTypeEnum.Column,
-            vseed_namespaceObject.ChartTypeEnum.ColumnPercent,
-            vseed_namespaceObject.ChartTypeEnum.ColumnParallel,
-            vseed_namespaceObject.ChartTypeEnum.BarPercent,
-            vseed_namespaceObject.ChartTypeEnum.BarParallel,
-            vseed_namespaceObject.ChartTypeEnum.Area,
-            vseed_namespaceObject.ChartTypeEnum.AreaPercent,
-            vseed_namespaceObject.ChartTypeEnum.DualAxis,
-            vseed_namespaceObject.ChartTypeEnum.Scatter,
-            vseed_namespaceObject.ChartTypeEnum.Rose,
-            vseed_namespaceObject.ChartTypeEnum.RoseParallel,
-            vseed_namespaceObject.ChartTypeEnum.Pie,
-            vseed_namespaceObject.ChartTypeEnum.Donut,
-            vseed_namespaceObject.ChartTypeEnum.Radar,
-            vseed_namespaceObject.ChartTypeEnum.Funnel,
-            vseed_namespaceObject.ChartTypeEnum.Heatmap,
-            vseed_namespaceObject.ChartTypeEnum.Boxplot,
-            vseed_namespaceObject.ChartTypeEnum.Histogram
-        ];
+        if (having_utils_isHavingGroup(item)) {
+            const nestedCollection = item.get('conditions');
+            const nestedMatch = having_utils_findEntry(nestedCollection, entryId);
+            if (nestedMatch) return nestedMatch;
+        }
     }
 }
-class WhereFilterNodeBuilder {
+class HavingFilterNodeBuilder {
     yMap;
     constructor(yMap){
         this.yMap = yMap;
@@ -446,23 +818,26 @@ class WhereFilterNodeBuilder {
     getOperator() {
         return this.yMap.get('op');
     }
-    setOperator(operator) {
-        this.yMap.set('op', operator);
-        return this;
-    }
     setValue(value) {
         this.yMap.set('value', value);
         return this;
     }
-    toJson() {
+    setOperator(operator) {
+        this.yMap.set('op', operator);
+        return this;
+    }
+    toJSON() {
         return this.yMap.toJSON();
     }
 }
-class WhereGroupBuilder {
+class HavingGroupBuilder {
     yMap;
     constructor(yMap){
         this.yMap = yMap;
     }
+    getConditions() {
+        return this.yMap.get('conditions');
+    }
     getId() {
         return this.yMap.get('id');
     }
@@ -477,29 +852,24 @@ class WhereGroupBuilder {
         const yMap = new external_yjs_namespaceObject.Map();
         yMap.set('id', id_id.uuid());
         yMap.set('field', field);
-        const conditions = this.yMap.get('conditions');
-        conditions.push([
+        this.getConditions().push([
             yMap
         ]);
-        const node = new WhereFilterNodeBuilder(yMap);
+        const node = new HavingFilterNodeBuilder(yMap);
         callback(node);
         return this;
     }
     addGroup(op, callback) {
-        const yMap = new external_yjs_namespaceObject.Map();
-        yMap.set('id', id_id.uuid());
-        yMap.set('op', op);
-        yMap.set('conditions', new external_yjs_namespaceObject.Array());
-        const conditions = this.yMap.get('conditions');
-        conditions.push([
+        const yMap = createHavingGroup(op, id_id.uuid());
+        this.getConditions().push([
             yMap
         ]);
-        const group = new WhereGroupBuilder(yMap);
+        const group = new HavingGroupBuilder(yMap);
         callback(group);
         return this;
     }
     remove(idOrIndex) {
-        const conditions = this.yMap.get('conditions');
+        const conditions = this.getConditions();
         if ('number' == typeof idOrIndex) {
             if (idOrIndex >= 0 && idOrIndex < conditions.length) conditions.delete(idOrIndex, 1);
         } else {
@@ -509,104 +879,191 @@ class WhereGroupBuilder {
         return this;
     }
     clear() {
-        const conditions = this.yMap.get('conditions');
+        const conditions = this.getConditions();
         conditions.delete(0, conditions.length);
         return this;
     }
-    toJson() {
+    toJSON() {
         return this.yMap.toJSON();
     }
 }
-class WhereFiltersBuilder {
-    dsl;
-    doc;
+class HavingFilterBuilder {
+    havingFilter;
     constructor(doc, dsl){
-        this.doc = doc;
-        this.dsl = dsl;
-        if (!this.dsl.get('whereFilters')) this.doc.transact(()=>{
-            this.dsl.set('whereFilters', new external_yjs_namespaceObject.Array());
+        doc.transact(()=>{
+            const existingHavingFilter = dsl.get('havingFilter');
+            if (existingHavingFilter instanceof external_yjs_namespaceObject.Map) this.havingFilter = existingHavingFilter;
+            else {
+                this.havingFilter = createHavingGroup();
+                dsl.set('havingFilter', this.havingFilter);
+            }
+            if (!(this.havingFilter.get('conditions') instanceof external_yjs_namespaceObject.Array)) this.havingFilter.set('conditions', new external_yjs_namespaceObject.Array());
+            if (!this.havingFilter.get('id')) this.havingFilter.set('id', 'root');
+            if (!this.havingFilter.get('op')) this.havingFilter.set('op', 'and');
         });
     }
+    getConditions() {
+        return this.havingFilter.get('conditions');
+    }
     add(field, callback) {
         const yMap = new external_yjs_namespaceObject.Map();
         yMap.set('id', id_id.uuid());
         yMap.set('field', field);
-        this.dsl.get('whereFilters').push([
+        this.getConditions().push([
             yMap
         ]);
-        const node = new WhereFilterNodeBuilder(yMap);
+        const node = new HavingFilterNodeBuilder(yMap);
         callback(node);
         return this;
     }
     addGroup(op, callback) {
-        const yMap = new external_yjs_namespaceObject.Map();
-        yMap.set('id', id_id.uuid());
-        yMap.set('op', op);
-        yMap.set('conditions', new external_yjs_namespaceObject.Array());
-        this.dsl.get('whereFilters').push([
+        const yMap = createHavingGroup(op, id_id.uuid());
+        this.getConditions().push([
             yMap
         ]);
-        const group = new WhereGroupBuilder(yMap);
+        const group = new HavingGroupBuilder(yMap);
         callback(group);
         return this;
     }
     update(id, callback) {
-        const whereFilters = this.dsl.get('whereFilters');
-        const index = whereFilters.toArray().findIndex((item)=>item.get('id') === id);
-        if (-1 === index) throw new Error(`Where filter with id ${id} not found`);
-        const filterYMap = whereFilters.get(index);
-        const node = new WhereFilterNodeBuilder(filterYMap);
+        const conditions = this.getConditions();
+        const match = having_utils_findEntry(conditions, id);
+        if (!match) throw new Error(`Having filter with id ${id} not found`);
+        if (!HavingFilterBuilder.isNode(match.item)) throw new Error(`Item with id ${id} is not a filter`);
+        const filterYMap = match.item;
+        const node = new HavingFilterNodeBuilder(filterYMap);
         callback(node);
         return this;
     }
     updateGroup(id, callback) {
-        const whereFilters = this.dsl.get('whereFilters');
-        const index = whereFilters.toArray().findIndex((item)=>item.get('id') === id);
-        if (-1 === index) throw new Error(`Where group with id ${id} not found`);
-        const yMap = whereFilters.get(index);
-        if (!WhereFiltersBuilder.isGroup(yMap)) throw new Error(`Item with id ${id} is not a group`);
-        const group = new WhereGroupBuilder(yMap);
+        const conditions = this.getConditions();
+        const match = having_utils_findEntry(conditions, id);
+        if (!match) throw new Error(`Having group with id ${id} not found`);
+        const yMap = match.item;
+        if (!HavingFilterBuilder.isGroup(yMap)) throw new Error(`Item with id ${id} is not a group`);
+        const group = new HavingGroupBuilder(yMap);
         callback(group);
         return this;
     }
     remove(idOrIndex) {
-        const whereFilters = this.dsl.get('whereFilters');
+        const conditions = this.getConditions();
         if ('number' == typeof idOrIndex) {
-            if (idOrIndex >= 0 && idOrIndex < whereFilters.length) whereFilters.delete(idOrIndex, 1);
+            if (idOrIndex >= 0 && idOrIndex < conditions.length) conditions.delete(idOrIndex, 1);
         } else {
-            const index = whereFilters.toArray().findIndex((item)=>item.get('id') === idOrIndex);
-            if (-1 !== index) whereFilters.delete(index, 1);
+            const match = having_utils_findEntry(conditions, idOrIndex);
+            if (match) match.collection.delete(match.index, 1);
         }
         return this;
     }
-    find(id) {
-        const whereFilters = this.dsl.get('whereFilters');
-        const yMap = whereFilters.toArray().find((item)=>item.get('id') === id);
-        if (!yMap) return;
-        if (WhereFiltersBuilder.isGroup(yMap)) return new WhereGroupBuilder(yMap);
-        return new WhereFilterNodeBuilder(yMap);
+    find(predicate) {
+        const traverse = (collection)=>{
+            const items = collection.toArray();
+            for(let index = 0; index < items.length; index++){
+                const yMap = items[index];
+                const entry = HavingFilterBuilder.isGroup(yMap) ? new HavingGroupBuilder(yMap) : new HavingFilterNodeBuilder(yMap);
+                if (predicate(entry, index)) return entry;
+                if (HavingFilterBuilder.isGroup(yMap)) {
+                    const nestedCollection = yMap.get('conditions');
+                    const nestedMatch = traverse(nestedCollection);
+                    if (nestedMatch) return nestedMatch;
+                }
+            }
+        };
+        return traverse(this.getConditions());
     }
     clear() {
-        const whereFilters = this.dsl.get('whereFilters');
-        whereFilters.delete(0, whereFilters.length);
+        const conditions = this.getConditions();
+        conditions.delete(0, conditions.length);
         return this;
     }
-    toJson() {
-        return this.dsl.get('whereFilters').toJSON();
+    toJSON() {
+        return this.havingFilter.toJSON();
     }
     observe(callback) {
-        this.dsl.get('whereFilters').observe(callback);
+        this.havingFilter.observeDeep(callback);
         return ()=>{
-            this.dsl.get('whereFilters').unobserve(callback);
+            this.havingFilter.unobserveDeep(callback);
         };
     }
     static isGroup(yMap) {
-        return void 0 !== yMap.get('op') && void 0 !== yMap.get('conditions');
+        return having_utils_isHavingGroup(yMap);
     }
     static isNode(yMap) {
         return void 0 !== yMap.get('field');
     }
 }
+class ThemeBuilder {
+    dsl;
+    constructor(_doc, dsl){
+        this.dsl = dsl;
+    }
+    observe(callback) {
+        const wrapper = (e, trans)=>{
+            if (e.keysChanged.has('theme')) callback(e, trans);
+        };
+        this.dsl.observe(wrapper);
+        return ()=>{
+            this.dsl.unobserve(wrapper);
+        };
+    }
+    setTheme(theme) {
+        this.dsl.set('theme', theme);
+    }
+    getTheme() {
+        return this.dsl.get('theme') || 'light';
+    }
+    toJSON() {
+        return this.getTheme();
+    }
+}
+class LocaleBuilder {
+    dsl;
+    constructor(_doc, dsl){
+        this.dsl = dsl;
+    }
+    observe(callback) {
+        const wrapper = (e, trans)=>{
+            if (e.keysChanged.has('locale')) callback(e, trans);
+        };
+        this.dsl.observe(wrapper);
+        return ()=>{
+            this.dsl.unobserve(wrapper);
+        };
+    }
+    setLocale(locale) {
+        this.dsl.set('locale', locale);
+    }
+    getLocale() {
+        return this.dsl.get('locale') || 'zh-CN';
+    }
+    toJSON() {
+        return this.getLocale();
+    }
+}
+class LimitBuilder {
+    dsl;
+    constructor(_doc, dsl){
+        this.dsl = dsl;
+    }
+    observe(callback) {
+        const wrapper = (e, trans)=>{
+            if (e.keysChanged.has('limit')) callback(e, trans);
+        };
+        this.dsl.observe(wrapper);
+        return ()=>{
+            this.dsl.unobserve(wrapper);
+        };
+    }
+    setLimit(limit) {
+        this.dsl.set('limit', limit);
+    }
+    getLimit() {
+        return this.dsl.get('limit');
+    }
+    toJSON() {
+        return this.getLimit();
+    }
+}
 class UndoManager {
     manager;
     constructor(scope){
@@ -628,355 +1085,215 @@ class UndoManager {
         this.manager.clear(clearUndoStack, clearRedoStack);
     }
 }
-const external_remeda_namespaceObject = require("remeda");
-const buildSelect = (queryDSL, context)=>{
-    const { vbiDSL } = context;
-    const measures = vbiDSL.measures;
-    const dimensions = vbiDSL.dimensions;
-    const result = {
-        ...queryDSL
-    };
-    const measureNodes = measures.filter((measure)=>MeasuresBuilder.isMeasureNode(measure));
-    const measureSelects = measureNodes.map((measure)=>({
-            field: measure.field,
-            alias: measure.alias,
-            aggr: measure.aggregate
-        }));
-    const dimensionNodes = dimensions.filter((dimension)=>DimensionsBuilder.isDimensionNode(dimension));
-    const dimensionSelects = dimensionNodes.map((dimension)=>({
-            field: dimension.field,
-            alias: dimension.alias
-        }));
-    result.select = measureSelects.concat(dimensionSelects);
-    return result;
-};
-const buildGroupBy = (queryDSL, context)=>{
-    const result = {
-        ...queryDSL
-    };
-    const { vbiDSL } = context;
-    const dimensions = vbiDSL.dimensions;
-    const dimensionNodes = dimensions.filter((dimension)=>DimensionsBuilder.isDimensionNode(dimension));
-    result.groupBy = dimensionNodes.map((dimension)=>dimension.field);
-    return result;
-};
-const buildWhere = (queryDSL, context)=>{
-    const { vbiDSL } = context;
-    const whereFilters = vbiDSL.whereFilters || [];
-    if (0 === whereFilters.length) return queryDSL;
-    const result = {
-        ...queryDSL
-    };
-    result.where = {
-        op: 'and',
-        conditions: whereFilters.flatMap(mapClauseToCondition)
-    };
-    return result;
-};
-function isWhereGroup(clause) {
-    return 'op' in clause && 'conditions' in clause;
-}
-function mapClauseToCondition(clause) {
-    if (isWhereGroup(clause)) return [
-        mapGroupToCondition(clause)
-    ];
-    return mapFilterToCondition(clause);
-}
-function mapGroupToCondition(group) {
-    return {
-        op: group.op,
-        conditions: group.conditions.flatMap(mapClauseToCondition)
-    };
-}
-function mapFilterToCondition(filter) {
-    if ('between' === filter.op) return handleBetweenFilter(filter);
-    return handleSimpleFilter(filter);
-}
-function handleBetweenFilter(filter) {
-    const conditions = [];
-    const value = filter.value;
-    if (void 0 !== value.min && null !== value.min && '' !== value.min) conditions.push({
-        field: filter.field,
-        op: '<' === value.leftOp ? '>' : '>=',
-        value: value.min
-    });
-    if (void 0 !== value.max && null !== value.max && '' !== value.max) conditions.push({
-        field: filter.field,
-        op: '<' === value.rightOp ? '<' : '<=',
-        value: value.max
+const createBuilderFeatures = (doc, dsl)=>({
+        undoManager: new UndoManager(dsl),
+        chartType: new ChartTypeBuilder(doc, dsl),
+        measures: new MeasuresBuilder(doc, dsl),
+        dimensions: new DimensionsBuilder(doc, dsl),
+        havingFilter: new HavingFilterBuilder(doc, dsl),
+        whereFilter: new WhereFilterBuilder(doc, dsl),
+        theme: new ThemeBuilder(doc, dsl),
+        locale: new LocaleBuilder(doc, dsl),
+        limit: new LimitBuilder(doc, dsl)
     });
-    return conditions;
-}
-function handleSimpleFilter(filter) {
-    let mappedOp = filter.op ?? '=';
-    const value = filter.value;
-    if (Array.isArray(value)) {
-        if ('=' === mappedOp) mappedOp = 'in';
-        if ('!=' === mappedOp) mappedOp = 'not in';
-    }
-    return [
-        {
-            field: filter.field,
-            op: mappedOp,
-            value
-        }
-    ];
-}
-const buildHaving = (queryDSL, context)=>{
-    const { vbiDSL } = context;
-    const havingFilters = vbiDSL.havingFilters || [];
-    if (0 === havingFilters.length) return queryDSL;
-    const result = {
-        ...queryDSL
-    };
-    result.having = {
-        op: 'and',
-        conditions: havingFilters.flatMap(buildHaving_mapClauseToCondition)
-    };
-    return result;
-};
-function isHavingGroup(clause) {
-    return 'op' in clause && 'conditions' in clause;
-}
-function buildHaving_mapClauseToCondition(clause) {
-    if (isHavingGroup(clause)) return [
-        buildHaving_mapGroupToCondition(clause)
-    ];
-    return buildHaving_mapFilterToCondition(clause);
-}
-function buildHaving_mapGroupToCondition(group) {
-    return {
-        op: group.op,
-        conditions: group.conditions.flatMap(buildHaving_mapClauseToCondition)
-    };
-}
-function buildHaving_mapFilterToCondition(filter) {
-    const mappedOp = filter.op ?? '=';
-    return [
-        {
-            field: filter.field,
-            op: mappedOp,
-            value: filter.value
-        }
-    ];
-}
-const buildLimit = (queryDSL, context)=>{
-    const result = {
-        ...queryDSL
-    };
-    const limit = context.vbiDSL.limit ?? 1000;
-    result.limit = limit;
-    return result;
-};
-const buildVQuery = (vbiDSL, builder)=>{
-    const wrapper = (processor)=>(queryDSL)=>processor(queryDSL, {
-                vbiDSL,
-                builder
-            });
-    return (0, external_remeda_namespaceObject.pipe)({}, wrapper(buildSelect), wrapper(buildGroupBy), wrapper(buildWhere), wrapper(buildHaving), wrapper(buildLimit));
-};
-const connectorMap = new Map();
-const registerConnector = (id, connector)=>{
-    connectorMap.set(id, connector);
-};
-const getConnector = async (id)=>{
-    const connector = connectorMap.get(id);
-    if (!connector) throw new Error(`connector ${id} not registered`);
-    if ('function' == typeof connector) return connector();
-    return connector;
-};
 class VBIBuilder {
     doc;
     dsl;
-    undoManager;
     chartType;
     measures;
     dimensions;
-    havingFilters;
-    whereFilters;
+    havingFilter;
+    whereFilter;
+    theme;
+    locale;
+    limit;
+    undoManager;
     constructor(doc){
         this.doc = doc;
         this.dsl = doc.getMap('dsl');
-        this.undoManager = new UndoManager(this.dsl);
-        this.chartType = new ChartTypeBuilder(doc, this.dsl);
-        this.measures = new MeasuresBuilder(doc, this.dsl);
-        this.dimensions = new DimensionsBuilder(doc, this.dsl);
-        this.havingFilters = new HavingFiltersBuilder(doc, this.dsl);
-        this.whereFilters = new WhereFiltersBuilder(doc, this.dsl);
-    }
-    applyUpdate(update) {
-        external_yjs_namespaceObject.applyUpdate(this.doc, update);
-    }
-    encodeStateAsUpdate(targetStateVector) {
-        return external_yjs_namespaceObject.encodeStateAsUpdate(this.doc, targetStateVector);
-    }
+        const features = createBuilderFeatures(doc, this.dsl);
+        this.undoManager = features.undoManager;
+        this.chartType = features.chartType;
+        this.measures = features.measures;
+        this.dimensions = features.dimensions;
+        this.havingFilter = features.havingFilter;
+        this.whereFilter = features.whereFilter;
+        this.theme = features.theme;
+        this.locale = features.locale;
+        this.limit = features.limit;
+    }
+    applyUpdate = (update, transactionOrigin)=>applyUpdateToDoc(this.doc, update, transactionOrigin);
+    encodeStateAsUpdate = (targetStateVector)=>encodeDocStateAsUpdate(this.doc, targetStateVector);
     buildVSeed = async ()=>{
         const vbiDSL = this.build();
-        const connectorId = vbiDSL.connectorId;
-        const connector = await getConnector(vbiDSL.connectorId);
         const queryDSL = this.buildVQuery();
-        const schema = await connector.discoverSchema();
-        const queryResult = await connector.query({
-            queryDSL,
-            schema,
-            connectorId
+        return buildVSeedDSL({
+            vbiDSL,
+            queryDSL
         });
-        return {
-            chartType: vbiDSL.chartType,
-            dataset: queryResult.dataset,
-            theme: vbiDSL.theme,
-            locale: vbiDSL.locale
-        };
     };
-    buildVQuery = ()=>{
-        const vbiDSL = this.build();
-        return buildVQuery(vbiDSL, this);
-    };
-    build = ()=>this.dsl.toJSON();
-    getSchema = async ()=>{
-        const connectorId = this.dsl.get('connectorId');
-        const con = await getConnector(connectorId);
-        const result = await con.discoverSchema();
-        return result;
-    };
-    setLimit(limit) {
-        this.dsl.set('limit', limit);
-        return this;
-    }
-    setLocale(locale) {
-        this.dsl.set('locale', locale);
-        return this;
+    buildVQuery = ()=>buildVQueryDSL(this.dsl, this);
+    build = ()=>buildVBIDSL(this.dsl);
+    isEmpty = ()=>isEmptyVBIDSL(this.dsl);
+    getSchema = async ()=>getBuilderSchema(this.dsl);
+}
+const shouldEnsureIdForObject = (obj, ensureId)=>{
+    if (true === ensureId) return true;
+    if ('field' === ensureId) return 'string' == typeof obj.field;
+    return false;
+};
+const toYMap = (obj, ensureId = false)=>{
+    const yMap = new external_yjs_namespaceObject.Map();
+    if (shouldEnsureIdForObject(obj, ensureId) && !obj.id) yMap.set('id', id_id.uuid());
+    for (const [key, value] of Object.entries(obj)){
+        if (('conditions' === key || 'children' === key) && Array.isArray(value)) {
+            const yArr = new external_yjs_namespaceObject.Array();
+            for (const child of value){
+                if (child instanceof external_yjs_namespaceObject.Map) {
+                    yArr.push([
+                        child
+                    ]);
+                    continue;
+                }
+                if ('object' == typeof child && null !== child) {
+                    yArr.push([
+                        toYMap(child, ensureId)
+                    ]);
+                    continue;
+                }
+                yArr.push([
+                    child
+                ]);
+            }
+            yMap.set(key, yArr);
+            continue;
+        }
+        yMap.set(key, value);
     }
-    setTheme(theme) {
-        this.dsl.set('theme', theme);
-        return this;
+    return yMap;
+};
+const ensureYArray = (arr, ensureId = false)=>{
+    if (!arr) return new external_yjs_namespaceObject.Array();
+    if (arr instanceof external_yjs_namespaceObject.Array) return arr;
+    const yArr = new external_yjs_namespaceObject.Array();
+    for (const item of arr){
+        if (item instanceof external_yjs_namespaceObject.Map) {
+            yArr.push([
+                item
+            ]);
+            continue;
+        }
+        if ('object' == typeof item && null !== item) {
+            yArr.push([
+                toYMap(item, ensureId)
+            ]);
+            continue;
+        }
+        yArr.push([
+            item
+        ]);
     }
-}
+    return yArr;
+};
+const getDefaultWhereFilter = ()=>({
+        id: 'root',
+        op: 'and',
+        conditions: []
+    });
+const isFilterGroupInput = (value)=>'object' == typeof value && null !== value;
+const ensureWhereGroup = (whereFilter)=>{
+    const sourceWhereFilter = whereFilter instanceof external_yjs_namespaceObject.Map || isFilterGroupInput(whereFilter) ? whereFilter : getDefaultWhereFilter();
+    const whereGroup = sourceWhereFilter instanceof external_yjs_namespaceObject.Map ? sourceWhereFilter : createWhereGroup();
+    if (sourceWhereFilter instanceof external_yjs_namespaceObject.Map) {
+        if (!(whereGroup.get('conditions') instanceof external_yjs_namespaceObject.Array)) whereGroup.set('conditions', new external_yjs_namespaceObject.Array());
+        if (!whereGroup.get('id')) whereGroup.set('id', 'root');
+        if (!whereGroup.get('op')) whereGroup.set('op', 'and');
+        return whereGroup;
+    }
+    whereGroup.set('id', sourceWhereFilter.id ?? 'root');
+    whereGroup.set('op', sourceWhereFilter.op ?? 'and');
+    whereGroup.set('conditions', ensureYArray(sourceWhereFilter.conditions, true));
+    return whereGroup;
+};
+const getDefaultHavingFilter = ()=>({
+        id: 'root',
+        op: 'and',
+        conditions: []
+    });
+const ensure_having_group_isFilterGroupInput = (value)=>'object' == typeof value && null !== value;
+const ensureHavingGroup = (havingFilter)=>{
+    const sourceHavingFilter = havingFilter instanceof external_yjs_namespaceObject.Map || ensure_having_group_isFilterGroupInput(havingFilter) ? havingFilter : getDefaultHavingFilter();
+    const havingGroup = sourceHavingFilter instanceof external_yjs_namespaceObject.Map ? sourceHavingFilter : createHavingGroup();
+    if (sourceHavingFilter instanceof external_yjs_namespaceObject.Map) {
+        if (!(havingGroup.get('conditions') instanceof external_yjs_namespaceObject.Array)) havingGroup.set('conditions', new external_yjs_namespaceObject.Array());
+        if (!havingGroup.get('id')) havingGroup.set('id', 'root');
+        if (!havingGroup.get('op')) havingGroup.set('op', 'and');
+        return havingGroup;
+    }
+    havingGroup.set('id', sourceHavingFilter.id ?? 'root');
+    havingGroup.set('op', sourceHavingFilter.op ?? 'and');
+    havingGroup.set('conditions', ensureYArray(sourceHavingFilter.conditions, true));
+    return havingGroup;
+};
+const setBaseDSLFields = (dsl, vbi)=>{
+    if (vbi.connectorId) dsl.set('connectorId', vbi.connectorId);
+    if (vbi.chartType) dsl.set('chartType', vbi.chartType);
+    if (vbi.theme) dsl.set('theme', vbi.theme);
+    if (vbi.limit) dsl.set('limit', vbi.limit);
+    if (vbi.locale) dsl.set('locale', vbi.locale);
+    if (void 0 !== vbi.version) dsl.set('version', vbi.version);
+};
+const fromVBIDSLInput = (vbi)=>{
+    const doc = new external_yjs_namespaceObject.Doc();
+    const dsl = doc.getMap('dsl');
+    doc.transact(()=>{
+        setBaseDSLFields(dsl, vbi);
+        dsl.set('whereFilter', ensureWhereGroup(vbi.whereFilter));
+        dsl.set('havingFilter', ensureHavingGroup(vbi.havingFilter));
+        dsl.set('measures', ensureYArray(vbi.measures, 'field'));
+        dsl.set('dimensions', ensureYArray(vbi.dimensions, 'field'));
+    });
+    return new VBIBuilder(doc);
+};
+const generateEmptyDSL = (connectorId)=>({
+        connectorId,
+        chartType: 'table',
+        measures: [],
+        dimensions: [],
+        whereFilter: {
+            id: 'root',
+            op: 'and',
+            conditions: []
+        },
+        havingFilter: {
+            id: 'root',
+            op: 'and',
+            conditions: []
+        },
+        theme: 'light',
+        locale: 'zh-CN',
+        version: 0
+    });
 const createVBI = ()=>({
         connectorMap: connectorMap,
         registerConnector: registerConnector,
         getConnector: getConnector,
-        generateEmptyDSL: (connectorId)=>({
-                connectorId: connectorId,
-                chartType: 'table',
-                measures: [],
-                dimensions: [],
-                whereFilters: [],
-                havingFilters: [],
-                theme: 'light',
-                locale: 'zh-CN',
-                version: 0
-            }),
-        from: (vbi)=>{
-            const doc = new external_yjs_namespaceObject.Doc();
-            const dsl = doc.getMap('dsl');
-            doc.transact(()=>{
-                if (vbi.connectorId) dsl.set('connectorId', vbi.connectorId);
-                if (vbi.chartType) dsl.set('chartType', vbi.chartType);
-                if (vbi.theme) dsl.set('theme', vbi.theme);
-                if (vbi.limit) dsl.set('limit', vbi.limit);
-                if (vbi.locale) dsl.set('locale', vbi.locale);
-                if (vbi.version) dsl.set('version', vbi.version);
-                const toYMap = (obj, ensureId = false)=>{
-                    const yMap = new external_yjs_namespaceObject.Map();
-                    if (ensureId && !obj.id) yMap.set('id', id_id.uuid());
-                    for (const [key, value] of Object.entries(obj))if ('conditions' === key && Array.isArray(value)) {
-                        const yArr = new external_yjs_namespaceObject.Array();
-                        value.forEach((child)=>{
-                            if (child instanceof external_yjs_namespaceObject.Map) yArr.push([
-                                child
-                            ]);
-                            else if ('object' == typeof child && null !== child) yArr.push([
-                                toYMap(child, true)
-                            ]);
-                            else yArr.push([
-                                child
-                            ]);
-                        });
-                        yMap.set(key, yArr);
-                    } else yMap.set(key, value);
-                    return yMap;
-                };
-                const ensureYArray = (arr, ensureId = false)=>{
-                    if (!arr) return new external_yjs_namespaceObject.Array();
-                    if (arr instanceof external_yjs_namespaceObject.Array) return arr;
-                    const yArr = new external_yjs_namespaceObject.Array();
-                    arr.forEach((item)=>{
-                        if (item instanceof external_yjs_namespaceObject.Map) yArr.push([
-                            item
-                        ]);
-                        else if ('object' == typeof item && null !== item) yArr.push([
-                            toYMap(item, ensureId)
-                        ]);
-                        else yArr.push([
-                            item
-                        ]);
-                    });
-                    return yArr;
-                };
-                dsl.set('whereFilters', ensureYArray(vbi.whereFilters, true));
-                dsl.set('havingFilters', ensureYArray(vbi.havingFilters, true));
-                dsl.set('measures', ensureYArray(vbi.measures));
-                dsl.set('dimensions', ensureYArray(vbi.dimensions));
-            });
-            return new VBIBuilder(doc);
-        }
+        generateEmptyDSL: generateEmptyDSL,
+        from: fromVBIDSLInput,
+        create: fromVBIDSLInput
     });
 const VBI = createVBI();
-const external_zod_namespaceObject = require("zod");
-const zVBIFilter = external_zod_namespaceObject.z.object({
-    id: external_zod_namespaceObject.z.string(),
-    field: external_zod_namespaceObject.z.string(),
-    op: external_zod_namespaceObject.z.string().optional(),
-    value: external_zod_namespaceObject.z.any().optional()
-});
-const zVBIWhereGroup = external_zod_namespaceObject.z.lazy(()=>external_zod_namespaceObject.z.object({
-        id: external_zod_namespaceObject.z.string(),
-        op: external_zod_namespaceObject.z["enum"]([
-            'and',
-            'or'
-        ]),
-        conditions: external_zod_namespaceObject.z.array(zVBIWhereClause)
-    }));
-const zVBIWhereClause = external_zod_namespaceObject.z.lazy(()=>external_zod_namespaceObject.z.union([
-        zVBIFilter,
-        zVBIWhereGroup
-    ]));
-function isVBIFilter(clause) {
-    return 'field' in clause;
-}
-function isVBIWhereGroup(clause) {
-    return 'conditions' in clause;
-}
-const zVBIHavingFilter = external_zod_namespaceObject.z.object({
-    id: external_zod_namespaceObject.z.string(),
-    field: external_zod_namespaceObject.z.string(),
-    op: external_zod_namespaceObject.z.string().optional(),
-    value: external_zod_namespaceObject.z.any().optional()
-});
-const zVBIHavingGroup = external_zod_namespaceObject.z.lazy(()=>external_zod_namespaceObject.z.object({
-        id: external_zod_namespaceObject.z.string(),
-        op: external_zod_namespaceObject.z["enum"]([
-            'and',
-            'or'
-        ]),
-        conditions: external_zod_namespaceObject.z.array(zVBIHavingClause)
-    }));
-const zVBIHavingClause = external_zod_namespaceObject.z.lazy(()=>external_zod_namespaceObject.z.union([
-        zVBIHavingFilter,
-        zVBIHavingGroup
-    ]));
-function isVBIHavingFilter(clause) {
-    return 'field' in clause;
-}
-function isVBIHavingGroup(clause) {
-    return 'conditions' in clause;
-}
 exports.ChartTypeBuilder = __webpack_exports__.ChartTypeBuilder;
 exports.DimensionsBuilder = __webpack_exports__.DimensionsBuilder;
+exports.HavingFilterBuilder = __webpack_exports__.HavingFilterBuilder;
+exports.LimitBuilder = __webpack_exports__.LimitBuilder;
+exports.LocaleBuilder = __webpack_exports__.LocaleBuilder;
 exports.MeasuresBuilder = __webpack_exports__.MeasuresBuilder;
+exports.ThemeBuilder = __webpack_exports__.ThemeBuilder;
+exports.UndoManager = __webpack_exports__.UndoManager;
 exports.VBI = __webpack_exports__.VBI;
 exports.VBIBuilder = __webpack_exports__.VBIBuilder;
+exports.WhereFilterBuilder = __webpack_exports__.WhereFilterBuilder;
 exports.buildVQuery = __webpack_exports__.buildVQuery;
 exports.findTreeNodesBy = __webpack_exports__.findTreeNodesBy;
 exports.id = __webpack_exports__.id;
@@ -988,9 +1305,15 @@ exports.preorderTraverse = __webpack_exports__.preorderTraverse;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "ChartTypeBuilder",
     "DimensionsBuilder",
+    "HavingFilterBuilder",
+    "LimitBuilder",
+    "LocaleBuilder",
     "MeasuresBuilder",
+    "ThemeBuilder",
+    "UndoManager",
     "VBI",
     "VBIBuilder",
+    "WhereFilterBuilder",
     "buildVQuery",
     "findTreeNodesBy",
     "id",