@visactor/vbi 0.4.19 → 0.4.20

package/dist/index.js

@@ -12,250 +12,6 @@ const getConnector = async (id)=>{
     if ('function' == typeof connector) return connector();
     return connector;
 };
-const VBI_TO_VQUERY_AGGR_FUNC_MAP = {
-    count: 'count',
-    countDistinct: 'count_distinct',
-    sum: 'sum',
-    avg: 'avg',
-    min: 'min',
-    max: 'max',
-    variance: 'variance',
-    variancePop: 'variance_pop',
-    stddev: 'stddev',
-    median: 'median',
-    quantile: 'quantile'
-};
-const mapAggregateForVQuery = (aggregate)=>{
-    if (!aggregate) return aggregate;
-    const mappedFunc = VBI_TO_VQUERY_AGGR_FUNC_MAP[aggregate.func] ?? aggregate.func;
-    return {
-        ...aggregate,
-        func: mappedFunc
-    };
-};
-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: mapAggregateForVQuery(measure.aggregate)
-        }));
-    const dimensionNodes = dimensions.filter((dimension)=>DimensionsBuilder.isDimensionNode(dimension));
-    const dimensionSelects = dimensionNodes.map((dimension)=>({
-            field: dimension.field,
-            alias: dimension.alias
-        }));
-    result.select = [
-        ...measureSelects,
-        ...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;
-}
-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
-            }
-        ];
-    }
-    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 DEFAULT_HAVING_AGGREGATE = {
-    func: 'sum'
-};
-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 = normalizeOperator(filter.op, filter.value);
-    const aggregate = mapAggregateForVQuery(filter.aggregate ?? DEFAULT_HAVING_AGGREGATE);
-    return [
-        {
-            field: filter.field,
-            aggr: aggregate,
-            op: mappedOp,
-            value: filter.value
-        }
-    ];
-}
-function normalizeOperator(op, value) {
-    let mappedOp = op ?? '=';
-    if (Array.isArray(value)) {
-        if ('=' === mappedOp) mappedOp = 'in';
-        if ('!=' === mappedOp) mappedOp = 'not in';
-    }
-    return mappedOp;
-}
-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 pipe({}, wrapper(buildSelect), wrapper(buildGroupBy), wrapper(buildWhere), wrapper(buildHaving), wrapper(buildLimit));
-};
-const buildVQueryDSL = ({ vbiDSL, builder })=>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 defaultVBIBuilderAdapters = {
-    buildVQuery: buildVQueryDSL,
-    buildVSeed: buildVSeedDSL
-};
-const resolveVBIBuilderAdapters = (adapters)=>({
-        buildVQuery: adapters?.buildVQuery ?? defaultVBIBuilderAdapters.buildVQuery,
-        buildVSeed: adapters?.buildVSeed ?? defaultVBIBuilderAdapters.buildVSeed
-    });
 class MeasureNodeBuilder {
     yMap;
     constructor(yMap){
@@ -267,6 +23,12 @@ class MeasureNodeBuilder {
     getField() {
         return this.yMap.get('field');
     }
+    getEncoding() {
+        return this.yMap.get('encoding');
+    }
+    getSort() {
+        return this.yMap.get('sort');
+    }
     setAlias(alias) {
         this.yMap.set('alias', alias);
         return this;
@@ -275,10 +37,29 @@ class MeasureNodeBuilder {
         this.yMap.set('encoding', encoding);
         return this;
     }
+    setSort(sort) {
+        this.yMap.set('sort', sort);
+        return this;
+    }
     setAggregate(aggregate) {
         this.yMap.set('aggregate', aggregate);
         return this;
     }
+    setFormat(format) {
+        this.yMap.set('format', format);
+        return this;
+    }
+    getFormat() {
+        return this.yMap.get('format');
+    }
+    clearFormat() {
+        this.yMap.delete('format');
+        return this;
+    }
+    clearSort() {
+        this.yMap.delete('sort');
+        return this;
+    }
     toJSON() {
         return this.yMap.toJSON();
     }
@@ -311,9 +92,369 @@ const normalizeMeasureNodeIds = (measures)=>{
     });
 };
 const locateMeasureIndexById = (measures, measureId)=>measures.toArray().findIndex((item)=>item.get('id') === measureId);
+const MEASURE_ENCODING_SUPPORT = {
+    table: [
+        'column'
+    ],
+    pivotTable: [
+        'detail'
+    ],
+    column: [
+        'yAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    columnParallel: [
+        'yAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    columnPercent: [
+        'yAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    line: [
+        'yAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    area: [
+        'yAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    areaPercent: [
+        'yAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    bar: [
+        'xAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    barParallel: [
+        'xAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    barPercent: [
+        'xAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    dualAxis: [
+        'primaryYAxis',
+        'secondaryYAxis',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    scatter: [
+        'xAxis',
+        'yAxis',
+        'size',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    pie: [
+        'angle',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    donut: [
+        'angle',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    rose: [
+        'radius',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    roseParallel: [
+        'radius',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    radar: [
+        'radius',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    funnel: [
+        'size',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    heatmap: [
+        'color',
+        'detail',
+        'label',
+        'tooltip'
+    ],
+    histogram: [
+        'value',
+        'x0',
+        'x1',
+        'yAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    boxplot: [
+        'value',
+        'q1',
+        'q3',
+        'min',
+        'max',
+        'median',
+        'outliers',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    treeMap: [
+        'size',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    sunburst: [
+        'size',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    circlePacking: [
+        'size',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    raceBar: [
+        'xAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    raceColumn: [
+        'yAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    raceLine: [
+        'yAxis',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    raceScatter: [
+        'xAxis',
+        'yAxis',
+        'size',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    racePie: [
+        'angle',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ],
+    raceDonut: [
+        'angle',
+        'detail',
+        'color',
+        'label',
+        'tooltip'
+    ]
+};
+const repeatEncoding = (first, rest = first)=>(index)=>0 === index ? first : rest;
+const STRATEGY_BY_CHART_TYPE = {
+    [ChartTypeEnum.Table]: {
+        supported: MEASURE_ENCODING_SUPPORT.table,
+        recommend: repeatEncoding('column')
+    },
+    [ChartTypeEnum.PivotTable]: {
+        supported: MEASURE_ENCODING_SUPPORT.pivotTable,
+        recommend: repeatEncoding('detail')
+    },
+    [ChartTypeEnum.Column]: {
+        supported: MEASURE_ENCODING_SUPPORT.column,
+        recommend: repeatEncoding('yAxis')
+    },
+    [ChartTypeEnum.ColumnParallel]: {
+        supported: MEASURE_ENCODING_SUPPORT.columnParallel,
+        recommend: repeatEncoding('yAxis')
+    },
+    [ChartTypeEnum.ColumnPercent]: {
+        supported: MEASURE_ENCODING_SUPPORT.columnPercent,
+        recommend: repeatEncoding('yAxis')
+    },
+    [ChartTypeEnum.Line]: {
+        supported: MEASURE_ENCODING_SUPPORT.line,
+        recommend: repeatEncoding('yAxis')
+    },
+    [ChartTypeEnum.Area]: {
+        supported: MEASURE_ENCODING_SUPPORT.area,
+        recommend: repeatEncoding('yAxis')
+    },
+    [ChartTypeEnum.AreaPercent]: {
+        supported: MEASURE_ENCODING_SUPPORT.areaPercent,
+        recommend: repeatEncoding('yAxis')
+    },
+    [ChartTypeEnum.Bar]: {
+        supported: MEASURE_ENCODING_SUPPORT.bar,
+        recommend: repeatEncoding('xAxis')
+    },
+    [ChartTypeEnum.BarParallel]: {
+        supported: MEASURE_ENCODING_SUPPORT.barParallel,
+        recommend: repeatEncoding('xAxis')
+    },
+    [ChartTypeEnum.BarPercent]: {
+        supported: MEASURE_ENCODING_SUPPORT.barPercent,
+        recommend: repeatEncoding('xAxis')
+    },
+    [ChartTypeEnum.DualAxis]: {
+        supported: MEASURE_ENCODING_SUPPORT.dualAxis,
+        recommend: (index)=>0 === index ? 'primaryYAxis' : 'secondaryYAxis'
+    },
+    [ChartTypeEnum.Scatter]: {
+        supported: MEASURE_ENCODING_SUPPORT.scatter,
+        recommend: (index)=>0 === index ? 'xAxis' : 'yAxis'
+    },
+    [ChartTypeEnum.Pie]: {
+        supported: MEASURE_ENCODING_SUPPORT.pie,
+        recommend: repeatEncoding('angle')
+    },
+    [ChartTypeEnum.Donut]: {
+        supported: MEASURE_ENCODING_SUPPORT.donut,
+        recommend: repeatEncoding('angle')
+    },
+    [ChartTypeEnum.Rose]: {
+        supported: MEASURE_ENCODING_SUPPORT.rose,
+        recommend: repeatEncoding('radius')
+    },
+    [ChartTypeEnum.RoseParallel]: {
+        supported: MEASURE_ENCODING_SUPPORT.roseParallel,
+        recommend: repeatEncoding('radius')
+    },
+    [ChartTypeEnum.Radar]: {
+        supported: MEASURE_ENCODING_SUPPORT.radar,
+        recommend: repeatEncoding('radius')
+    },
+    [ChartTypeEnum.Funnel]: {
+        supported: MEASURE_ENCODING_SUPPORT.funnel,
+        recommend: repeatEncoding('size')
+    },
+    [ChartTypeEnum.Heatmap]: {
+        supported: MEASURE_ENCODING_SUPPORT.heatmap,
+        recommend: repeatEncoding('color')
+    },
+    [ChartTypeEnum.Histogram]: {
+        supported: MEASURE_ENCODING_SUPPORT.histogram,
+        recommend: repeatEncoding('value')
+    },
+    [ChartTypeEnum.Boxplot]: {
+        supported: MEASURE_ENCODING_SUPPORT.boxplot,
+        recommend: repeatEncoding('value')
+    },
+    [ChartTypeEnum.TreeMap]: {
+        supported: MEASURE_ENCODING_SUPPORT.treeMap,
+        recommend: repeatEncoding('size')
+    },
+    [ChartTypeEnum.Sunburst]: {
+        supported: MEASURE_ENCODING_SUPPORT.sunburst,
+        recommend: repeatEncoding('size')
+    },
+    [ChartTypeEnum.CirclePacking]: {
+        supported: MEASURE_ENCODING_SUPPORT.circlePacking,
+        recommend: repeatEncoding('size')
+    },
+    [ChartTypeEnum.RaceBar]: {
+        supported: MEASURE_ENCODING_SUPPORT.raceBar,
+        recommend: repeatEncoding('xAxis')
+    },
+    [ChartTypeEnum.RaceColumn]: {
+        supported: MEASURE_ENCODING_SUPPORT.raceColumn,
+        recommend: repeatEncoding('yAxis')
+    },
+    [ChartTypeEnum.RaceLine]: {
+        supported: MEASURE_ENCODING_SUPPORT.raceLine,
+        recommend: repeatEncoding('yAxis')
+    },
+    [ChartTypeEnum.RaceScatter]: {
+        supported: MEASURE_ENCODING_SUPPORT.raceScatter,
+        recommend: (index)=>0 === index ? 'xAxis' : 'yAxis'
+    },
+    [ChartTypeEnum.RacePie]: {
+        supported: MEASURE_ENCODING_SUPPORT.racePie,
+        recommend: repeatEncoding('angle')
+    },
+    [ChartTypeEnum.RaceDonut]: {
+        supported: MEASURE_ENCODING_SUPPORT.raceDonut,
+        recommend: repeatEncoding('angle')
+    }
+};
+const DEFAULT_STRATEGY = STRATEGY_BY_CHART_TYPE[ChartTypeEnum.Table];
+const getSupportedMeasureEncodingsForChartType = (chartType)=>[
+        ...(STRATEGY_BY_CHART_TYPE[chartType] || DEFAULT_STRATEGY).supported
+    ];
+const getRecommendedMeasureEncodingsForChartType = (chartType, measureCount)=>{
+    const strategy = STRATEGY_BY_CHART_TYPE[chartType] || DEFAULT_STRATEGY;
+    if (measureCount <= 0) return [];
+    return Array.from({
+        length: measureCount
+    }, (_, index)=>strategy.recommend(index));
+};
 class MeasuresBuilder {
+    doc;
     dsl;
     constructor(doc, dsl){
+        this.doc = doc;
         this.dsl = dsl;
         doc.transact(()=>{
             const measures = getOrCreateMeasures(this.dsl);
@@ -321,38 +462,47 @@ class MeasuresBuilder {
         });
     }
     add(field, callback) {
+        const measures = getOrCreateMeasures(this.dsl);
+        const chartType = this.dsl.get('chartType') || 'table';
+        const [encoding] = getRecommendedMeasureEncodingsForChartType(chartType, measures.length + 1).slice(-1);
         const measure = {
             id: id_id.uuid(),
             alias: field,
             field,
-            encoding: 'yAxis',
+            encoding,
             aggregate: {
                 func: 'sum'
             }
         };
         const yMap = new external_yjs_Map();
-        for (const [key, value] of Object.entries(measure))yMap.set(key, value);
-        const measures = getOrCreateMeasures(this.dsl);
-        measures.push([
-            yMap
-        ]);
-        const node = new MeasureNodeBuilder(yMap);
-        callback(node);
+        this.doc.transact(()=>{
+            for (const [key, value] of Object.entries(measure))yMap.set(key, value);
+            const measures = getOrCreateMeasures(this.dsl);
+            measures.push([
+                yMap
+            ]);
+            const node = new MeasureNodeBuilder(yMap);
+            callback(node);
+        });
         return this;
     }
     remove(id) {
-        const measures = getOrCreateMeasures(this.dsl);
-        const index = locateMeasureIndexById(measures, id);
-        if (-1 !== index) measures.delete(index, 1);
+        this.doc.transact(()=>{
+            const measures = getOrCreateMeasures(this.dsl);
+            const index = locateMeasureIndexById(measures, id);
+            if (-1 !== index) measures.delete(index, 1);
+        });
         return this;
     }
     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);
+        this.doc.transact(()=>{
+            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(predicate) {
@@ -373,9 +523,9 @@ class MeasuresBuilder {
     }
     observe(callback) {
         const measures = getOrCreateMeasures(this.dsl);
-        measures.observe(callback);
+        measures.observeDeep(callback);
         return ()=>{
-            measures.unobserve(callback);
+            measures.unobserveDeep(callback);
         };
     }
     static isMeasureNode(node) {
@@ -396,10 +546,36 @@ class DimensionNodeBuilder {
     getField() {
         return this.yMap.get('field');
     }
-    setAlias(alias) {
+    getEncoding() {
+        return this.yMap.get('encoding');
+    }
+    getSort() {
+        return this.yMap.get('sort');
+    }
+    setAlias(alias) {
         this.yMap.set('alias', alias);
         return this;
     }
+    setEncoding(encoding) {
+        this.yMap.set('encoding', encoding);
+        return this;
+    }
+    setSort(sort) {
+        this.yMap.set('sort', sort);
+        return this;
+    }
+    setAggregate(aggregate) {
+        this.yMap.set('aggregate', aggregate);
+        return this;
+    }
+    clearAggregate() {
+        this.yMap.delete('aggregate');
+        return this;
+    }
+    clearSort() {
+        this.yMap.delete('sort');
+        return this;
+    }
     toJSON() {
         return this.yMap.toJSON();
     }
@@ -417,9 +593,423 @@ const normalizeDimensionNodeIds = (dimensions)=>{
     });
 };
 const locateDimensionIndexById = (dimensions, dimensionId)=>dimensions.toArray().findIndex((item)=>item.get('id') === dimensionId);
+const DIMENSION_ENCODING_SUPPORT = {
+    table: [
+        'column'
+    ],
+    pivotTable: [
+        'row',
+        'column'
+    ],
+    column: [
+        'xAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    columnParallel: [
+        'xAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    columnPercent: [
+        'xAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    line: [
+        'xAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    area: [
+        'xAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    areaPercent: [
+        'xAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    dualAxis: [
+        'xAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    bar: [
+        'yAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    barParallel: [
+        'yAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    barPercent: [
+        'yAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    pie: [
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    donut: [
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    funnel: [
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    scatter: [
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    rose: [
+        'angle',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    roseParallel: [
+        'angle',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    radar: [
+        'angle',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    heatmap: [
+        'xAxis',
+        'yAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    boxplot: [
+        'xAxis',
+        'color',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    histogram: [
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    treeMap: [
+        'hierarchy',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    sunburst: [
+        'hierarchy',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    circlePacking: [
+        'hierarchy',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    raceBar: [
+        'player',
+        'yAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    raceColumn: [
+        'player',
+        'xAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    raceLine: [
+        'player',
+        'xAxis',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    raceScatter: [
+        'player',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    racePie: [
+        'player',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ],
+    raceDonut: [
+        'player',
+        'color',
+        'detail',
+        'tooltip',
+        'label',
+        'row',
+        'column'
+    ]
+};
+const dimension_encoding_repeatEncoding = (first, rest = first)=>(index)=>0 === index ? first : rest;
+const alternateEncoding = (a, b)=>(index)=>index % 2 === 0 ? a : b;
+const dimension_encoding_STRATEGY_BY_CHART_TYPE = {
+    [ChartTypeEnum.Table]: {
+        supported: DIMENSION_ENCODING_SUPPORT.table,
+        recommend: dimension_encoding_repeatEncoding('column')
+    },
+    [ChartTypeEnum.PivotTable]: {
+        supported: DIMENSION_ENCODING_SUPPORT.pivotTable,
+        recommend: alternateEncoding('column', 'row')
+    },
+    [ChartTypeEnum.Column]: {
+        supported: DIMENSION_ENCODING_SUPPORT.column,
+        recommend: dimension_encoding_repeatEncoding('xAxis', 'color')
+    },
+    [ChartTypeEnum.ColumnParallel]: {
+        supported: DIMENSION_ENCODING_SUPPORT.columnParallel,
+        recommend: dimension_encoding_repeatEncoding('xAxis', 'color')
+    },
+    [ChartTypeEnum.ColumnPercent]: {
+        supported: DIMENSION_ENCODING_SUPPORT.columnPercent,
+        recommend: dimension_encoding_repeatEncoding('xAxis', 'color')
+    },
+    [ChartTypeEnum.Line]: {
+        supported: DIMENSION_ENCODING_SUPPORT.line,
+        recommend: dimension_encoding_repeatEncoding('xAxis', 'color')
+    },
+    [ChartTypeEnum.Area]: {
+        supported: DIMENSION_ENCODING_SUPPORT.area,
+        recommend: dimension_encoding_repeatEncoding('xAxis', 'color')
+    },
+    [ChartTypeEnum.AreaPercent]: {
+        supported: DIMENSION_ENCODING_SUPPORT.areaPercent,
+        recommend: dimension_encoding_repeatEncoding('xAxis', 'color')
+    },
+    [ChartTypeEnum.DualAxis]: {
+        supported: DIMENSION_ENCODING_SUPPORT.dualAxis,
+        recommend: dimension_encoding_repeatEncoding('xAxis', 'color')
+    },
+    [ChartTypeEnum.Bar]: {
+        supported: DIMENSION_ENCODING_SUPPORT.bar,
+        recommend: dimension_encoding_repeatEncoding('yAxis', 'color')
+    },
+    [ChartTypeEnum.BarParallel]: {
+        supported: DIMENSION_ENCODING_SUPPORT.barParallel,
+        recommend: dimension_encoding_repeatEncoding('yAxis', 'color')
+    },
+    [ChartTypeEnum.BarPercent]: {
+        supported: DIMENSION_ENCODING_SUPPORT.barPercent,
+        recommend: dimension_encoding_repeatEncoding('yAxis', 'color')
+    },
+    [ChartTypeEnum.Pie]: {
+        supported: DIMENSION_ENCODING_SUPPORT.pie,
+        recommend: dimension_encoding_repeatEncoding('color')
+    },
+    [ChartTypeEnum.Donut]: {
+        supported: DIMENSION_ENCODING_SUPPORT.donut,
+        recommend: dimension_encoding_repeatEncoding('color')
+    },
+    [ChartTypeEnum.Funnel]: {
+        supported: DIMENSION_ENCODING_SUPPORT.funnel,
+        recommend: dimension_encoding_repeatEncoding('color')
+    },
+    [ChartTypeEnum.Scatter]: {
+        supported: DIMENSION_ENCODING_SUPPORT.scatter,
+        recommend: dimension_encoding_repeatEncoding('color')
+    },
+    [ChartTypeEnum.Rose]: {
+        supported: DIMENSION_ENCODING_SUPPORT.rose,
+        recommend: dimension_encoding_repeatEncoding('angle', 'color')
+    },
+    [ChartTypeEnum.RoseParallel]: {
+        supported: DIMENSION_ENCODING_SUPPORT.roseParallel,
+        recommend: dimension_encoding_repeatEncoding('angle', 'color')
+    },
+    [ChartTypeEnum.Radar]: {
+        supported: DIMENSION_ENCODING_SUPPORT.radar,
+        recommend: dimension_encoding_repeatEncoding('angle', 'color')
+    },
+    [ChartTypeEnum.Heatmap]: {
+        supported: DIMENSION_ENCODING_SUPPORT.heatmap,
+        recommend: dimension_encoding_repeatEncoding('xAxis', 'yAxis')
+    },
+    [ChartTypeEnum.Boxplot]: {
+        supported: DIMENSION_ENCODING_SUPPORT.boxplot,
+        recommend: dimension_encoding_repeatEncoding('xAxis', 'color')
+    },
+    [ChartTypeEnum.Histogram]: {
+        supported: DIMENSION_ENCODING_SUPPORT.histogram,
+        recommend: dimension_encoding_repeatEncoding('color')
+    },
+    [ChartTypeEnum.TreeMap]: {
+        supported: DIMENSION_ENCODING_SUPPORT.treeMap,
+        recommend: dimension_encoding_repeatEncoding('hierarchy')
+    },
+    [ChartTypeEnum.Sunburst]: {
+        supported: DIMENSION_ENCODING_SUPPORT.sunburst,
+        recommend: dimension_encoding_repeatEncoding('hierarchy')
+    },
+    [ChartTypeEnum.CirclePacking]: {
+        supported: DIMENSION_ENCODING_SUPPORT.circlePacking,
+        recommend: dimension_encoding_repeatEncoding('hierarchy')
+    },
+    [ChartTypeEnum.RaceBar]: {
+        supported: DIMENSION_ENCODING_SUPPORT.raceBar,
+        recommend: (index)=>{
+            if (0 === index) return 'player';
+            if (1 === index) return 'yAxis';
+            return 'color';
+        }
+    },
+    [ChartTypeEnum.RaceColumn]: {
+        supported: DIMENSION_ENCODING_SUPPORT.raceColumn,
+        recommend: (index)=>{
+            if (0 === index) return 'player';
+            if (1 === index) return 'xAxis';
+            return 'color';
+        }
+    },
+    [ChartTypeEnum.RaceLine]: {
+        supported: DIMENSION_ENCODING_SUPPORT.raceLine,
+        recommend: (index)=>0 === index ? 'player' : 'color'
+    },
+    [ChartTypeEnum.RaceScatter]: {
+        supported: DIMENSION_ENCODING_SUPPORT.raceScatter,
+        recommend: (index)=>0 === index ? 'player' : 'color'
+    },
+    [ChartTypeEnum.RacePie]: {
+        supported: DIMENSION_ENCODING_SUPPORT.racePie,
+        recommend: (index)=>0 === index ? 'player' : 'color'
+    },
+    [ChartTypeEnum.RaceDonut]: {
+        supported: DIMENSION_ENCODING_SUPPORT.raceDonut,
+        recommend: (index)=>0 === index ? 'player' : 'color'
+    }
+};
+const dimension_encoding_DEFAULT_STRATEGY = dimension_encoding_STRATEGY_BY_CHART_TYPE[ChartTypeEnum.Table];
+const getSupportedDimensionEncodingsForChartType = (chartType)=>[
+        ...(dimension_encoding_STRATEGY_BY_CHART_TYPE[chartType] || dimension_encoding_DEFAULT_STRATEGY).supported
+    ];
+const getRecommendedDimensionEncodingsForChartType = (chartType, dimensionCount)=>{
+    const strategy = dimension_encoding_STRATEGY_BY_CHART_TYPE[chartType] || dimension_encoding_DEFAULT_STRATEGY;
+    if (dimensionCount <= 0) return [];
+    return Array.from({
+        length: dimensionCount
+    }, (_, index)=>strategy.recommend(index));
+};
 class DimensionsBuilder {
+    doc;
     dsl;
     constructor(doc, dsl){
+        this.doc = doc;
         this.dsl = dsl;
         doc.transact(()=>{
             const dimensions = getOrCreateDimensions(this.dsl);
@@ -427,34 +1017,44 @@ class DimensionsBuilder {
         });
     }
     add(field, callback) {
+        const dimensions = getOrCreateDimensions(this.dsl);
+        const chartType = this.dsl.get('chartType') || 'table';
+        const [encoding] = getRecommendedDimensionEncodingsForChartType(chartType, dimensions.length + 1).slice(-1);
         const dimension = {
             id: id_id.uuid(),
             alias: field,
-            field
+            field,
+            encoding
         };
         const yMap = new external_yjs_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);
+        this.doc.transact(()=>{
+            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);
+        this.doc.transact(()=>{
+            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);
+        this.doc.transact(()=>{
+            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) {
@@ -475,9 +1075,9 @@ class DimensionsBuilder {
     }
     observe(callback) {
         const dimensions = getOrCreateDimensions(this.dsl);
-        dimensions.observe(callback);
+        dimensions.observeDeep(callback);
         return ()=>{
-            dimensions.unobserve(callback);
+            dimensions.unobserveDeep(callback);
         };
     }
     static isDimensionNode(node) {
@@ -487,9 +1087,27 @@ class DimensionsBuilder {
         return 'children' in node;
     }
 }
+const reapplyDimensionEncodings = (dsl, chartType)=>{
+    const dimensions = getOrCreateDimensions(dsl);
+    const nodes = dimensions.toArray().filter((item)=>item instanceof external_yjs_Map && 'string' == typeof item.get('field'));
+    const encodings = getRecommendedDimensionEncodingsForChartType(chartType, nodes.length);
+    nodes.forEach((node, index)=>{
+        node.set('encoding', encodings[index]);
+    });
+};
+const reapplyMeasureEncodings = (dsl, chartType)=>{
+    const measures = getOrCreateMeasures(dsl);
+    const nodes = measures.toArray().filter((item)=>item instanceof external_yjs_Map && 'string' == typeof item.get('field'));
+    const encodings = getRecommendedMeasureEncodingsForChartType(chartType, nodes.length);
+    nodes.forEach((node, index)=>{
+        node.set('encoding', encodings[index]);
+    });
+};
 class ChartTypeBuilder {
+    doc;
     dsl;
-    constructor(_doc, dsl){
+    constructor(doc, dsl){
+        this.doc = doc;
         this.dsl = dsl;
     }
     observe(callback) {
@@ -502,11 +1120,29 @@ class ChartTypeBuilder {
         };
     }
     changeChartType(chartType) {
-        this.dsl.set('chartType', chartType);
+        this.doc.transact(()=>{
+            this.dsl.set('chartType', chartType);
+            reapplyDimensionEncodings(this.dsl, chartType);
+            reapplyMeasureEncodings(this.dsl, chartType);
+        });
     }
     getChartType() {
         return this.dsl.get('chartType') || 'table';
     }
+    getSupportedDimensionEncodings() {
+        return getSupportedDimensionEncodingsForChartType(this.getChartType());
+    }
+    getRecommendedDimensionEncodings(dimensionCount) {
+        const resolvedCount = dimensionCount ?? this.dsl.get('dimensions')?.length;
+        return getRecommendedDimensionEncodingsForChartType(this.getChartType(), resolvedCount);
+    }
+    getSupportedMeasureEncodings() {
+        return getSupportedMeasureEncodingsForChartType(this.getChartType());
+    }
+    getRecommendedMeasureEncodings(measureCount) {
+        const resolvedCount = measureCount ?? this.dsl.get('measures')?.length;
+        return getRecommendedMeasureEncodingsForChartType(this.getChartType(), resolvedCount);
+    }
     toJSON() {
         return this.dsl.get('chartType') || 'table';
     }
@@ -514,25 +1150,35 @@ class ChartTypeBuilder {
         return [
             ChartTypeEnum.Table,
             ChartTypeEnum.PivotTable,
-            ChartTypeEnum.Line,
             ChartTypeEnum.Column,
-            ChartTypeEnum.ColumnPercent,
             ChartTypeEnum.ColumnParallel,
-            ChartTypeEnum.BarPercent,
+            ChartTypeEnum.ColumnPercent,
+            ChartTypeEnum.Bar,
             ChartTypeEnum.BarParallel,
+            ChartTypeEnum.BarPercent,
+            ChartTypeEnum.Line,
             ChartTypeEnum.Area,
             ChartTypeEnum.AreaPercent,
             ChartTypeEnum.DualAxis,
             ChartTypeEnum.Scatter,
-            ChartTypeEnum.Rose,
-            ChartTypeEnum.RoseParallel,
             ChartTypeEnum.Pie,
             ChartTypeEnum.Donut,
+            ChartTypeEnum.Rose,
+            ChartTypeEnum.RoseParallel,
             ChartTypeEnum.Radar,
             ChartTypeEnum.Funnel,
             ChartTypeEnum.Heatmap,
             ChartTypeEnum.Boxplot,
-            ChartTypeEnum.Histogram
+            ChartTypeEnum.Histogram,
+            ChartTypeEnum.TreeMap,
+            ChartTypeEnum.Sunburst,
+            ChartTypeEnum.CirclePacking,
+            ChartTypeEnum.RaceBar,
+            ChartTypeEnum.RaceColumn,
+            ChartTypeEnum.RaceLine,
+            ChartTypeEnum.RaceScatter,
+            ChartTypeEnum.RacePie,
+            ChartTypeEnum.RaceDonut
         ];
     }
 }
@@ -543,7 +1189,7 @@ function createWhereGroup(op = 'and', groupId = 'root') {
     yMap.set('conditions', new external_yjs_Array());
     return yMap;
 }
-function where_utils_isWhereGroup(yMap) {
+function isWhereGroup(yMap) {
     return void 0 !== yMap.get('op') && void 0 !== yMap.get('conditions');
 }
 function findEntry(collection, entryId) {
@@ -555,7 +1201,7 @@ function findEntry(collection, entryId) {
             index,
             item
         };
-        if (where_utils_isWhereGroup(item)) {
+        if (isWhereGroup(item)) {
             const nestedCollection = item.get('conditions');
             const nestedMatch = findEntry(nestedCollection, entryId);
             if (nestedMatch) return nestedMatch;
@@ -588,6 +1234,15 @@ class WhereFilterNodeBuilder {
         this.yMap.set('value', value);
         return this;
     }
+    setDate(predicate) {
+        this.yMap.set('op', 'date');
+        this.yMap.set('value', predicate);
+        return this;
+    }
+    getDate() {
+        if ('date' !== this.yMap.get('op')) return;
+        return this.yMap.get('value');
+    }
     toJSON() {
         return this.yMap.toJSON();
     }
@@ -748,7 +1403,7 @@ class WhereFilterBuilder {
         };
     }
     static isGroup(yMap) {
-        return where_utils_isWhereGroup(yMap);
+        return isWhereGroup(yMap);
     }
     static isNode(yMap) {
         return void 0 !== yMap.get('field');
@@ -761,7 +1416,7 @@ function createHavingGroup(op = 'and', groupId = 'root') {
     yMap.set('conditions', new external_yjs_Array());
     return yMap;
 }
-function having_utils_isHavingGroup(yMap) {
+function isHavingGroup(yMap) {
     return void 0 !== yMap.get('op') && void 0 !== yMap.get('conditions');
 }
 function having_utils_findEntry(collection, entryId) {
@@ -773,7 +1428,7 @@ function having_utils_findEntry(collection, entryId) {
             index,
             item
         };
-        if (having_utils_isHavingGroup(item)) {
+        if (isHavingGroup(item)) {
             const nestedCollection = item.get('conditions');
             const nestedMatch = having_utils_findEntry(nestedCollection, entryId);
             if (nestedMatch) return nestedMatch;
@@ -975,7 +1630,7 @@ class HavingFilterBuilder {
         };
     }
     static isGroup(yMap) {
-        return having_utils_isHavingGroup(yMap);
+        return isHavingGroup(yMap);
     }
     static isNode(yMap) {
         return void 0 !== yMap.get('field');
@@ -1074,17 +1729,518 @@ class undo_manager_UndoManager {
         this.manager.clear(clearUndoStack, clearRedoStack);
     }
 }
+const VBI_TO_VQUERY_MEASURE_AGGR_FUNC_MAP = {
+    count: 'count',
+    countDistinct: 'count_distinct',
+    sum: 'sum',
+    avg: 'avg',
+    min: 'min',
+    max: 'max',
+    variance: 'variance',
+    variancePop: 'variance_pop',
+    stddev: 'stddev',
+    median: 'median',
+    quantile: 'quantile'
+};
+const VBI_TO_VQUERY_DIMENSION_AGGR_FUNC_MAP = {
+    toYear: 'to_year',
+    toQuarter: 'to_quarter',
+    toMonth: 'to_month',
+    toWeek: 'to_week',
+    toDay: 'to_day',
+    toHour: 'to_hour',
+    toMinute: 'to_minute',
+    toSecond: 'to_second'
+};
+const mapAggregateForVQuery = (aggregate)=>{
+    if (!aggregate) return aggregate;
+    const mappedFunc = VBI_TO_VQUERY_MEASURE_AGGR_FUNC_MAP[aggregate.func] ?? aggregate.func;
+    return {
+        ...aggregate,
+        func: mappedFunc
+    };
+};
+const mapDimensionAggregateForVQuery = (aggregate)=>{
+    if (!aggregate) return aggregate;
+    const mappedFunc = VBI_TO_VQUERY_DIMENSION_AGGR_FUNC_MAP[aggregate.func] ?? aggregate.func;
+    return {
+        ...aggregate,
+        func: mappedFunc
+    };
+};
+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.id,
+            aggr: mapAggregateForVQuery(measure.aggregate)
+        }));
+    const dimensionNodes = dimensions.filter((dimension)=>DimensionsBuilder.isDimensionNode(dimension));
+    const dimensionSelects = dimensionNodes.map((dimension)=>{
+        const aggregate = mapDimensionAggregateForVQuery(dimension.aggregate);
+        if (!aggregate) return {
+            field: dimension.field,
+            alias: dimension.id
+        };
+        return {
+            field: dimension.field,
+            alias: dimension.id,
+            aggr: aggregate
+        };
+    });
+    result.select = [
+        ...measureSelects,
+        ...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.aggregate ? dimension.id : dimension.field);
+    return result;
+};
+function resolveDatePredicate(predicate, now) {
+    switch(predicate.type){
+        case 'range':
+            return resolveRange(predicate);
+        case 'period':
+            return resolvePeriod(predicate);
+        case 'relative':
+            return resolveRelative(predicate, now ?? new Date());
+        case 'current':
+            return resolveCurrent(predicate, now ?? new Date());
+    }
+}
+function resolveRange(p) {
+    return {
+        start: toDateString(p.start),
+        end: toDateString(p.end),
+        bounds: p.bounds ?? '[)'
+    };
+}
+function resolvePeriod(p) {
+    switch(p.unit){
+        case 'year':
+            return {
+                start: `${p.year}-01-01`,
+                end: `${p.year + 1}-01-01`,
+                bounds: '[)'
+            };
+        case 'quarter':
+            return resolveQuarter(p.year, p.quarter);
+        case 'month':
+            return resolveMonth(p.year, p.month);
+        case 'week':
+            return resolveISOWeek(p.year, p.week);
+        case 'day':
+            return resolveDay(p.date);
+    }
+}
+function resolveQuarter(year, quarter) {
+    const startMonth = (quarter - 1) * 3 + 1;
+    const start = formatDate(year, startMonth, 1);
+    const endDate = new Date(Date.UTC(year, startMonth - 1 + 3, 1));
+    return {
+        start,
+        end: utcToDateString(endDate),
+        bounds: '[)'
+    };
+}
+function resolveMonth(year, month) {
+    const start = formatDate(year, month, 1);
+    const endDate = new Date(Date.UTC(year, month, 1));
+    return {
+        start,
+        end: utcToDateString(endDate),
+        bounds: '[)'
+    };
+}
+function resolveISOWeek(year, week) {
+    const jan4 = new Date(Date.UTC(year, 0, 4));
+    const dayOfWeek = jan4.getUTCDay() || 7;
+    const monday = new Date(jan4.getTime() - (dayOfWeek - 1) * 86400000);
+    const weekStart = new Date(monday.getTime() + (week - 1) * 604800000);
+    const weekEnd = new Date(weekStart.getTime() + 604800000);
+    return {
+        start: utcToDateString(weekStart),
+        end: utcToDateString(weekEnd),
+        bounds: '[)'
+    };
+}
+function resolveDay(date) {
+    const d = 'string' == typeof date ? new Date(date + 'T00:00:00Z') : date;
+    const next = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() + 1));
+    return {
+        start: utcToDateString(d),
+        end: utcToDateString(next),
+        bounds: '[)'
+    };
+}
+function resolveRelative(p, now) {
+    const today = truncateToDay(now);
+    const offset = 'last' === p.mode ? -p.amount : p.amount;
+    const shifted = shiftDate(today, offset, p.unit);
+    if ('last' === p.mode) return {
+        start: utcToDateString(shifted),
+        end: utcToDateString(today),
+        bounds: '[)'
+    };
+    return {
+        start: utcToDateString(today),
+        end: utcToDateString(shifted),
+        bounds: '[)'
+    };
+}
+function resolveCurrent(p, now) {
+    const offset = p.offset ?? 0;
+    const base = truncateToDay(now);
+    const periodStart = getPeriodStart(base, p.unit, offset);
+    const periodEnd = shiftDate(periodStart, 1, p.unit);
+    return {
+        start: utcToDateString(periodStart),
+        end: utcToDateString(periodEnd),
+        bounds: '[)'
+    };
+}
+function getPeriodStart(date, unit, offset) {
+    const y = date.getUTCFullYear();
+    const m = date.getUTCMonth();
+    switch(unit){
+        case 'year':
+            return new Date(Date.UTC(y + offset, 0, 1));
+        case 'quarter':
+            {
+                const q = Math.floor(m / 3);
+                return new Date(Date.UTC(y, (q + offset) * 3, 1));
+            }
+        case 'month':
+            return new Date(Date.UTC(y, m + offset, 1));
+        case 'week':
+            {
+                const dow = date.getUTCDay() || 7;
+                const monday = new Date(date.getTime() - (dow - 1) * 86400000);
+                return new Date(monday.getTime() + 7 * offset * 86400000);
+            }
+        case 'day':
+            return new Date(Date.UTC(y, m, date.getUTCDate() + offset));
+        default:
+            return date;
+    }
+}
+function shiftDate(date, amount, unit) {
+    const y = date.getUTCFullYear();
+    const m = date.getUTCMonth();
+    const d = date.getUTCDate();
+    switch(unit){
+        case 'year':
+            return new Date(Date.UTC(y + amount, m, d));
+        case 'quarter':
+            return new Date(Date.UTC(y, m + 3 * amount, d));
+        case 'month':
+            return new Date(Date.UTC(y, m + amount, d));
+        case 'week':
+            return new Date(date.getTime() + 7 * amount * 86400000);
+        case 'day':
+            return new Date(Date.UTC(y, m, d + amount));
+        default:
+            return date;
+    }
+}
+function truncateToDay(date) {
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+}
+function toDateString(input) {
+    if ('string' == typeof input) return input;
+    return utcToDateString(input);
+}
+function utcToDateString(date) {
+    return formatDate(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate());
+}
+function formatDate(year, month, day) {
+    const y = String(year);
+    const m = String(month).padStart(2, '0');
+    const d = String(day).padStart(2, '0');
+    return `${y}-${m}-${d}`;
+}
+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 buildWhere_isWhereGroup(clause) {
+    return 'op' in clause && 'conditions' in clause;
+}
+function mapClauseToCondition(clause) {
+    if (buildWhere_isWhereGroup(clause)) return [
+        mapGroupToCondition(clause)
+    ];
+    return mapFilterToCondition(clause);
+}
+function mapGroupToCondition(group) {
+    return {
+        op: group.op,
+        conditions: group.conditions.flatMap((c)=>mapClauseToCondition(c))
+    };
+}
+function mapFilterToCondition(filter) {
+    if ('date' === filter.op) return handleDateFilter(filter.field, filter.value);
+    if ('between' === filter.op || 'not between' === filter.op) return handleBetweenFilter(filter);
+    return handleSimpleFilter(filter);
+}
+function handleDateFilter(field, predicate) {
+    const range = resolveDatePredicate(predicate);
+    const startOp = '>=';
+    const endOp = '[]' === range.bounds ? '<=' : '<';
+    return [
+        {
+            field,
+            op: startOp,
+            value: range.start
+        },
+        {
+            field,
+            op: endOp,
+            value: range.end
+        }
+    ];
+}
+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
+            }
+        ];
+    }
+    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 buildHaving_isHavingGroup(clause) {
+    return 'op' in clause && 'conditions' in clause;
+}
+function buildHaving_mapClauseToCondition(clause) {
+    if (buildHaving_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 = normalizeOperator(filter.op, filter.value);
+    const aggregate = mapAggregateForVQuery(filter.aggregate);
+    return [
+        {
+            field: filter.field,
+            aggr: aggregate,
+            op: mappedOp,
+            value: filter.value
+        }
+    ];
+}
+function normalizeOperator(op, value) {
+    let mappedOp = op;
+    if (Array.isArray(value)) {
+        if ('=' === mappedOp) mappedOp = 'in';
+        if ('!=' === mappedOp) mappedOp = 'not in';
+    }
+    return mappedOp;
+}
+const toOrderItem = (node)=>({
+        field: node.id,
+        order: node.sort?.order
+    });
+const buildOrderBy = (queryDSL, context)=>{
+    const result = {
+        ...queryDSL
+    };
+    const dimensions = context.vbiDSL.dimensions.filter(DimensionsBuilder.isDimensionNode);
+    const measures = context.vbiDSL.measures.filter(MeasuresBuilder.isMeasureNode);
+    const sortedDimensions = dimensions.filter((node)=>node.sort);
+    const sortedMeasures = measures.filter((node)=>node.sort);
+    const sortedNodes = [
+        ...sortedDimensions,
+        ...sortedMeasures
+    ];
+    if (sortedNodes.length > 0) {
+        result.orderBy = sortedNodes.map(toOrderItem);
+        return result;
+    }
+    const firstDimension = dimensions[0];
+    if (firstDimension) result.orderBy = [
+        {
+            field: firstDimension.id,
+            order: 'asc'
+        }
+    ];
+    return result;
+};
+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 pipe({}, wrapper(buildSelect), wrapper(buildGroupBy), wrapper(buildWhere), wrapper(buildHaving), wrapper(buildOrderBy), wrapper(buildLimit));
+};
+const buildVQueryDSL = ({ vbiDSL, builder })=>buildVQuery(vbiDSL, builder);
+const buildVSeedDSL = async ({ vbiDSL, queryDSL, options })=>{
+    const connectorId = vbiDSL.connectorId;
+    const connector = await getConnector(connectorId);
+    const schema = await connector.discoverSchema();
+    const queryResult = await connector.query({
+        queryDSL,
+        schema,
+        connectorId,
+        signal: options.signal
+    });
+    const measures = vbiDSL.measures.filter((measure)=>MeasuresBuilder.isMeasureNode(measure)).map((measure)=>{
+        const nextMeasure = {
+            id: measure.id,
+            alias: measure.alias
+        };
+        if (measure.encoding) nextMeasure.encoding = measure.encoding;
+        if (measure.format) if ('autoFormat' in measure.format && true === measure.format.autoFormat) nextMeasure.autoFormat = true;
+        else {
+            nextMeasure.autoFormat = false;
+            nextMeasure.numFormat = Object.fromEntries(Object.entries(measure.format).filter(([key])=>'autoFormat' !== key));
+        }
+        return nextMeasure;
+    });
+    const dimensions = vbiDSL.dimensions.filter((dimension)=>DimensionsBuilder.isDimensionNode(dimension)).map((dimension)=>{
+        const nextDimension = {
+            id: dimension.id,
+            alias: dimension.alias
+        };
+        if (dimension.encoding) nextDimension.encoding = dimension.encoding;
+        return nextDimension;
+    });
+    return {
+        chartType: vbiDSL.chartType,
+        dataset: queryResult.dataset,
+        dimensions,
+        measures,
+        theme: vbiDSL.theme,
+        locale: vbiDSL.locale
+    };
+};
+const defaultVBIChartBuilderAdapters = {
+    buildVQuery: buildVQueryDSL,
+    buildVSeed: buildVSeedDSL
+};
+const resolveVBIChartBuilderAdapters = (adapters)=>({
+        buildVQuery: adapters?.buildVQuery ?? defaultVBIChartBuilderAdapters.buildVQuery,
+        buildVSeed: adapters?.buildVSeed ?? defaultVBIChartBuilderAdapters.buildVSeed
+    });
 const applyUpdateToDoc = (doc, update, transactionOrigin)=>{
     applyUpdate(doc, update, transactionOrigin);
 };
 const encodeDocStateAsUpdate = (doc, targetStateVector)=>encodeStateAsUpdate(doc, targetStateVector);
-const buildVBIDSL = (dsl)=>dsl.toJSON();
+const buildVBIChartDSL = (dsl)=>dsl.toJSON();
 const getCollectionLength = (value)=>{
     if (value instanceof external_yjs_Array) return value.length;
     if (Array.isArray(value)) return value.length;
     return 0;
 };
-const isEmptyVBIDSL = (dsl)=>{
+const isEmptyVBIChartDSL = (dsl)=>{
     const dimensionsLength = getCollectionLength(dsl.get('dimensions'));
     const measuresLength = getCollectionLength(dsl.get('measures'));
     return 0 === dimensionsLength && 0 === measuresLength;
@@ -1094,7 +2250,7 @@ const getBuilderSchema = async (dsl)=>{
     const connector = await getConnector(connectorId);
     return connector.discoverSchema();
 };
-class VBIBuilder {
+class VBIChartBuilder {
     doc;
     dsl;
     adapters;
@@ -1110,7 +2266,7 @@ class VBIBuilder {
     constructor(doc, options){
         this.doc = doc;
         this.dsl = doc.getMap('dsl');
-        this.adapters = resolveVBIBuilderAdapters(options?.adapters);
+        this.adapters = resolveVBIChartBuilderAdapters(options?.adapters);
         this.undoManager = new undo_manager_UndoManager(this.dsl);
         this.chartType = new ChartTypeBuilder(doc, this.dsl);
         this.measures = new MeasuresBuilder(doc, this.dsl);
@@ -1123,7 +2279,7 @@ class VBIBuilder {
     }
     applyUpdate = (update, transactionOrigin)=>applyUpdateToDoc(this.doc, update, transactionOrigin);
     encodeStateAsUpdate = (targetStateVector)=>encodeDocStateAsUpdate(this.doc, targetStateVector);
-    buildVSeed = async ()=>{
+    buildVSeed = async (options = {})=>{
         const vbiDSL = this.build();
         const queryDSL = this.adapters.buildVQuery({
             dsl: this.dsl,
@@ -1134,6 +2290,7 @@ class VBIBuilder {
             dsl: this.dsl,
             vbiDSL,
             queryDSL,
+            options,
             builder: this
         });
     };
@@ -1145,14 +2302,13 @@ class VBIBuilder {
             builder: this
         });
     };
-    build = ()=>buildVBIDSL(this.dsl);
-    isEmpty = ()=>isEmptyVBIDSL(this.dsl);
+    build = ()=>buildVBIChartDSL(this.dsl);
+    isEmpty = ()=>isEmptyVBIChartDSL(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;
+    return 'field' === ensureId && 'string' == typeof obj.field;
 };
 const toYMap = (obj, ensureId = false)=>{
     const yMap = new external_yjs_Map();
@@ -1160,23 +2316,9 @@ const toYMap = (obj, ensureId = false)=>{
     for (const [key, value] of Object.entries(obj)){
         if (('conditions' === key || 'children' === key) && Array.isArray(value)) {
             const yArr = new external_yjs_Array();
-            for (const child of value){
-                if (child instanceof external_yjs_Map) {
-                    yArr.push([
-                        child
-                    ]);
-                    continue;
-                }
-                if ('object' == typeof child && null !== child) {
-                    yArr.push([
-                        toYMap(child, ensureId)
-                    ]);
-                    continue;
-                }
-                yArr.push([
-                    child
-                ]);
-            }
+            for (const child of value)yArr.push([
+                toYMap(child, ensureId)
+            ]);
             yMap.set(key, yArr);
             continue;
         }
@@ -1186,65 +2328,34 @@ const toYMap = (obj, ensureId = false)=>{
 };
 const ensureYArray = (arr, ensureId = false)=>{
     if (!arr) return new external_yjs_Array();
-    if (arr instanceof external_yjs_Array) return arr;
     const yArr = new external_yjs_Array();
-    for (const item of arr){
-        if (item instanceof external_yjs_Map) {
-            yArr.push([
-                item
-            ]);
-            continue;
-        }
-        if ('object' == typeof item && null !== item) {
-            yArr.push([
-                toYMap(item, ensureId)
-            ]);
-            continue;
-        }
-        yArr.push([
-            item
-        ]);
-    }
+    for (const item of arr)yArr.push([
+        toYMap(item, ensureId)
+    ]);
     return yArr;
 };
-const getDefaultWhereFilter = ()=>({
+const ensureWhereGroup = (whereFilter)=>{
+    const source = whereFilter ?? {
         id: 'root',
         op: 'and',
         conditions: []
-    });
-const isFilterGroupInput = (value)=>'object' == typeof value && null !== value;
-const ensureWhereGroup = (whereFilter)=>{
-    const sourceWhereFilter = whereFilter instanceof external_yjs_Map || isFilterGroupInput(whereFilter) ? whereFilter : getDefaultWhereFilter();
-    const whereGroup = sourceWhereFilter instanceof external_yjs_Map ? sourceWhereFilter : createWhereGroup();
-    if (sourceWhereFilter instanceof external_yjs_Map) {
-        if (!(whereGroup.get('conditions') instanceof external_yjs_Array)) whereGroup.set('conditions', new external_yjs_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));
+    };
+    const whereGroup = createWhereGroup();
+    whereGroup.set('id', source.id);
+    whereGroup.set('op', source.op);
+    whereGroup.set('conditions', ensureYArray(source.conditions, true));
     return whereGroup;
 };
-const getDefaultHavingFilter = ()=>({
+const ensureHavingGroup = (havingFilter)=>{
+    const source = havingFilter ?? {
         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_Map || ensure_having_group_isFilterGroupInput(havingFilter) ? havingFilter : getDefaultHavingFilter();
-    const havingGroup = sourceHavingFilter instanceof external_yjs_Map ? sourceHavingFilter : createHavingGroup();
-    if (sourceHavingFilter instanceof external_yjs_Map) {
-        if (!(havingGroup.get('conditions') instanceof external_yjs_Array)) havingGroup.set('conditions', new external_yjs_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));
+    };
+    const havingGroup = createHavingGroup();
+    havingGroup.set('id', source.id);
+    havingGroup.set('op', source.op);
+    havingGroup.set('conditions', ensureYArray(source.conditions, true));
     return havingGroup;
 };
 const setBaseDSLFields = (dsl, vbi)=>{
@@ -1255,7 +2366,7 @@ const setBaseDSLFields = (dsl, vbi)=>{
     if (vbi.locale) dsl.set('locale', vbi.locale);
     if (void 0 !== vbi.version) dsl.set('version', vbi.version);
 };
-const fromVBIDSLInput = (vbi, options)=>{
+const createChartBuilderFromVBIChartDSLInput = (vbi, options)=>{
     const doc = new Doc();
     const dsl = doc.getMap('dsl');
     doc.transact(()=>{
@@ -1265,9 +2376,9 @@ const fromVBIDSLInput = (vbi, options)=>{
         dsl.set('measures', ensureYArray(vbi.measures, 'field'));
         dsl.set('dimensions', ensureYArray(vbi.dimensions, 'field'));
     });
-    return new VBIBuilder(doc, options);
+    return new VBIChartBuilder(doc, options);
 };
-const generateEmptyDSL = (connectorId)=>({
+const generateEmptyChartDSL = (connectorId)=>({
         connectorId,
         chartType: 'table',
         measures: [],
@@ -1299,15 +2410,14 @@ const mergeBuilderOptions = (base, overrides)=>{
     };
 };
 function createVBI(defaultBuilderOptions) {
-    const from = (vbi, builderOptions)=>fromVBIDSLInput(vbi, mergeBuilderOptions(defaultBuilderOptions, builderOptions));
+    const createChart = (vbi, builderOptions)=>createChartBuilderFromVBIChartDSLInput(vbi, mergeBuilderOptions(defaultBuilderOptions, builderOptions));
     return {
         connectorMap: connectorMap,
         registerConnector: registerConnector,
         getConnector: getConnector,
-        generateEmptyDSL: generateEmptyDSL,
-        from,
-        create: from
+        generateEmptyChartDSL: generateEmptyChartDSL,
+        createChart
     };
 }
 const VBI = createVBI();
-export { ChartTypeBuilder, DimensionsBuilder, HavingFilterBuilder, LimitBuilder, LocaleBuilder, MeasuresBuilder, ThemeBuilder, undo_manager_UndoManager as UndoManager, VBI, VBIBuilder, WhereFilterBuilder, buildVQuery, createVBI, defaultVBIBuilderAdapters, findTreeNodesBy, id_id as id, isVBIFilter, isVBIHavingFilter, isVBIHavingGroup, isVBIWhereGroup, preorderTraverse, resolveVBIBuilderAdapters };
+export { ChartTypeBuilder, DimensionsBuilder, HavingFilterBuilder, LimitBuilder, LocaleBuilder, MeasuresBuilder, ThemeBuilder, undo_manager_UndoManager as UndoManager, VBI, VBIChartBuilder, WhereFilterBuilder, buildVQuery, createVBI, defaultVBIChartBuilderAdapters, findTreeNodesBy, id_id as id, isVBIFilter, isVBIHavingFilter, isVBIHavingGroup, isVBIWhereGroup, preorderTraverse, resolveVBIChartBuilderAdapters };