@visactor/vbi 0.4.19 → 0.4.20

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,15 +1,14 @@
 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';
+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;
-    generateEmptyDSL: typeof generateEmptyDSL;
-    from: (vbi: VBIDSLInput, builderOptions?: VBIBuilderOptions<TQueryDSL, TSeedDSL>) => VBIBuilder<TQueryDSL, TSeedDSL>;
-    create: (vbi: VBIDSLInput, builderOptions?: VBIBuilderOptions<TQueryDSL, TSeedDSL>) => VBIBuilder<TQueryDSL, TSeedDSL>;
+    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: VBIBuilderOptions<TQueryDSL, TSeedDSL>): VBIInstance<TQueryDSL, TSeedDSL>;
+export declare function createVBI<TQueryDSL, TSeedDSL>(defaultBuilderOptions: VBIChartBuilderOptions<TQueryDSL, TSeedDSL>): VBIInstance<TQueryDSL, TSeedDSL>;

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

@@ -1,4 +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>;
+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/package.json

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