@visactor/vchart-types 2.1.0-alpha.4 → 2.1.0-alpha.6

package/types/chart/base/base-chart.d.ts

@@ -135,6 +135,7 @@ export declare class BaseChart<T extends IChartSpec> extends CompilableBase impl
     private _isComponentSpecKey;
     private _isOnlyComponentSpecsChanged;
     private _isOnlySeriesSpecsChanged;
+    private _isOnlyComponentOrSeriesSpecsChanged;
     private _canSkipChartDataStages;
     private _isComponentScaleDomainOnlyUpdate;
     private _reRunStackDataFlow;

package/types/component/axis/polar/band-axis.d.ts

@@ -18,6 +18,7 @@ export declare class PolarBandAxis<T extends IPolarBandAxisSpec = IPolarBandAxis
     };
     protected _scale: BandScale;
     protected _scales: BandScale[];
+    protected _updateData: () => void;
     protected computeDomain(data: {
         min: number;
         max: number;
@@ -37,6 +38,7 @@ export declare class PolarBandAxis<T extends IPolarBandAxisSpec = IPolarBandAxis
         getSpec: () => T;
     };
     protected initScales(): void;
+    reInit(spec?: T): void;
     protected registerTicksTransform(): string;
     transformScaleDomain(): void;
 }

package/types/component/indicator/util.d.ts

@@ -2,12 +2,13 @@ import type { IIndicatorItemSpec } from './interface';
 export interface IIndicatorDatum {
     type: 'title' | 'content';
     index: number;
-    datum: any;
+    datum: unknown;
     spec: IIndicatorItemSpec;
 }
 export interface IIndicatorMapper {
     title: IIndicatorItemSpec;
     content: IIndicatorItemSpec[];
-    datum: () => any;
+    datum: () => unknown;
 }
-export declare const indicatorMapper: (data: Array<any>, op: IIndicatorMapper) => any[];
+export type IndicatorMapperOption = IIndicatorMapper | (() => IIndicatorMapper);
+export declare const indicatorMapper: (data: Array<unknown>, op: IndicatorMapperOption) => IIndicatorDatum[];

package/types/data/transforms/box-plot.d.ts

@@ -1,6 +1,9 @@
+import type { DataView } from '@visactor/vdataset';
 export interface IBoxPlotOutlierOpt {
     dimensionField: string[];
     outliersField: string;
     seriesField?: string;
 }
-export declare const foldOutlierData: (data: Array<DataView>, op: IBoxPlotOutlierOpt) => any;
+type BoxPlotOutlierOption = IBoxPlotOutlierOpt | (() => IBoxPlotOutlierOpt);
+export declare const foldOutlierData: (data: Array<DataView>, op: BoxPlotOutlierOption) => Record<string, unknown>[];
+export {};

package/types/data/transforms/correlation-center.d.ts

@@ -1,4 +1,10 @@
-export declare const correlationCenter: (data: any, options: any) => {
-    [x: string]: any;
-    [x: number]: any;
-};
+type CorrelationCenterOptionValue<T> = T | (() => T);
+type CorrelationCenterData = Array<{
+    latestData: Array<Record<string, unknown>>;
+}>;
+export interface ICorrelationCenterOpt {
+    keyword: CorrelationCenterOptionValue<string>;
+    categoryField: CorrelationCenterOptionValue<string>;
+}
+export declare const correlationCenter: (data: CorrelationCenterData, options: ICorrelationCenterOpt) => Record<string, unknown> | [];
+export {};

package/types/data/transforms/correlation.d.ts

@@ -1,17 +1,20 @@
+type CorrelationOptionValue<T> = T | (() => T);
 export interface ICorrelationOpt {
-    field: string;
-    radiusField?: string;
-    radiusRange?: [number, number];
-    center?: [string | number, string | number];
-    startAngle?: number;
-    endAngle?: number;
-    innerRadius?: string | number;
-    outerRadius?: string | number;
+    view: () => {
+        x0: number;
+        x1: number;
+        y0: number;
+        y1: number;
+    };
+    field: CorrelationOptionValue<string>;
+    radiusField?: CorrelationOptionValue<string | undefined>;
+    radiusRange?: CorrelationOptionValue<[number, number] | undefined>;
+    center?: CorrelationOptionValue<[string | number, string | number] | undefined>;
+    startAngle?: CorrelationOptionValue<number | undefined>;
+    endAngle?: CorrelationOptionValue<number | undefined>;
+    innerRadius?: CorrelationOptionValue<string | number | undefined>;
+    outerRadius?: CorrelationOptionValue<string | number | undefined>;
 }
-export interface CircularRelationItem {
-    x: number;
-    y: number;
-    size: number;
-    datum: any;
-}
-export declare const correlation: (data: any, options: any) => any;
+export type CircularRelationItem = Record<string, unknown>;
+export declare const correlation: (data: unknown, options: ICorrelationOpt) => unknown;
+export {};

package/types/data/transforms/funnel.d.ts

@@ -1,6 +1,7 @@
 import type { DataView } from '@visactor/vdataset';
+type FunnelOptionValue<T> = T | (() => T);
 export interface IFunnelOpt {
-    valueField: string;
+    valueField: FunnelOptionValue<string>;
     asTransformRatio: string;
     asReachRatio: string;
     asHeightRatio: string;
@@ -10,12 +11,12 @@ export interface IFunnelOpt {
     asCurrentValue: string;
     asLastValue: string;
     asNextValue: string;
-    isCone?: boolean;
-    heightVisual?: boolean;
-    range?: {
-        min: number;
-        max: number;
-    };
+    isCone?: FunnelOptionValue<boolean | undefined>;
+    heightVisual?: FunnelOptionValue<boolean | undefined>;
+    range?: FunnelOptionValue<{
+        min?: number;
+        max?: number;
+    } | undefined>;
 }
 export declare const funnel: (originData: Array<DataView>, op: IFunnelOpt) => {
     dataSet: import("@visactor/vdataset").DataSet;
@@ -43,4 +44,5 @@ export declare const funnel: (originData: Array<DataView>, op: IFunnelOpt) => {
 export interface IFunnelTransformOpt {
     asIsTransformLevel: string;
 }
-export declare const funnelTransform: (originData: Array<DataView>, op: IFunnelTransformOpt) => any;
+export declare const funnelTransform: (originData: Array<DataView>, op: IFunnelTransformOpt) => Record<string, unknown>[];
+export {};

package/types/data/transforms/lookup.d.ts

@@ -3,10 +3,10 @@ import type { Datum } from '../../typings';
 export interface ILookUpOpt {
     from: () => object[];
     key: string;
-    fields: string;
+    fields: string | (() => string);
     values?: string[];
     as?: string[];
-    default?: any;
-    set?: (A: Datum, B: Datum) => void;
+    default?: unknown;
+    set?: (A: Datum, B?: Datum) => void;
 }
 export declare const lookup: (data: Array<DataView>, opt: ILookUpOpt) => DataView[];

package/types/data/transforms/map.d.ts

@@ -1,6 +1,12 @@
 import type { GeoSourceType } from '../../typings/geo';
 export interface IMapOpt {
-    nameMap: Record<string, string>;
+    nameMap: Record<string, unknown>;
     nameProperty: string;
 }
-export declare const map: (data: GeoSourceType, opt: IMapOpt) => any;
+type MapFeature = {
+    properties?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+type MapOption = IMapOpt | (() => IMapOpt);
+export declare const map: (data: GeoSourceType, opt: MapOption) => MapFeature[];
+export {};

package/types/data/transforms/sankey.d.ts

@@ -1,4 +1,4 @@
-import type { SankeyOptions, SankeyData } from '@visactor/vlayouts';
+import { type SankeyOptions, type SankeyData } from '@visactor/vlayouts';
 export interface ISankeyOpt extends SankeyOptions {
     targetField: string;
     sourceField: string;
@@ -10,10 +10,18 @@ export interface ISankeyOpt extends SankeyOptions {
         y1: number;
     };
 }
-export declare const collectHierarchyField: (set: Set<any>, data: any[], field: string) => void;
-export declare const sankeyFormat: (data: any[]) => SankeyData[];
-export declare const sankeyLayout: (data: SankeyData[], op: ISankeyOpt) => {
+type SankeyLayoutOption = ISankeyOpt | (() => ISankeyOpt);
+type SankeyFormatDatum = Record<string, unknown> & {
+    id?: 'links' | 'nodes';
+    values?: unknown;
+    latestData?: SankeyData[];
+    children?: SankeyFormatDatum[];
+};
+export declare const collectHierarchyField: <T>(set: Set<T>, data: SankeyFormatDatum[], field: string) => void;
+export declare const sankeyFormat: (data: SankeyFormatDatum[]) => SankeyData[];
+export declare const sankeyLayout: (data: SankeyData[], op: SankeyLayoutOption) => {
     nodes: import("@visactor/vlayouts").SankeyNodeElement[];
     links: import("@visactor/vlayouts").SankeyLinkElement[];
     columns: import("@visactor/vlayouts").SankeyNodeElement[][];
 }[];
+export {};

package/types/data/transforms/stack-split.d.ts

@@ -3,4 +3,5 @@ import type { DataView } from '@visactor/vdataset';
 export interface IStackOption {
     fields: string[];
 }
-export declare const stackSplit: (data: Array<DataView>, op: IStackOption) => ISeriesStackDataNode;
+export type StackOption = IStackOption | (() => IStackOption);
+export declare const stackSplit: (data: Array<DataView>, op: StackOption) => ISeriesStackDataNode;

package/types/data/transforms/treemap.d.ts

@@ -1,5 +1,5 @@
-import type { TreemapNodeElement, TreemapOptions } from '@visactor/vlayouts';
-export declare const treemapLayout: (data: Array<any>, op: TreemapOptions & {
+import { type TreemapNodeElement, type TreemapOptions } from '@visactor/vlayouts';
+interface ITreemapLayoutOptions extends TreemapOptions {
     getViewBox: () => {
         x0: number;
         x1: number;
@@ -7,4 +7,6 @@ export declare const treemapLayout: (data: Array<any>, op: TreemapOptions & {
         y1: number;
     };
     nameField: string;
-}) => TreemapNodeElement[];
+}
+export declare const treemapLayout: (data: Array<Record<string, unknown>>, op: ITreemapLayoutOptions | (() => ITreemapLayoutOptions)) => TreemapNodeElement[];
+export {};

package/types/data/transforms/venn.d.ts

@@ -1,4 +1,4 @@
-export declare const vennLayout: (data: Array<any>, op: {
+interface IVennLayoutOptions {
     setField: string;
     valueField: string;
     getViewBox: () => {
@@ -7,4 +7,6 @@ export declare const vennLayout: (data: Array<any>, op: {
         y0: number;
         y1: number;
     };
-}) => (import("@visactor/vlayouts").IVennCircleDatum<any> | import("@visactor/vlayouts").IVennOverlapDatum<any>)[];
+}
+export declare const vennLayout: (data: Array<Record<string, unknown>>, op: IVennLayoutOptions | (() => IVennLayoutOptions)) => (import("@visactor/vlayouts").IVennCircleDatum<any> | import("@visactor/vlayouts").IVennOverlapDatum<any>)[];
+export {};

package/types/data/transforms/waterfall.d.ts

@@ -17,7 +17,8 @@ export interface IWaterfallOpt {
     stackInverse: boolean;
     groupData: () => DataView;
 }
-export declare const waterfall: (lastData: Array<Datum>, op: IWaterfallOpt) => Datum[];
+export type WaterfallOption = IWaterfallOpt | (() => IWaterfallOpt);
+export declare const waterfall: (lastData: Array<Datum>, op: WaterfallOption) => Datum[];
 export interface IWaterfallFillEndOpt {
     indexField: string;
     valueField: string;
@@ -25,4 +26,5 @@ export interface IWaterfallFillEndOpt {
     total: IWaterfallSeriesSpec['total'];
     calculationMode: IWaterfallSeriesSpec['calculationMode'];
 }
-export declare const waterfallFillTotal: (data: Array<Datum>, op: IWaterfallFillEndOpt) => Datum[];
+export type WaterfallFillEndOption = IWaterfallFillEndOpt | (() => IWaterfallFillEndOpt);
+export declare const waterfallFillTotal: (data: Array<Datum>, op: WaterfallFillEndOption) => Datum[];

package/types/series/dot/dot.d.ts

@@ -31,6 +31,17 @@ export declare class DotSeries<T extends IDotSeriesSpec = IDotSeriesSpec> extend
     setHighLightSeriesGroup(field: string): void;
     protected _gridBackground?: IFillMarkSpec;
     setGridBackground(gridBackground: IFillMarkSpec): void;
+    protected _getSpecUpdatePolicy(): {
+        compileOnlyKeys: {
+            highLightSeriesGroup: true;
+            titleField: true;
+            subTitleField: true;
+        };
+        compileOnlySubKeys: {
+            grid: Record<"background", true>;
+        };
+        dataRelatedKeys?: Record<string, true>;
+    };
     initData(): void;
     getStatisticFields(): {
         key: string;

package/types/series/polar/progress-like/progress-like.d.ts

@@ -4,11 +4,13 @@ import { PolarSeries } from '../polar';
 import type { IContinuousTickData, IProgressLikeSeriesSpec } from './interface';
 import type { IPolarAxis } from '../../../component/axis';
 import type { SeriesMarkMap } from '../../interface';
+import type { ISeriesSpecUpdatePolicy } from '../../base/base-series';
 export declare abstract class ProgressLikeSeries<T extends IProgressLikeSeriesSpec> extends PolarSeries<T> {
     static readonly mark: SeriesMarkMap;
     protected _startAngle: number;
     protected _endAngle: number;
     protected _arcGroupMark: IGroupMark | null;
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     setAttrFromSpec(): void;
     getStackGroupFields(): string[];
     getStackValueField(): string;

package/types/series/polar/rose-like/rose-like.d.ts

@@ -1,6 +1,8 @@
 import { PolarSeries } from '../polar';
 import type { IRoseLikeSeriesSpec } from './interface';
+import type { ISeriesSpecUpdatePolicy } from '../../base/base-series';
 export declare abstract class RoseLikeSeries<T extends IRoseLikeSeriesSpec> extends PolarSeries<T> {
+    protected _getSpecUpdatePolicy(): ISeriesSpecUpdatePolicy;
     getStackGroupFields(): string[];
     getStackValueField(): string;
     getGroupFields(): string[];