@kanaries/graphic-walker 0.3.14 → 0.3.15

package/dist/interfaces.d.ts

@@ -30,17 +30,21 @@ export interface IMutField {
     fid: string;
     key?: string;
     name?: string;
+    basename?: string;
     disable?: boolean;
     semanticType: ISemanticType;
     analyticType: IAnalyticType;
+    path?: string[];
 }
 export interface IUncertainMutField {
     fid: string;
     key?: string;
     name?: string;
+    basename?: string;
     disable?: boolean;
     semanticType: ISemanticType | '?';
     analyticType: IAnalyticType | '?';
+    path: string[];
 }
 export type IExpParamter = {
     type: 'field';
@@ -78,6 +82,8 @@ export interface IField {
     cmp?: (a: any, b: any) => number;
     computed?: boolean;
     expression?: IExpression;
+    basename?: string;
+    path?: [];
 }
 export interface IViewField extends IField {
     dragId: string;
@@ -184,6 +190,11 @@ export interface IVisSpec {
     readonly encodings: DeepReadonly<DraggableFieldState>;
     readonly config: DeepReadonly<IVisualConfig>;
 }
+export type SetToArray<T> = (T extends object ? (T extends Set<infer U> ? Array<U> : {
+    [K in keyof T]: SetToArray<T[K]>;
+}) : T);
+export type IVisSpecForExport = SetToArray<IVisSpec>;
+export type IFilterFieldForExport = SetToArray<IFilterField>;
 export declare enum ISegmentKey {
     vis = "vis",
     data = "data"

package/dist/lib/inferMeta.d.ts

@@ -6,7 +6,7 @@ import { IMutField, IRow, ISemanticType, IUncertainMutField } from '../interface
  */
 export declare function isDateTimeArray(data: string[]): boolean;
 export declare function isNumericArray(data: any[]): boolean;
-export declare function inferSemanticType(data: IRow[], fid: string): ISemanticType;
+export declare function inferSemanticType(data: IRow[], path: string[]): ISemanticType;
 export declare function inferMeta(props: {
     dataSource: IRow[];
     fields: IUncertainMutField[];

package/dist/lib/viewQuery.d.ts

@@ -1,4 +1,4 @@
-import { IMutField, IRow } from "../interfaces";
+import { IField, IRow } from "../interfaces";
 import { IAggQuery, IBinQuery, IFoldQuery, IRawQuery } from "./interfaces";
 export type IViewQuery = IAggQuery | IFoldQuery | IBinQuery | IRawQuery;
-export declare function queryView(rawData: IRow[], metas: IMutField[], query: IViewQuery): IRow[];
+export declare function queryView(rawData: IRow[], metas: IField[], query: IViewQuery): IRow[];

package/dist/services.d.ts

@@ -1,9 +1,9 @@
-import { IRow, IMutField, IFilterField, Specification } from './interfaces';
+import { IRow, IField, IFilterField, Specification } from './interfaces';
 import { IViewQuery } from './lib/viewQuery';
 export interface IVisSpace {
     dataView: IRow[];
     schema: Specification;
 }
 export declare const applyFilter: (data: IRow[], filters: readonly IFilterField[]) => Promise<IRow[]>;
-export declare const transformDataService: (data: IRow[], columns: IMutField[]) => Promise<IRow[]>;
-export declare const applyViewQuery: (data: IRow[], metas: IMutField[], query: IViewQuery) => Promise<IRow[]>;
+export declare const transformDataService: (data: IRow[], columns: IField[]) => Promise<IRow[]>;
+export declare const applyViewQuery: (data: IRow[], metas: IField[], query: IViewQuery) => Promise<IRow[]>;

package/dist/store/visualSpecStore.d.ts

@@ -1,4 +1,4 @@
-import { DataSet, DraggableFieldState, IFilterRule, IViewField, IVisSpec, IVisualConfig, Specification } from "../interfaces";
+import { DataSet, DraggableFieldState, IFilterRule, IViewField, IVisualConfig, Specification } from "../interfaces";
 import { VisSpecWithHistory } from "../models/visSpecHistory";
 import { IStoInfo } from "../utils/save";
 import { CommonStore } from "./commonStore";
@@ -113,8 +113,434 @@ export declare class VizSpecStore {
     renderSpec(spec: Specification): void;
     destroy(): void;
     exportAsRaw(): string;
-    exportViewSpec(): IVisSpec[];
+    exportViewSpec(): {
+        readonly visId: string;
+        readonly name?: string | undefined;
+        readonly encodings: {
+            readonly dimensions: readonly {
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+            readonly measures: readonly {
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+            readonly rows: readonly {
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+            readonly columns: readonly {
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+            readonly color: readonly {
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+            readonly opacity: readonly {
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+            readonly size: readonly {
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+            readonly shape: readonly {
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+            readonly theta: readonly {
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+            readonly radius: readonly {
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+            readonly details: readonly {
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+            readonly filters: readonly {
+                readonly rule: {
+                    type: "range";
+                    value: readonly [number, number];
+                } | {
+                    type: "temporal range";
+                    value: readonly [number, number];
+                } | {
+                    type: "one of";
+                    value: (string | number)[];
+                } | null;
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+            readonly text: readonly {
+                readonly dragId: string;
+                readonly sort?: "none" | "ascending" | "descending" | undefined;
+                readonly fid: string;
+                readonly name: string;
+                readonly aggName?: string | undefined;
+                readonly semanticType: import("../interfaces").ISemanticType;
+                readonly analyticType: import("../interfaces").IAnalyticType;
+                readonly cmp?: {} | undefined;
+                readonly computed?: boolean | undefined;
+                readonly expression?: {
+                    op: "bin" | "log2" | "log10" | "one" | "binCount";
+                    params: ({
+                        type: "field";
+                        value: string;
+                    } | {
+                        type: "value";
+                        value: any;
+                    } | {
+                        type: "expression";
+                        value: any;
+                    } | {
+                        type: "constant";
+                        value: any;
+                    })[];
+                    as: string;
+                } | undefined;
+                readonly basename?: string | undefined;
+                readonly path?: [] | undefined;
+            }[];
+        };
+        readonly config: {
+            readonly defaultAggregated: boolean;
+            readonly geoms: readonly string[];
+            readonly stack: import("../interfaces").IStackMode;
+            readonly showActions: boolean;
+            readonly interactiveScale: boolean;
+            readonly sorted: "none" | "ascending" | "descending";
+            readonly zeroScale: boolean;
+            readonly format: {
+                readonly numberFormat?: string | undefined;
+                readonly timeFormat?: string | undefined;
+                readonly normalizedNumberFormat?: string | undefined;
+            };
+            readonly size: {
+                readonly mode: "auto" | "fixed";
+                readonly width: number;
+                readonly height: number;
+            };
+        };
+    }[];
     importStoInfo(stoInfo: IStoInfo): void;
     importRaw(raw: string): void;
+    private visSpecEncoder;
+    private visSpecDecoder;
 }
 export {};

package/dist/utils/dataPrep.d.ts

@@ -3,5 +3,5 @@ export declare function guardDataKeys(data: IRow[], metas: IMutField[]): {
     safeData: IRow[];
     safeMetas: IMutField[];
 };
-export declare function flatNestKeys(object: any): string[];
-export declare function getValueByKeyPath(object: any, keyPath: string): any;
+export declare function flatKeys(obj: Object, prefixKeys?: string[]): string[][];
+export declare function getValueByKeyPath(object: any, keyPath: string[]): any;

package/dist/utils/is-plain-object.d.ts

@@ -0,0 +1,2 @@
+declare function isPlainObject(o: any): boolean;
+export { isPlainObject };

package/dist/utils/save.d.ts

@@ -1,11 +1,11 @@
-import { IDataSet, IDataSource, IVisSpec } from "../interfaces";
+import { IDataSet, IDataSource, IVisSpec, IVisSpecForExport } from "../interfaces";
 import { VisSpecWithHistory } from "../models/visSpecHistory";
 export declare function dumpsGWPureSpec(list: VisSpecWithHistory[]): IVisSpec[];
 export declare function parseGWPureSpec(list: IVisSpec[]): VisSpecWithHistory[];
 export interface IStoInfo {
     datasets: IDataSet[];
     specList: {
-        [K in keyof IVisSpec]: K extends "config" ? Partial<IVisSpec[K]> : IVisSpec[K];
+        [K in keyof IVisSpecForExport]: K extends "config" ? Partial<IVisSpecForExport[K]> : IVisSpecForExport[K];
     }[];
     dataSources: IDataSource[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kanaries/graphic-walker",
-  "version": "0.3.14",
+  "version": "0.3.15",
   "scripts": {
     "dev:front_end": "vite --host",
     "dev": "npm run dev:front_end",