@visactor/vbi 0.4.15 → 0.4.17

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

@@ -1,9 +1,8 @@
 import type { VQueryDSL } from '@visactor/vquery';
 import type { VBIDSL } from '../dsl';
 import type { VSeedDSL } from '@visactor/vseed';
-import type { MeasuresBuilder, DimensionsBuilder, ChartTypeBuilder, HavingFiltersBuilder, WhereFiltersBuilder } from '../../builder/sub-builders';
+import type { MeasuresBuilder, DimensionsBuilder, ChartTypeBuilder, HavingFilterBuilder, WhereFilterBuilder, ThemeBuilder, LocaleBuilder, LimitBuilder, UndoManager } from '../../builder/features';
 import type { Map, Doc } from 'yjs';
-import type { UndoManager } from '../../builder/undo-manager';
 export interface VBIBuilderInterface {
     doc: Doc;
     dsl: Map<any>;
@@ -11,12 +10,15 @@ export interface VBIBuilderInterface {
     chartType: ChartTypeBuilder;
     measures: MeasuresBuilder;
     dimensions: DimensionsBuilder;
-    havingFilters: HavingFiltersBuilder;
-    whereFilters: WhereFiltersBuilder;
+    havingFilter: HavingFilterBuilder;
+    whereFilter: WhereFilterBuilder;
+    theme: ThemeBuilder;
+    locale: LocaleBuilder;
+    limit: LimitBuilder;
     applyUpdate: (update: Uint8Array, origin?: any) => void;
     encodeStateAsUpdate: (targetStateVector?: Uint8Array) => Uint8Array;
     buildVSeed: () => Promise<VSeedDSL>;
     buildVQuery: () => VQueryDSL;
     build: () => VBIDSL;
-    setLimit: (limit: number) => this;
+    isEmpty: () => boolean;
 }

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

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 export declare const zVBIDimensionSchema: z.ZodObject<{
+    id: z.ZodString;
     field: z.ZodString;
     alias: z.ZodString;
 }, z.core.$strip>;
 export declare const zVBIDimensionGroupSchema: z.ZodType<VBIDimensionGroup>;
 export declare const zVBIDimensionTree: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
     field: z.ZodString;
     alias: z.ZodString;
 }, z.core.$strip>, z.ZodType<VBIDimensionGroup, unknown, z.core.$ZodTypeInternals<VBIDimensionGroup, unknown>>]>>;

package/dist/types/dsl/{havingFilters → havingFilter}/having.d.ts

@@ -1,4 +1,8 @@
 import { z } from 'zod';
+declare const zHavingLogicalOperator: z.ZodEnum<{
+    and: "and";
+    or: "or";
+}>;
 export declare const zVBIHavingFilter: z.ZodObject<{
     id: z.ZodString;
     field: z.ZodString;
@@ -6,13 +10,13 @@ export declare const zVBIHavingFilter: z.ZodObject<{
     value: z.ZodOptional<z.ZodAny>;
 }, z.core.$strip>;
 export type VBIHavingFilter = z.infer<typeof zVBIHavingFilter>;
-export declare const zVBIHavingGroup: z.ZodType<VBIHavingGroup>;
-export declare const zVBIHavingClause: z.ZodType<VBIHavingClause>;
-export type VBIHavingGroup = {
+type VBIHavingBranch = {
     id: string;
-    op: 'and' | 'or';
+    op: z.infer<typeof zHavingLogicalOperator>;
     conditions: VBIHavingClause[];
 };
+export type VBIHavingGroup = VBIHavingBranch;
 export type VBIHavingClause = VBIHavingFilter | VBIHavingGroup;
-export declare function isVBIHavingFilter(clause: VBIHavingClause): clause is VBIHavingFilter;
-export declare function isVBIHavingGroup(clause: VBIHavingClause): clause is VBIHavingGroup;
+export declare const zVBIHavingGroup: z.ZodType<VBIHavingGroup>;
+export declare const zVBIHavingClause: z.ZodType<VBIHavingClause>;
+export {};

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

@@ -1,8 +1,7 @@
 export type { VBIDimensionTree, VBIDimensionGroup, VBIDimension } from './dimensions/dimensions';
 export type { VBIMeasureTree, VBIMeasureGroup, VBIMeasure } from './measures/measures';
-export type { VBIFilter, VBIWhereGroup, VBIWhereClause } from './whereFilters/filters';
-export { isVBIFilter, isVBIWhereGroup } from './whereFilters/filters';
-export type { VBIHavingFilter, VBIHavingGroup, VBIHavingClause } from './havingFilters/having';
-export { isVBIHavingFilter, isVBIHavingGroup } from './havingFilters/having';
+export type { VBIFilter, VBIWhereGroup, VBIWhereClause } from './whereFilter/filters';
+export type { VBIHavingFilter, VBIHavingGroup, VBIHavingClause } from './havingFilter/having';
 export type { VBIDSLTheme } from './theme/theme';
-export type { VBIDSL } from './vbi/vbi';
+export type { VBIDSLLocale } from './locale/locale';
+export type { VBIDSL, VBIDSLInput } from './vbi/vbi';

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

@@ -1,8 +1,16 @@
 import { z } from 'zod';
 export declare const zVBIMeasure: z.ZodObject<{
+    id: z.ZodString;
     field: z.ZodString;
     alias: z.ZodString;
-    encoding: z.ZodLiteral<"yAxis" | "xAxis" | "color" | "label" | "tooltip" | "size">;
+    encoding: z.ZodEnum<{
+        yAxis: "yAxis";
+        xAxis: "xAxis";
+        color: "color";
+        label: "label";
+        tooltip: "tooltip";
+        size: "size";
+    }>;
     aggregate: z.ZodDiscriminatedUnion<[z.ZodObject<{
         func: z.ZodLiteral<"sum" | "count" | "avg" | "min" | "max">;
     }, z.core.$strip>, z.ZodObject<{
@@ -12,9 +20,17 @@ export declare const zVBIMeasure: z.ZodObject<{
 }, z.core.$strip>;
 export declare const zVBIMeasureGroup: z.ZodType<VBIMeasureGroup>;
 export declare const zVBIMeasureTree: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
     field: z.ZodString;
     alias: z.ZodString;
-    encoding: z.ZodLiteral<"yAxis" | "xAxis" | "color" | "label" | "tooltip" | "size">;
+    encoding: z.ZodEnum<{
+        yAxis: "yAxis";
+        xAxis: "xAxis";
+        color: "color";
+        label: "label";
+        tooltip: "tooltip";
+        size: "size";
+    }>;
     aggregate: z.ZodDiscriminatedUnion<[z.ZodObject<{
         func: z.ZodLiteral<"sum" | "count" | "avg" | "min" | "max">;
     }, z.core.$strip>, z.ZodObject<{

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

@@ -3,13 +3,22 @@ export declare const zVBIDSL: 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;
     }, 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.ZodLiteral<"yAxis" | "xAxis" | "color" | "label" | "tooltip" | "size">;
+        encoding: z.ZodEnum<{
+            yAxis: "yAxis";
+            xAxis: "xAxis";
+            color: "color";
+            label: "label";
+            tooltip: "tooltip";
+            size: "size";
+        }>;
         aggregate: z.ZodDiscriminatedUnion<[z.ZodObject<{
             func: z.ZodLiteral<"sum" | "count" | "avg" | "min" | "max">;
         }, z.core.$strip>, z.ZodObject<{
@@ -17,8 +26,36 @@ export declare const zVBIDSL: z.ZodObject<{
             quantile: z.ZodNumber;
         }, z.core.$strip>], "func">;
     }, z.core.$strip>, z.ZodType<import("..").VBIMeasureGroup, unknown, z.core.$ZodTypeInternals<import("..").VBIMeasureGroup, unknown>>]>>;
-    havingFilters: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodType<import("..").VBIHavingClause, unknown, z.core.$ZodTypeInternals<import("..").VBIHavingClause, unknown>>>>>;
-    whereFilters: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodType<import("..").VBIWhereClause, unknown, z.core.$ZodTypeInternals<import("..").VBIWhereClause, unknown>>>>>;
+    havingFilter: z.ZodDefault<z.ZodOptional<z.ZodType<{
+        id: string;
+        op: z.infer<z.ZodEnum<{
+            and: "and";
+            or: "or";
+        }>>;
+        conditions: import("..").VBIHavingClause[];
+    }, unknown, z.core.$ZodTypeInternals<{
+        id: string;
+        op: z.infer<z.ZodEnum<{
+            and: "and";
+            or: "or";
+        }>>;
+        conditions: import("..").VBIHavingClause[];
+    }, unknown>>>>;
+    whereFilter: z.ZodDefault<z.ZodOptional<z.ZodType<{
+        id: string;
+        op: z.infer<z.ZodEnum<{
+            and: "and";
+            or: "or";
+        }>>;
+        conditions: import("..").VBIWhereClause[];
+    }, unknown, z.core.$ZodTypeInternals<{
+        id: string;
+        op: z.infer<z.ZodEnum<{
+            and: "and";
+            or: "or";
+        }>>;
+        conditions: import("..").VBIWhereClause[];
+    }, unknown>>>>;
     theme: z.ZodEnum<{
         light: "light";
         dark: "dark";
@@ -30,4 +67,5 @@ export declare const zVBIDSL: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     version: z.ZodNumber;
 }, z.core.$strip>;
-export type VBIDSL = z.infer<typeof zVBIDSL>;
+export type VBIDSLInput = z.input<typeof zVBIDSL>;
+export type VBIDSL = z.output<typeof zVBIDSL>;

package/dist/types/dsl/{whereFilters → whereFilter}/filters.d.ts

@@ -1,4 +1,8 @@
 import { z } from 'zod';
+declare const zWhereLogicalOperator: z.ZodEnum<{
+    and: "and";
+    or: "or";
+}>;
 export declare const zVBIFilter: z.ZodObject<{
     id: z.ZodString;
     field: z.ZodString;
@@ -6,13 +10,13 @@ export declare const zVBIFilter: z.ZodObject<{
     value: z.ZodOptional<z.ZodAny>;
 }, z.core.$strip>;
 export type VBIFilter = z.infer<typeof zVBIFilter>;
-export declare const zVBIWhereGroup: z.ZodType<VBIWhereGroup>;
-export declare const zVBIWhereClause: z.ZodType<VBIWhereClause>;
-export type VBIWhereGroup = {
+type VBIWhereBranch = {
     id: string;
-    op: 'and' | 'or';
+    op: z.infer<typeof zWhereLogicalOperator>;
     conditions: VBIWhereClause[];
 };
+export type VBIWhereGroup = VBIWhereBranch;
 export type VBIWhereClause = VBIFilter | VBIWhereGroup;
-export declare function isVBIFilter(clause: VBIWhereClause): clause is VBIFilter;
-export declare function isVBIWhereGroup(clause: VBIWhereClause): clause is VBIWhereGroup;
+export declare const zVBIWhereGroup: z.ZodType<VBIWhereGroup>;
+export declare const zVBIWhereClause: z.ZodType<VBIWhereClause>;
+export {};

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

@@ -0,0 +1,5 @@
+import type { VBIFilter, VBIWhereClause, VBIWhereGroup, VBIHavingClause, VBIHavingFilter, VBIHavingGroup } from '../types/dsl';
+export declare function isVBIFilter(clause: VBIWhereClause): clause is VBIFilter;
+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/utils/index.d.ts

@@ -1,2 +1,3 @@
 export * from './tree';
 export { id } from './id';
+export * from './filter-guards';

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

@@ -0,0 +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;
+};

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

@@ -0,0 +1,3 @@
+import type { VBIDSLInput } from '../../types';
+import { VBIBuilder } from '../../builder';
+export declare const fromVBIDSLInput: (vbi: VBIDSLInput) => VBIBuilder;

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

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

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

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

package/dist/vbi/normalize/ensure-having-group.d.ts

@@ -0,0 +1,2 @@
+import * as Y from 'yjs';
+export declare const ensureHavingGroup: (havingFilter?: unknown) => Y.Map<any>;

package/dist/vbi/normalize/ensure-where-group.d.ts

@@ -0,0 +1,2 @@
+import * as Y from 'yjs';
+export declare const ensureWhereGroup: (whereFilter?: unknown) => Y.Map<any>;

package/dist/vbi/normalize/ensure-y-array.d.ts

@@ -0,0 +1,3 @@
+import * as Y from 'yjs';
+import { type EnsureIdMode } from './to-y-map';
+export declare const ensureYArray: (arr: any, ensureId?: EnsureIdMode) => Y.Array<any>;

package/dist/vbi/normalize/to-y-map.d.ts

@@ -0,0 +1,3 @@
+import * as Y from 'yjs';
+export type EnsureIdMode = boolean | 'field';
+export declare const toYMap: (obj: Record<string, any>, ensureId?: EnsureIdMode) => Y.Map<any>;

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

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

package/dist/vbi.d.ts

@@ -0,0 +1,14 @@
+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;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visactor/vbi",
-  "version": "0.4.15",
+  "version": "0.4.17",
   "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.15"
+    "@visactor/vseed": "0.4.17"
   },
   "optionalDependencies": {
-    "@visactor/vseed": "0.4.15",
-    "@visactor/vquery": "0.4.15"
+    "@visactor/vquery": "0.4.17",
+    "@visactor/vseed": "0.4.17"
   },
   "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.15"
+    "@visactor/vquery": "0.4.17"
   },
   "scripts": {
     "build": "rslib build",

package/dist/builder/sub-builders/havingFilters/index.d.ts

@@ -1,3 +0,0 @@
-export { HavingFiltersBuilder } from './having-builder';
-export { HavingFiltersNodeBuilder } from './having-node-builder';
-export { HavingGroupBuilder } from './having-group-builder';

package/dist/builder/sub-builders/index.d.ts

@@ -1,5 +0,0 @@
-export { MeasuresBuilder } from './measures';
-export { DimensionsBuilder } from './dimensions';
-export { ChartTypeBuilder } from './chart-type';
-export { WhereFiltersBuilder, WhereGroupBuilder } from './whereFilters';
-export { HavingFiltersBuilder } from './havingFilters';

package/dist/builder/vbi.d.ts

@@ -1,16 +0,0 @@
-import { VBIConnectorId } from '../types/connector/connector';
-import { VBIDSL } from '../types';
-import { VBIBuilder } from './vbi-builder';
-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: VBIConnectorId, connector: import("../types").VBIConnector | (() => Promise<import("../types").VBIConnector>)) => void;
-    getConnector: (id: VBIConnectorId) => Promise<{
-        discoverSchema: () => Promise<import("../types").VBISchema>;
-        query: (queryProps: import("../types").VBIQueryProps) => Promise<import("../types").VBIQueryResult>;
-    }>;
-    generateEmptyDSL: (connectorId: VBIConnectorId) => VBIDSL;
-    from: (vbi: VBIDSL) => VBIBuilder;
-};