@visactor/vbi 0.4.17 → 0.4.20

package/dist/types/dsl/vbi/vbi.d.ts

@@ -1,30 +1,126 @@
 import { z } from 'zod';
-export declare const zVBIDSL: z.ZodObject<{
+export declare const zVBIChartDSL: z.ZodObject<{
     connectorId: z.ZodString;
     chartType: z.ZodCustom<any, any>;
     dimensions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         id: z.ZodString;
         field: z.ZodString;
         alias: z.ZodString;
+        encoding: z.ZodOptional<z.ZodEnum<{
+            column: "column";
+            xAxis: "xAxis";
+            yAxis: "yAxis";
+            angle: "angle";
+            color: "color";
+            detail: "detail";
+            tooltip: "tooltip";
+            label: "label";
+            row: "row";
+            player: "player";
+            hierarchy: "hierarchy";
+        }>>;
+        aggregate: z.ZodOptional<z.ZodObject<{
+            func: z.ZodEnum<{
+                toYear: "toYear";
+                toQuarter: "toQuarter";
+                toMonth: "toMonth";
+                toWeek: "toWeek";
+                toDay: "toDay";
+                toHour: "toHour";
+                toMinute: "toMinute";
+                toSecond: "toSecond";
+            }>;
+        }, z.core.$strip>>;
+        sort: z.ZodOptional<z.ZodObject<{
+            order: z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>;
+        }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodType<import("..").VBIDimensionGroup, unknown, z.core.$ZodTypeInternals<import("..").VBIDimensionGroup, unknown>>]>>;
     measures: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         id: z.ZodString;
         field: z.ZodString;
         alias: z.ZodString;
         encoding: z.ZodEnum<{
-            yAxis: "yAxis";
+            value: "value";
+            column: "column";
             xAxis: "xAxis";
+            yAxis: "yAxis";
+            angle: "angle";
             color: "color";
-            label: "label";
+            detail: "detail";
             tooltip: "tooltip";
+            label: "label";
+            min: "min";
+            max: "max";
+            median: "median";
+            primaryYAxis: "primaryYAxis";
+            secondaryYAxis: "secondaryYAxis";
+            radius: "radius";
             size: "size";
+            q1: "q1";
+            q3: "q3";
+            outliers: "outliers";
+            x0: "x0";
+            x1: "x1";
         }>;
         aggregate: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            func: z.ZodLiteral<"sum" | "count" | "avg" | "min" | "max">;
+            func: z.ZodEnum<{
+                count: "count";
+                countDistinct: "countDistinct";
+                sum: "sum";
+                avg: "avg";
+                min: "min";
+                max: "max";
+                variance: "variance";
+                variancePop: "variancePop";
+                stddev: "stddev";
+                median: "median";
+            }>;
         }, z.core.$strip>, z.ZodObject<{
             func: z.ZodLiteral<"quantile">;
-            quantile: z.ZodNumber;
+            quantile: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>], "func">;
+        format: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            autoFormat: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                number: "number";
+                percent: "percent";
+                permille: "permille";
+                scientific: "scientific";
+            }>>>;
+            ratio: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            symbol: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+            thousandSeparator: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            prefix: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+            suffix: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+            fractionDigits: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            significantDigits: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            roundingPriority: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                morePrecision: "morePrecision";
+                lessPrecision: "lessPrecision";
+            }>>>;
+            roundingMode: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                floor: "floor";
+                ceil: "ceil";
+                expand: "expand";
+                trunc: "trunc";
+                halfCeil: "halfCeil";
+                halfFloor: "halfFloor";
+                halfExpand: "halfExpand";
+                halfTrunc: "halfTrunc";
+                halfEven: "halfEven";
+            }>>>;
+            autoFormat: z.ZodOptional<z.ZodLiteral<false>>;
+        }, z.core.$strip>]>>;
+        sort: z.ZodOptional<z.ZodObject<{
+            order: z.ZodEnum<{
+                asc: "asc";
+                desc: "desc";
+            }>;
+        }, z.core.$strip>>;
     }, z.core.$strip>, z.ZodType<import("..").VBIMeasureGroup, unknown, z.core.$ZodTypeInternals<import("..").VBIMeasureGroup, unknown>>]>>;
     havingFilter: z.ZodDefault<z.ZodOptional<z.ZodType<{
         id: string;
@@ -67,5 +163,5 @@ export declare const zVBIDSL: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     version: z.ZodNumber;
 }, z.core.$strip>;
-export type VBIDSLInput = z.input<typeof zVBIDSL>;
-export type VBIDSL = z.output<typeof zVBIDSL>;
+export type VBIChartDSLInput = z.input<typeof zVBIChartDSL>;
+export type VBIChartDSL = z.output<typeof zVBIChartDSL>;

package/dist/types/dsl/whereFilter/date.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export type VBIWhereDateInput = string | Date;
+export type VBIWhereDateUnit = 'year' | 'quarter' | 'month' | 'week' | 'day';
+export type VBIWhereDateBounds = '[)' | '[]';
+export type VBIWhereDatePeriod = {
+    unit: 'year';
+    year: number;
+} | {
+    unit: 'quarter';
+    year: number;
+    quarter: 1 | 2 | 3 | 4;
+} | {
+    unit: 'month';
+    year: number;
+    month: number;
+} | {
+    unit: 'week';
+    year: number;
+    week: number;
+} | {
+    unit: 'day';
+    date: VBIWhereDateInput;
+};
+export type VBIWhereDatePredicate = {
+    type: 'range';
+    start: VBIWhereDateInput;
+    end: VBIWhereDateInput;
+    bounds?: VBIWhereDateBounds;
+} | {
+    type: 'relative';
+    mode: 'last' | 'next';
+    amount: number;
+    unit: VBIWhereDateUnit;
+    complete?: boolean;
+} | {
+    type: 'current';
+    unit: VBIWhereDateUnit;
+    offset?: number;
+} | ({
+    type: 'period';
+} & VBIWhereDatePeriod);
+export declare const zVBIWhereDatePredicate: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"range">;
+    start: z.ZodUnion<readonly [z.ZodString, z.ZodDate]>;
+    end: z.ZodUnion<readonly [z.ZodString, z.ZodDate]>;
+    bounds: z.ZodOptional<z.ZodEnum<{
+        "[)": "[)";
+        "[]": "[]";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"relative">;
+    mode: z.ZodEnum<{
+        last: "last";
+        next: "next";
+    }>;
+    amount: z.ZodNumber;
+    unit: z.ZodEnum<{
+        year: "year";
+        quarter: "quarter";
+        month: "month";
+        week: "week";
+        day: "day";
+    }>;
+    complete: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"current">;
+    unit: z.ZodEnum<{
+        year: "year";
+        quarter: "quarter";
+        month: "month";
+        week: "week";
+        day: "day";
+    }>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+    type: z.ZodLiteral<"period">;
+}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    unit: z.ZodLiteral<"year">;
+    year: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    unit: z.ZodLiteral<"quarter">;
+    year: z.ZodNumber;
+    quarter: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>;
+}, z.core.$strip>, z.ZodObject<{
+    unit: z.ZodLiteral<"month">;
+    year: z.ZodNumber;
+    month: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    unit: z.ZodLiteral<"week">;
+    year: z.ZodNumber;
+    week: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    unit: z.ZodLiteral<"day">;
+    date: z.ZodUnion<readonly [z.ZodString, z.ZodDate]>;
+}, z.core.$strip>], "unit">>]>;

package/dist/types/dsl/whereFilter/filters.d.ts

@@ -1,22 +1,159 @@
 import { z } from 'zod';
+import type { VBIWhereDatePredicate } from './date';
+export type { VBIWhereDateInput, VBIWhereDateUnit, VBIWhereDateBounds, VBIWhereDatePeriod, VBIWhereDatePredicate, } from './date';
+export { zVBIWhereDatePredicate } from './date';
 declare const zWhereLogicalOperator: z.ZodEnum<{
     and: "and";
     or: "or";
 }>;
-export declare const zVBIFilter: z.ZodObject<{
+export type VBIWhereScalarFilter = {
+    id: string;
+    field: string;
+    op: string;
+    value?: unknown;
+};
+export type VBIWhereDateFilter = {
+    id: string;
+    field: string;
+    op: 'date';
+    value: VBIWhereDatePredicate;
+};
+export type VBIWhereFilter = VBIWhereScalarFilter | VBIWhereDateFilter;
+export declare const zVBIWhereDateFilter: z.ZodObject<{
+    id: z.ZodString;
+    field: z.ZodString;
+    op: z.ZodLiteral<"date">;
+    value: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"range">;
+        start: z.ZodUnion<readonly [z.ZodString, z.ZodDate]>;
+        end: z.ZodUnion<readonly [z.ZodString, z.ZodDate]>;
+        bounds: z.ZodOptional<z.ZodEnum<{
+            "[)": "[)";
+            "[]": "[]";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"relative">;
+        mode: z.ZodEnum<{
+            last: "last";
+            next: "next";
+        }>;
+        amount: z.ZodNumber;
+        unit: z.ZodEnum<{
+            year: "year";
+            quarter: "quarter";
+            month: "month";
+            week: "week";
+            day: "day";
+        }>;
+        complete: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"current">;
+        unit: z.ZodEnum<{
+            year: "year";
+            quarter: "quarter";
+            month: "month";
+            week: "week";
+            day: "day";
+        }>;
+        offset: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+        type: z.ZodLiteral<"period">;
+    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        unit: z.ZodLiteral<"year">;
+        year: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        unit: z.ZodLiteral<"quarter">;
+        year: z.ZodNumber;
+        quarter: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        unit: z.ZodLiteral<"month">;
+        year: z.ZodNumber;
+        month: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        unit: z.ZodLiteral<"week">;
+        year: z.ZodNumber;
+        week: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        unit: z.ZodLiteral<"day">;
+        date: z.ZodUnion<readonly [z.ZodString, z.ZodDate]>;
+    }, z.core.$strip>], "unit">>]>;
+}, z.core.$strip>;
+export declare const zVBIWhereScalarFilter: z.ZodObject<{
     id: z.ZodString;
     field: z.ZodString;
-    op: z.ZodOptional<z.ZodString>;
+    op: z.ZodString;
     value: z.ZodOptional<z.ZodAny>;
 }, z.core.$strip>;
-export type VBIFilter = z.infer<typeof zVBIFilter>;
+export declare const zVBIWhereFilter: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
+    field: z.ZodString;
+    op: z.ZodLiteral<"date">;
+    value: z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"range">;
+        start: z.ZodUnion<readonly [z.ZodString, z.ZodDate]>;
+        end: z.ZodUnion<readonly [z.ZodString, z.ZodDate]>;
+        bounds: z.ZodOptional<z.ZodEnum<{
+            "[)": "[)";
+            "[]": "[]";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"relative">;
+        mode: z.ZodEnum<{
+            last: "last";
+            next: "next";
+        }>;
+        amount: z.ZodNumber;
+        unit: z.ZodEnum<{
+            year: "year";
+            quarter: "quarter";
+            month: "month";
+            week: "week";
+            day: "day";
+        }>;
+        complete: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"current">;
+        unit: z.ZodEnum<{
+            year: "year";
+            quarter: "quarter";
+            month: "month";
+            week: "week";
+            day: "day";
+        }>;
+        offset: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodIntersection<z.ZodObject<{
+        type: z.ZodLiteral<"period">;
+    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        unit: z.ZodLiteral<"year">;
+        year: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        unit: z.ZodLiteral<"quarter">;
+        year: z.ZodNumber;
+        quarter: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>;
+    }, z.core.$strip>, z.ZodObject<{
+        unit: z.ZodLiteral<"month">;
+        year: z.ZodNumber;
+        month: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        unit: z.ZodLiteral<"week">;
+        year: z.ZodNumber;
+        week: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        unit: z.ZodLiteral<"day">;
+        date: z.ZodUnion<readonly [z.ZodString, z.ZodDate]>;
+    }, z.core.$strip>], "unit">>]>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    field: z.ZodString;
+    op: z.ZodString;
+    value: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>]>;
 type VBIWhereBranch = {
     id: string;
     op: z.infer<typeof zWhereLogicalOperator>;
     conditions: VBIWhereClause[];
 };
 export type VBIWhereGroup = VBIWhereBranch;
-export type VBIWhereClause = VBIFilter | VBIWhereGroup;
+export type VBIWhereClause = VBIWhereFilter | VBIWhereGroup;
 export declare const zVBIWhereGroup: z.ZodType<VBIWhereGroup>;
 export declare const zVBIWhereClause: z.ZodType<VBIWhereClause>;
-export {};

package/dist/utils/filter-guards.d.ts

@@ -1,5 +1,5 @@
-import type { VBIFilter, VBIWhereClause, VBIWhereGroup, VBIHavingClause, VBIHavingFilter, VBIHavingGroup } from '../types/dsl';
-export declare function isVBIFilter(clause: VBIWhereClause): clause is VBIFilter;
+import type { VBIWhereFilter, VBIWhereClause, VBIWhereGroup, VBIHavingClause, VBIHavingFilter, VBIHavingGroup } from '../types/dsl';
+export declare function isVBIFilter(clause: VBIWhereClause): clause is VBIWhereFilter;
 export declare function isVBIWhereGroup(clause: VBIWhereClause): clause is VBIWhereGroup;
 export declare function isVBIHavingFilter(clause: VBIHavingClause): clause is VBIHavingFilter;
 export declare function isVBIHavingGroup(clause: VBIHavingClause): clause is VBIHavingGroup;

package/dist/vbi/create-vbi.d.ts

@@ -1,14 +1,14 @@
-export declare const createVBI: () => {
-    connectorMap: Map<string, {
-        discoverSchema: () => Promise<import("..").VBISchema>;
-        query: (queryProps: import("..").VBIQueryProps) => Promise<import("..").VBIQueryResult>;
-    } | (() => Promise<import("..").VBIConnector>)>;
-    registerConnector: (id: import("../types/connector/connector").VBIConnectorId, connector: import("..").VBIConnector | (() => Promise<import("..").VBIConnector>)) => void;
-    getConnector: (id: import("../types/connector/connector").VBIConnectorId) => Promise<{
-        discoverSchema: () => Promise<import("..").VBISchema>;
-        query: (queryProps: import("..").VBIQueryProps) => Promise<import("..").VBIQueryResult>;
-    }>;
-    generateEmptyDSL: (connectorId: import("../types/connector/connector").VBIConnectorId) => import("..").VBIDSL;
-    from: (vbi: import("..").VBIDSLInput) => import("..").VBIBuilder;
-    create: (vbi: import("..").VBIDSLInput) => import("..").VBIBuilder;
-};
+import type { DefaultVBIQueryDSL, DefaultVBISeedDSL } from '../builder/adapters/vquery-vseed/types';
+import { connectorMap, getConnector, registerConnector } from '../builder/connector';
+import type { VBIChartBuilder } from '../builder/builder';
+import type { VBIChartDSLInput, VBIChartBuilderOptions } from '../types';
+import { generateEmptyChartDSL } from './generate-empty-dsl';
+export interface VBIInstance<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
+    connectorMap: typeof connectorMap;
+    registerConnector: typeof registerConnector;
+    getConnector: typeof getConnector;
+    generateEmptyChartDSL: typeof generateEmptyChartDSL;
+    createChart: (vbi: VBIChartDSLInput, builderOptions?: VBIChartBuilderOptions<TQueryDSL, TSeedDSL>) => VBIChartBuilder<TQueryDSL, TSeedDSL>;
+}
+export declare function createVBI(): VBIInstance<DefaultVBIQueryDSL, DefaultVBISeedDSL>;
+export declare function createVBI<TQueryDSL, TSeedDSL>(defaultBuilderOptions: VBIChartBuilderOptions<TQueryDSL, TSeedDSL>): VBIInstance<TQueryDSL, TSeedDSL>;

package/dist/vbi/from/from-vbi-dsl-input.d.ts

@@ -1,3 +1,4 @@
-import type { VBIDSLInput } from '../../types';
-import { VBIBuilder } from '../../builder';
-export declare const fromVBIDSLInput: (vbi: VBIDSLInput) => VBIBuilder;
+import type { DefaultVBIQueryDSL, DefaultVBISeedDSL } from '../../builder/adapters/vquery-vseed/types';
+import type { VBIChartDSLInput, VBIChartBuilderOptions } from '../../types';
+import { VBIChartBuilder } from '../../builder/builder';
+export declare const createChartBuilderFromVBIChartDSLInput: <TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL>(vbi: VBIChartDSLInput, options?: VBIChartBuilderOptions<TQueryDSL, TSeedDSL>) => VBIChartBuilder<TQueryDSL, TSeedDSL>;

package/dist/vbi/from/set-base-dsl-fields.d.ts

@@ -1,3 +1,3 @@
 import * as Y from 'yjs';
-import type { VBIDSLInput } from '../../types';
-export declare const setBaseDSLFields: (dsl: Y.Map<any>, vbi: VBIDSLInput) => void;
+import type { VBIChartDSLInput } from '../../types';
+export declare const setBaseDSLFields: (dsl: Y.Map<any>, vbi: VBIChartDSLInput) => void;

package/dist/vbi/generate-empty-dsl.d.ts

@@ -1,3 +1,3 @@
 import type { VBIConnectorId } from '../types/connector/connector';
-import type { VBIDSL } from '../types';
-export declare const generateEmptyDSL: (connectorId: VBIConnectorId) => VBIDSL;
+import type { VBIChartDSL } from '../types';
+export declare const generateEmptyChartDSL: (connectorId: VBIConnectorId) => VBIChartDSL;

package/dist/vbi/normalize/types.d.ts

@@ -1,5 +1,5 @@
 export interface FilterGroupInput {
-    id?: string;
-    op?: 'and' | 'or';
-    conditions?: any[];
+    id: string;
+    op: 'and' | 'or';
+    conditions: any[];
 }

package/dist/vbi.d.ts

@@ -1,14 +1 @@
-export declare const VBI: {
-    connectorMap: Map<string, {
-        discoverSchema: () => Promise<import("./types").VBISchema>;
-        query: (queryProps: import("./types").VBIQueryProps) => Promise<import("./types").VBIQueryResult>;
-    } | (() => Promise<import("./types").VBIConnector>)>;
-    registerConnector: (id: import("./types/connector/connector").VBIConnectorId, connector: import("./types").VBIConnector | (() => Promise<import("./types").VBIConnector>)) => void;
-    getConnector: (id: import("./types/connector/connector").VBIConnectorId) => Promise<{
-        discoverSchema: () => Promise<import("./types").VBISchema>;
-        query: (queryProps: import("./types").VBIQueryProps) => Promise<import("./types").VBIQueryResult>;
-    }>;
-    generateEmptyDSL: (connectorId: import("./types/connector/connector").VBIConnectorId) => import("./types").VBIDSL;
-    from: (vbi: import("./types").VBIDSLInput) => import("./builder").VBIBuilder;
-    create: (vbi: import("./types").VBIDSLInput) => import("./builder").VBIBuilder;
-};
+export declare const VBI: import(".").VBIInstance<import("./builder").DefaultVBIQueryDSL, import("@visactor/vseed").VSeed>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visactor/vbi",
-  "version": "0.4.17",
+  "version": "0.4.20",
   "license": "MIT",
   "homepage": "https://visactor.github.io/VBI",
   "bugs": "https://github.com/VisActor/VBI/issues",
@@ -33,11 +33,11 @@
     "uuid": "13.0.0",
     "yjs": "13.6.28",
     "zod": "4.0.17",
-    "@visactor/vseed": "0.4.17"
+    "@visactor/vseed": "0.4.20"
   },
   "optionalDependencies": {
-    "@visactor/vquery": "0.4.17",
-    "@visactor/vseed": "0.4.17"
+    "@visactor/vquery": "0.4.20",
+    "@visactor/vseed": "0.4.20"
   },
   "devDependencies": {
     "@eslint/js": "9.39.0",
@@ -51,7 +51,7 @@
     "ts-morph": "26.0.0",
     "typescript": "5.9.3",
     "typescript-eslint": "8.48.0",
-    "@visactor/vquery": "0.4.17"
+    "@visactor/vquery": "0.4.20"
   },
   "scripts": {
     "build": "rslib build",

package/dist/builder/modules/build-vquery.d.ts

@@ -1,4 +0,0 @@
-import * as Y from 'yjs';
-import type { VQueryDSL } from '@visactor/vquery';
-import type { VBIBuilder } from '../vbi-builder';
-export declare const buildVQueryDSL: (dsl: Y.Map<any>, builder: VBIBuilder) => VQueryDSL;

package/dist/builder/modules/build-vseed.d.ts

@@ -1,8 +0,0 @@
-import type { VSeedDSL } from '@visactor/vseed';
-import type { VQueryDSL } from '@visactor/vquery';
-import type { VBIDSL } from '../../types';
-export interface BuildVSeedInput {
-    vbiDSL: VBIDSL;
-    queryDSL: VQueryDSL;
-}
-export declare const buildVSeedDSL: ({ vbiDSL, queryDSL }: BuildVSeedInput) => Promise<VSeedDSL>;

package/dist/builder/modules/create-builder-features.d.ts

@@ -1,14 +0,0 @@
-import * as Y from 'yjs';
-import { DimensionsBuilder, MeasuresBuilder, HavingFilterBuilder, WhereFilterBuilder, ChartTypeBuilder, ThemeBuilder, LocaleBuilder, LimitBuilder, UndoManager } from '../features';
-export interface BuilderFeatureInstances {
-    chartType: ChartTypeBuilder;
-    measures: MeasuresBuilder;
-    dimensions: DimensionsBuilder;
-    havingFilter: HavingFilterBuilder;
-    whereFilter: WhereFilterBuilder;
-    theme: ThemeBuilder;
-    locale: LocaleBuilder;
-    limit: LimitBuilder;
-    undoManager: UndoManager;
-}
-export declare const createBuilderFeatures: (doc: Y.Doc, dsl: Y.Map<any>) => BuilderFeatureInstances;