@visactor/vbi 0.4.16 → 0.4.19

package/dist/pipeline/vqueryDSL/aggregateMap.d.ts

@@ -0,0 +1,30 @@
+export type VQueryAggregateFunc = 'count' | 'count_distinct' | 'sum' | 'avg' | 'min' | 'max' | 'variance' | 'variance_pop' | 'stddev' | 'median' | 'quantile';
+export type VQueryAggregate = {
+    func: VQueryAggregateFunc;
+    quantile?: number;
+};
+export type VBIAggregateInput = {
+    func: 'count';
+} | {
+    func: 'countDistinct';
+} | {
+    func: 'sum';
+} | {
+    func: 'avg';
+} | {
+    func: 'min';
+} | {
+    func: 'max';
+} | {
+    func: 'variance';
+} | {
+    func: 'variancePop';
+} | {
+    func: 'stddev';
+} | {
+    func: 'median';
+} | {
+    func: 'quantile';
+    quantile?: number;
+};
+export declare const mapAggregateForVQuery: (aggregate: VBIAggregateInput | undefined) => VQueryAggregate | undefined;

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

@@ -1,4 +1,3 @@
 import type { VQueryDSL } from '@visactor/vquery';
-import type { VBIDSL } from '../../types';
-import type { VBIBuilder } from '../../builder';
-export declare const buildVQuery: (vbiDSL: VBIDSL, builder: VBIBuilder) => VQueryDSL;
+import type { VBIBuilderInterface, VBIDSL } from '../../types';
+export declare const buildVQuery: (vbiDSL: VBIDSL, builder: VBIBuilderInterface<any, any>) => VQueryDSL;

package/dist/pipeline/vqueryDSL/types.d.ts

@@ -1,7 +1,6 @@
 import type { VQueryDSL } from '@visactor/vquery';
-import type { VBIDSL } from '../../types';
-import type { VBIBuilder } from '../../builder';
+import type { VBIBuilderInterface, VBIDSL } from '../../types';
 export type buildPipe = (queryDSL: VQueryDSL, context: {
     vbiDSL: VBIDSL;
-    builder: VBIBuilder;
+    builder: VBIBuilderInterface<any, any>;
 }) => VQueryDSL;

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

@@ -1,9 +1,8 @@
-import type { VQueryDSL } from '@visactor/vquery';
+import type { DefaultVBIQueryDSL, DefaultVBISeedDSL } from '../../builder/adapters/vquery-vseed/types';
 import type { VBIDSL } from '../dsl';
-import type { VSeedDSL } from '@visactor/vseed';
 import type { MeasuresBuilder, DimensionsBuilder, ChartTypeBuilder, HavingFilterBuilder, WhereFilterBuilder, ThemeBuilder, LocaleBuilder, LimitBuilder, UndoManager } from '../../builder/features';
 import type { Map, Doc } from 'yjs';
-export interface VBIBuilderInterface {
+export interface VBIBuilderInterface<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
     doc: Doc;
     dsl: Map<any>;
     undoManager: UndoManager;
@@ -17,7 +16,8 @@ export interface VBIBuilderInterface {
     limit: LimitBuilder;
     applyUpdate: (update: Uint8Array, origin?: any) => void;
     encodeStateAsUpdate: (targetStateVector?: Uint8Array) => Uint8Array;
-    buildVSeed: () => Promise<VSeedDSL>;
-    buildVQuery: () => VQueryDSL;
+    buildVSeed: () => Promise<TSeedDSL>;
+    buildVQuery: () => TQueryDSL;
     build: () => VBIDSL;
+    isEmpty: () => boolean;
 }

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

@@ -0,0 +1,21 @@
+import type { DefaultVBIQueryDSL, DefaultVBISeedDSL } from '../../builder/adapters/vquery-vseed/types';
+import type { Map } from 'yjs';
+import type { VBIDSL } from '../dsl';
+import type { VBIBuilderInterface } from './VBIInterface';
+export interface VBIBuildVQueryContext<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
+    dsl: Map<any>;
+    vbiDSL: VBIDSL;
+    builder: VBIBuilderInterface<TQueryDSL, TSeedDSL>;
+}
+export interface VBIBuildVSeedContext<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> extends VBIBuildVQueryContext<TQueryDSL, TSeedDSL> {
+    queryDSL: TQueryDSL;
+}
+export type VBIQueryBuilder<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> = (context: VBIBuildVQueryContext<TQueryDSL, TSeedDSL>) => TQueryDSL;
+export type VBISeedBuilder<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> = (context: VBIBuildVSeedContext<TQueryDSL, TSeedDSL>) => Promise<TSeedDSL> | TSeedDSL;
+export interface VBIBuilderAdapters<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
+    buildVQuery: VBIQueryBuilder<TQueryDSL, TSeedDSL>;
+    buildVSeed: VBISeedBuilder<TQueryDSL, TSeedDSL>;
+}
+export interface VBIBuilderOptions<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
+    adapters?: Partial<VBIBuilderAdapters<TQueryDSL, TSeedDSL>>;
+}

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

@@ -1,2 +1,3 @@
 export type { VBIBuilderInterface } from './VBIInterface';
+export type { VBIBuildVQueryContext, VBIBuildVSeedContext, VBIQueryBuilder, VBISeedBuilder, VBIBuilderAdapters, VBIBuilderOptions, } from './adapter';
 export type { ObserveCallback } from './observe';

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/havingFilter/having.d.ts

@@ -1,11 +1,30 @@
 import { z } from 'zod';
+import { zAggregate } from '../measures/aggregate';
 declare const zHavingLogicalOperator: z.ZodEnum<{
     and: "and";
     or: "or";
 }>;
+export type VBIHavingAggregate = z.infer<typeof zAggregate>;
 export declare const zVBIHavingFilter: z.ZodObject<{
     id: z.ZodString;
     field: z.ZodString;
+    aggregate: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        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.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>], "func">>;
     op: z.ZodOptional<z.ZodString>;
     value: z.ZodOptional<z.ZodAny>;
 }, z.core.$strip>;

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

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

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

@@ -1,7 +1,19 @@
 import { z } from 'zod';
+export declare const VBI_MEASURE_SIMPLE_AGGREGATE_FUNCS: readonly ["count", "countDistinct", "sum", "avg", "min", "max", "variance", "variancePop", "stddev", "median"];
 export declare const zAggregate: 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">;

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

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 export declare const zVBIMeasure: z.ZodObject<{
+    id: z.ZodString;
     field: z.ZodString;
     alias: z.ZodString;
     encoding: z.ZodEnum<{
@@ -11,14 +12,26 @@ export declare const zVBIMeasure: z.ZodObject<{
         size: "size";
     }>;
     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">;
 }, 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.ZodEnum<{
@@ -30,10 +43,21 @@ export declare const zVBIMeasureTree: z.ZodArray<z.ZodUnion<readonly [z.ZodObjec
         size: "size";
     }>;
     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">;
 }, z.core.$strip>, z.ZodType<VBIMeasureGroup, unknown, z.core.$ZodTypeInternals<VBIMeasureGroup, unknown>>]>>;
 export type VBIMeasure = z.infer<typeof zVBIMeasure>;

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

@@ -3,10 +3,12 @@ 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.ZodEnum<{
@@ -18,10 +20,21 @@ export declare const zVBIDSL: z.ZodObject<{
             size: "size";
         }>;
         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">;
     }, z.core.$strip>, z.ZodType<import("..").VBIMeasureGroup, unknown, z.core.$ZodTypeInternals<import("..").VBIMeasureGroup, unknown>>]>>;
     havingFilter: z.ZodDefault<z.ZodOptional<z.ZodType<{

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

@@ -0,0 +1,15 @@
+import type { DefaultVBIQueryDSL, DefaultVBISeedDSL } from '../builder/adapters/vquery-vseed/types';
+import { connectorMap, getConnector, registerConnector } from '../builder/connector';
+import type { VBIBuilder } from '../builder/builder';
+import type { VBIDSLInput, VBIBuilderOptions } from '../types';
+import { generateEmptyDSL } from './generate-empty-dsl';
+export interface VBIInstance<TQueryDSL = DefaultVBIQueryDSL, TSeedDSL = DefaultVBISeedDSL> {
+    connectorMap: typeof connectorMap;
+    registerConnector: typeof registerConnector;
+    getConnector: typeof getConnector;
+    generateEmptyDSL: typeof generateEmptyDSL;
+    from: (vbi: VBIDSLInput, builderOptions?: VBIBuilderOptions<TQueryDSL, TSeedDSL>) => VBIBuilder<TQueryDSL, TSeedDSL>;
+    create: (vbi: VBIDSLInput, builderOptions?: VBIBuilderOptions<TQueryDSL, TSeedDSL>) => VBIBuilder<TQueryDSL, TSeedDSL>;
+}
+export declare function createVBI(): VBIInstance<DefaultVBIQueryDSL, DefaultVBISeedDSL>;
+export declare function createVBI<TQueryDSL, TSeedDSL>(defaultBuilderOptions: VBIBuilderOptions<TQueryDSL, TSeedDSL>): VBIInstance<TQueryDSL, TSeedDSL>;

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

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

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 @@
+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.16",
+  "version": "0.4.19",
   "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.16"
+    "@visactor/vseed": "0.4.19"
   },
   "optionalDependencies": {
-    "@visactor/vseed": "0.4.16",
-    "@visactor/vquery": "0.4.16"
+    "@visactor/vquery": "0.4.19",
+    "@visactor/vseed": "0.4.19"
   },
   "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.16"
+    "@visactor/vquery": "0.4.19"
   },
   "scripts": {
     "build": "rslib build",

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

@@ -1,28 +0,0 @@
-import * as Y from 'yjs';
-import { VSeedDSL } from '@visactor/vseed';
-import { VQueryDSL } from '@visactor/vquery';
-import { DimensionsBuilder, MeasuresBuilder, HavingFilterBuilder, WhereFilterBuilder, ChartTypeBuilder, ThemeBuilder, LocaleBuilder, LimitBuilder, UndoManager } from './features';
-import { VBIDSL, VBIBuilderInterface } from '../types';
-export declare class VBIBuilder implements VBIBuilderInterface {
-    doc: Y.Doc;
-    dsl: Y.Map<any>;
-    undoManager: UndoManager;
-    chartType: ChartTypeBuilder;
-    measures: MeasuresBuilder;
-    dimensions: DimensionsBuilder;
-    havingFilter: HavingFilterBuilder;
-    whereFilter: WhereFilterBuilder;
-    theme: ThemeBuilder;
-    locale: LocaleBuilder;
-    limit: LimitBuilder;
-    constructor(doc: Y.Doc);
-    applyUpdate(update: Uint8Array): void;
-    encodeStateAsUpdate(targetStateVector?: Uint8Array): Uint8Array<ArrayBufferLike>;
-    buildVSeed: () => Promise<VSeedDSL>;
-    buildVQuery: () => VQueryDSL;
-    build: () => VBIDSL;
-    getSchema: () => Promise<{
-        name: string;
-        type: string;
-    }[]>;
-}

package/dist/builder/vbi.d.ts

@@ -1,16 +0,0 @@
-import { VBIConnectorId } from '../types/connector/connector';
-import { VBIDSL, VBIDSLInput } 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: VBIDSLInput) => VBIBuilder;
-};