@visactor/vchart 1.2.0-beta.5 → 1.2.0-beta.7

package/build/es5/constant/polar.d.ts

@@ -0,0 +1,22 @@
+export declare const ARC_RATIO: string;
+export declare const ARC_START_ANGLE: string;
+export declare const ARC_END_ANGLE: string;
+export declare const ARC_K: string;
+export declare const ARC_LABEL_HOVER_AX: string;
+export declare const ARC_LABEL_HOVER_AY: string;
+export declare const ARC_LABEL_POINT_AX: string;
+export declare const ARC_LABEL_POINT_AY: string;
+export declare const ARC_LABEL_POINT_BX: string;
+export declare const ARC_LABEL_POINT_BY: string;
+export declare const ARC_LABEL_POINT_CX: string;
+export declare const ARC_LABEL_POINT_CY: string;
+export declare const ARC_LABEL_SELECTED_AX: string;
+export declare const ARC_LABEL_SELECTED_AY: string;
+export declare const ARC_MIDDLE_ANGLE: string;
+export declare const ARC_QUADRANT: string;
+export declare const ARC_RADIAN: string;
+export declare const POLAR_START_RADIAN: number;
+export declare const POLAR_END_RADIAN: number;
+export declare const POLAR_START_ANGLE = -90;
+export declare const POLAR_END_ANGLE = 270;
+export declare const POLAR_DEFAULT_RADIUS = 0.6;

package/build/es5/constant/scatter.d.ts

@@ -0,0 +1,7 @@
+import { ScaleEnum } from '@visactor/vscale';
+export declare const SCATTER_DEFAULT_SIZE = 10;
+export declare const SCATTER_DEFAULT_RANGE_SIZE: number[];
+export declare const SCATTER_DEFAULT_SIZE_SCALE_TYPE = ScaleEnum.Linear;
+export declare const SCATTER_DEFAULT_SHAPE = "circle";
+export declare const SCATTER_DEFAULT_SHAPE_SCALE_TYPE = ScaleEnum.Ordinal;
+export declare const SCATTER_DEFAULT_RANGE_SHAPE: string[];

package/build/es5/constant/scroll-bar.d.ts

@@ -0,0 +1 @@
+export declare const SCROLL_BAR_DEFAULT_SIZE = 12;

package/build/es5/constant/sunburst.d.ts

@@ -0,0 +1 @@
+export declare const SUNBURST_AUTO_VISIBLE_DEFAULT_THRESHOLD = 10;

package/build/es5/constant/waterfall.d.ts

@@ -0,0 +1 @@
+export declare const WaterfallDefaultSeriesField: string;

package/build/es5/constant/word-cloud.d.ts

@@ -0,0 +1,7 @@
+export declare const WORD_CLOUD_ANGLE: string;
+export declare const WORD_CLOUD_FILLING_ANGLE: string;
+export declare const WORD_CLOUD_WEIGHT: string;
+export declare const WORDCLOUD_COLOR: string;
+export declare const WORDCLOUD_DATA_TOTAL: string;
+export declare const WORD_CLOUD_TEXT: string;
+export declare const WORDCLOUD_SHAPE_DATA_TOTAL: string;

package/build/es5/core/factory.d.ts

@@ -0,0 +1,39 @@
+import type { IChartConstructor, IChartOption, IChart } from '../chart/interface';
+import type { ISeriesConstructor, ISeriesOption } from '../series/interface';
+import type { IComponentConstructor } from '../component/interface';
+import type { IMarkOption, MarkConstructor } from '../mark/interface';
+import type { IRegion, IRegionConstructor } from '../region/interface';
+import type { IModelOption } from '../model/interface';
+import type { Transform, Parser } from '@visactor/vdataset';
+import type { ILayoutConstructor } from '../layout/interface';
+export declare class Factory {
+    private static _charts;
+    private static _series;
+    private static _components;
+    private static _marks;
+    private static _regions;
+    static transforms: {
+        [key: string]: Transform;
+    };
+    static dataParser: {
+        [key: string]: Parser;
+    };
+    static _layout: {
+        [key: string]: ILayoutConstructor;
+    };
+    static registerChart(key: string, chart: IChartConstructor): void;
+    static registerSeries(key: string, series: ISeriesConstructor): void;
+    static registerComponent(key: string, cmp: IComponentConstructor): void;
+    static registerMark(key: string, mark: MarkConstructor): void;
+    static registerRegion(key: string, region: IRegionConstructor): void;
+    static registerTransform(key: string, transform: Transform): void;
+    static registerLayout(key: string, layout: ILayoutConstructor): void;
+    static createChart(chartType: string, spec: any, options: IChartOption): IChart | null;
+    static createRegion(regionType: string, spec: any, options: IModelOption): IRegion | null;
+    static createSeries(seriesType: string, spec: any, options: ISeriesOption): import("../series/interface").ISeries;
+    static createMark(markType: string, name: string, options: IMarkOption): import("../mark/interface").IMark;
+    static getComponents(): IComponentConstructor[];
+    static getComponentInKey(name: string): IComponentConstructor;
+    static getLayout(name: string): ILayoutConstructor;
+    static getSeries(type: string): ISeriesConstructor;
+}

package/build/es5/core/index.d.ts

@@ -0,0 +1,9 @@
+import { VChart } from './vchart';
+import { Factory } from './factory';
+export { VChart, Factory };
+export declare const version: string;
+export type { IVChart } from './interface';
+export * from '../event/interface';
+export * from '../typings/spec/common';
+export type { IStateSpec, StateValueType } from '../compile/mark';
+export * from '../theme/interface';

package/build/es5/core/instance-manager.d.ts

@@ -0,0 +1,10 @@
+import type { MaybeArray } from '../typings';
+import type { IVChart } from './interface';
+export declare class InstanceManager {
+    static readonly instances: Map<number, IVChart>;
+    static registerInstance(instance: IVChart): void;
+    static unregisterInstance(instance: IVChart): void;
+    static getInstance(id: number): IVChart | undefined;
+    static instanceExist(id: number): boolean;
+    static forEach(callbackfn: (instance: IVChart, id: number, map: Map<number, IVChart>) => void, excludeId?: MaybeArray<number>, thisArg?: any): void;
+}

package/build/es5/core/interface.d.ts

@@ -0,0 +1,74 @@
+import type { DataSet, DataView } from '@visactor/vdataset';
+import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { Datum, IMarkStateSpec, IPoint, IRegionQuerier, IShowTooltipOption, ISpec, ITooltipHandler, Maybe, MaybeArray, StringOrNumber } from '../typings';
+import type { IMorphConfig } from '../animation/spec';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { EventCallback, EventParams, EventQuery, EventType } from '../event/interface';
+import type { IMark } from '../mark/interface';
+import type { ISeries } from '../series/interface/series';
+import type { ITheme } from '../theme';
+import type { IComponent } from '../component/interface';
+import type { LayoutCallBack } from '../layout/interface';
+import type { Compiler } from '../compile/compiler';
+import type { IChart } from '../chart/interface';
+import type { Stage } from '@visactor/vrender';
+export type DataLinkSeries = {
+    seriesId?: StringOrNumber;
+    seriesIndex?: number;
+};
+export type DataLinkAxis = {
+    axisId?: StringOrNumber;
+    axisIndex?: number;
+};
+export interface IVChart {
+    readonly id: number;
+    renderSync: (morphConfig?: IMorphConfig) => IVChart;
+    renderAsync: (morphConfig?: IMorphConfig) => Promise<IVChart>;
+    updateData: (id: StringOrNumber, data: DataView | Datum[] | string, options?: IParserOptions) => Promise<IVChart>;
+    updateDataInBatches: (list: {
+        id: string;
+        data: DataView | Datum[];
+        options?: IParserOptions;
+    }[]) => Promise<IVChart>;
+    updateDataSync: (id: StringOrNumber, data: DataView | Datum[], options?: IParserOptions) => IVChart;
+    updateSpec: (spec: ISpec, forceMerge?: boolean, morphConfig?: IMorphConfig) => Promise<IVChart>;
+    updateViewBox: (viewBox: IBoundsLike, reRender?: boolean) => IVChart;
+    resize: (width: number, height: number) => Promise<IVChart>;
+    release: () => void;
+    on: ((eType: EventType, handler: EventCallback<EventParams>) => void) & ((eType: EventType, query: EventQuery, handler: EventCallback<EventParams>) => void);
+    off: (eType: EventType, handler?: EventCallback<EventParams>) => void;
+    updateState: (state: Record<string, Omit<IMarkStateSpec<unknown>, 'style'>>, filter?: (series: ISeries, mark: IMark, stateKey: string) => boolean) => void;
+    setSelected: (datum: MaybeArray<any> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier) => void;
+    setHovered: (datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier) => void;
+    getCurrentTheme: () => ITheme;
+    getCurrentThemeName: () => string;
+    setCurrentTheme: (name: string) => Promise<IVChart>;
+    setTooltipHandler: (tooltipHandler: ITooltipHandler) => void;
+    getTooltipHandlerByUser: () => ITooltipHandler | undefined;
+    getTooltipHandler: () => ITooltipHandler | undefined;
+    showTooltip: (datum: Datum, options: IShowTooltipOption) => boolean;
+    hideTooltip: () => boolean;
+    getLegendDataById: (id: string) => Datum[];
+    getLegendDataByIndex: (index?: number) => Datum[];
+    getLegendSelectedDataById: (id: string) => StringOrNumber[];
+    getLegendSelectedDataByIndex: (index?: number) => StringOrNumber[];
+    setLegendSelectedDataById: (id: string, selectedData: StringOrNumber[]) => void;
+    setLegendSelectedDataByIndex: (index: number, selectedData: StringOrNumber[]) => void;
+    getDataURL: () => Promise<any>;
+    exportImg: (name?: string) => Promise<void>;
+    getImageBuffer: () => void;
+    setLayout: (layout: LayoutCallBack) => void;
+    reLayout: () => void;
+    getCompiler: () => Compiler;
+    getChart: () => Maybe<IChart>;
+    getStage: () => Stage;
+    getCanvas: () => HTMLCanvasElement | undefined;
+    getContainer: () => Maybe<HTMLElement>;
+    getComponents: () => IComponent[];
+    getDataSet: () => Maybe<DataSet>;
+    convertDatumToPosition: (datum: Datum, dataLinkInfo?: DataLinkSeries, isRelativeToCanvas?: boolean) => IPoint | null;
+    convertValueToPosition: ((value: StringOrNumber, dataLinkInfo: DataLinkAxis, isRelativeToCanvas?: boolean) => number | null) & ((value: [StringOrNumber, StringOrNumber], dataLinkInfo: DataLinkSeries, isRelativeToCanvas?: boolean) => IPoint | null);
+}
+export interface IGlobalConfig {
+    uniqueTooltip?: boolean;
+}

package/build/es5/core/vchart.d.ts

@@ -0,0 +1,125 @@
+import type { ISeries } from '../series/interface/series';
+import type { ILayoutConstructor, LayoutCallBack } from '../layout/interface';
+import type { IMarkStateSpec, IInitOption } from '../typings/spec/common';
+import type { ISeriesConstructor } from '../series/interface';
+import type { DimensionIndexOption, IChart, IChartConstructor } from '../chart/interface';
+import type { IComponentConstructor } from '../component/interface';
+import type { EventCallback, EventParams, EventQuery, EventType } from '../event/interface';
+import type { IParserOptions } from '@visactor/vdataset/es/parser';
+import type { Transform } from '@visactor/vdataset';
+import { DataSet, DataView } from '@visactor/vdataset';
+import type { Stage } from '@visactor/vrender';
+import type { GeoSourceType } from '../typings/geo';
+import type { GeoSourceOption } from '../series/map/geo-source';
+import type { IMark, MarkConstructor } from '../mark/interface';
+import type { ITooltipHandler } from '../typings/tooltip';
+import type { Datum, IPoint, IRegionQuerier, IShowTooltipOption, ISpec, Maybe, MaybeArray, StringOrNumber } from '../typings';
+import type { IBoundsLike, ILogger } from '@visactor/vutils';
+import { ThemeManager } from '../theme/theme-manager';
+import type { ITheme } from '../theme';
+import type { IUpdateSpecResult } from '../model/interface';
+import { Compiler } from '../compile/compiler';
+import type { IMorphConfig } from '../animation/spec';
+import type { DataLinkAxis, DataLinkSeries, IGlobalConfig, IVChart } from './interface';
+import { InstanceManager } from './instance-manager';
+export declare class VChart implements IVChart {
+    readonly id: number;
+    static useChart(charts: IChartConstructor[]): void;
+    static useSeries(series: ISeriesConstructor[]): void;
+    static useComponent(components: IComponentConstructor[]): void;
+    static useMark(marks: MarkConstructor[]): void;
+    static useLayout(layouts: ILayoutConstructor[]): void;
+    static registerDataSetTransform(name: string, transform: Transform): void;
+    static registerMap(key: string, source: GeoSourceType, option?: GeoSourceOption): void;
+    static unregisterMap(key: string): void;
+    static getMap(key: string): GeoSourceType;
+    static hideTooltip(excludeId?: MaybeArray<number>): void;
+    static getLogger(): ILogger;
+    static readonly InstanceManager: typeof InstanceManager;
+    static readonly ThemeManager: typeof ThemeManager;
+    static globalConfig: IGlobalConfig;
+    protected _spec: any;
+    private _viewBox;
+    private _chart;
+    private _compiler;
+    private _event;
+    private _eventDispatcher;
+    private _dataSet;
+    getDataSet(): DataSet;
+    private _container?;
+    private _canvas?;
+    private _stage?;
+    private _autoSize;
+    private _option;
+    private _curSize;
+    private _observer;
+    private _currentThemeName;
+    private _currentTheme;
+    private _onError?;
+    private _context;
+    constructor(spec: ISpec, options: IInitOption);
+    private _setSpec;
+    private _initData;
+    private _initChart;
+    private _releaseData;
+    private _bindVGrammarViewEvent;
+    private _bindResizeEvent;
+    private _unBindResizeEvent;
+    private _onResize;
+    private _initDataSet;
+    updateCustomConfigAndRerender(modifyConfig: () => IUpdateSpecResult | undefined, morphConfig?: IMorphConfig): Promise<IVChart>;
+    updateCustomConfigAndRerenderSync(modifyConfig: () => IUpdateSpecResult | undefined, morphConfig?: IMorphConfig): IVChart;
+    protected _reCompile(updateResult: IUpdateSpecResult): void;
+    renderSync(morphConfig?: IMorphConfig): IVChart;
+    renderAsync(morphConfig?: IMorphConfig): Promise<IVChart>;
+    release(): void;
+    updateData(id: StringOrNumber, data: DataView | Datum[] | string, options?: IParserOptions): Promise<IVChart>;
+    updateDataInBatches(list: {
+        id: string;
+        data: DataView | Datum[];
+        options?: IParserOptions;
+    }[]): Promise<IVChart>;
+    updateDataSync(id: StringOrNumber, data: DataView | Datum[], options?: IParserOptions): IVChart;
+    updateSpec(spec: ISpec, forceMerge?: boolean, morphConfig?: IMorphConfig): Promise<IVChart>;
+    updateSpecSync(spec: ISpec, forceMerge?: boolean, morphConfig?: IMorphConfig): IVChart;
+    resize(width: number, height: number): Promise<IVChart>;
+    updateViewBox(viewBox: IBoundsLike, reRender?: boolean): IVChart;
+    on(eType: EventType, handler: EventCallback<EventParams>): void;
+    on(eType: EventType, query: EventQuery, handler: EventCallback<EventParams>): void;
+    off(eType: string, handler?: EventCallback<EventParams>): void;
+    updateState(state: Record<string, Omit<IMarkStateSpec<unknown>, 'style'>>, filter?: (series: ISeries, mark: IMark, stateKey: string) => boolean): void;
+    setSelected(datum: MaybeArray<any> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
+    setHovered(datum: MaybeArray<Datum> | null, filter?: (series: ISeries, mark: IMark) => boolean, region?: IRegionQuerier): void;
+    private _updateCurrentTheme;
+    getCurrentTheme(): ITheme;
+    getCurrentThemeName(): string;
+    setCurrentTheme(name: string): Promise<IVChart>;
+    setCurrentThemeSync(name: string): IVChart;
+    private _getTooltipComponent;
+    setTooltipHandler(tooltipHandler: ITooltipHandler): void;
+    getTooltipHandlerByUser(): ITooltipHandler | undefined;
+    getTooltipHandler(): ITooltipHandler | undefined;
+    showTooltip(datum: Datum, options: IShowTooltipOption): boolean;
+    hideTooltip(): boolean;
+    getLegendDataById(id: string): Datum[];
+    getLegendDataByIndex(index?: number): Datum[];
+    getLegendSelectedDataById(id: string): StringOrNumber[];
+    getLegendSelectedDataByIndex(index?: number): StringOrNumber[];
+    setLegendSelectedDataById(id: string, selectedData: StringOrNumber[]): void;
+    setLegendSelectedDataByIndex(index: number, selectedData: StringOrNumber[]): void;
+    getDataURL(): Promise<string>;
+    exportImg(name?: string): Promise<void>;
+    getImageBuffer(): any;
+    setLayout(layout: LayoutCallBack): void;
+    reLayout(): void;
+    getCompiler(): Compiler;
+    getChart(): IChart;
+    getStage(): Stage;
+    getCanvas(): HTMLCanvasElement | undefined;
+    getContainer(): Maybe<HTMLElement>;
+    getComponents(): import("../component/interface").IComponent[];
+    setDimensionIndex(value: StringOrNumber, opt?: DimensionIndexOption): void;
+    convertDatumToPosition(datum: Datum, dataLinkInfo?: DataLinkSeries, isRelativeToCanvas?: boolean): IPoint | null;
+    convertValueToPosition(value: StringOrNumber, dataLinkInfo: DataLinkAxis, isRelativeToCanvas?: boolean): number | null;
+    convertValueToPosition(value: [StringOrNumber, StringOrNumber], dataLinkInfo: DataLinkSeries, isRelativeToCanvas?: boolean): IPoint | null;
+}

package/build/es5/data/initialize.d.ts

@@ -0,0 +1,10 @@
+import type { utilFunctionCtx } from './../typings/params';
+import { DataSet, DataView } from '@visactor/vdataset';
+import type { IDataViewOptions } from '@visactor/vdataset';
+import type { IDataValues } from '../typings/spec/common';
+export declare function initializeData(): void;
+export declare function initCSVData(): void;
+export declare function initData(): void;
+export declare function initFoldData(): void;
+export declare function dataViewFromDataView(rawData: DataView, dataSet?: DataSet, op?: IDataViewOptions): DataView;
+export declare function dataToDataView(data: DataView | IDataValues, dataSet: DataSet, sourceDataViews?: DataView[], ctx?: utilFunctionCtx): DataView;

package/build/es5/data/parser/array.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from '@visactor/vdataset';
+export declare const arrayParser: Parser;

package/build/es5/data/parser/scale.d.ts

@@ -0,0 +1,2 @@
+import type { Parser } from '@visactor/vdataset';
+export declare const scaleParser: Parser;

package/build/es5/data/register.d.ts

@@ -0,0 +1,3 @@
+import type { DataSet, Parser, Transform } from '@visactor/vdataset';
+export declare function registerDataSetInstanceTransform(dataSet: DataSet, name: string, transform: Transform): void;
+export declare function registerDataSetInstanceParser(dataSet: DataSet, name: string, parse: Parser): void;

package/build/es5/data/transforms/add-property.d.ts

@@ -0,0 +1,8 @@
+export type AddVChartPropertyContext = {
+    keyMap: Map<string, number>;
+};
+export interface IAddVChartPropertyOpt {
+    beforeCall: () => AddVChartPropertyContext;
+    call: (d: any, i: number, context: AddVChartPropertyContext) => void;
+}
+export declare const addVChartProperty: (data: Array<any>, op: IAddVChartPropertyOpt) => any[];

package/build/es5/data/transforms/aggregation.d.ts

@@ -0,0 +1,28 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IAggrType } from '../../component/marker/interface';
+import type { ICartesianSeries } from '../../series/interface';
+export type IOption = {
+    field: string;
+};
+export type IOptionAggrField = {
+    field: string;
+    aggrType: IAggrType;
+};
+export type IOptionPos = IOptionAggrField | string | number;
+export type IOptionAggr = {
+    x?: IOptionPos;
+    y?: IOptionPos;
+    getRefRelativeSeries?: () => ICartesianSeries;
+};
+export type IOptionAggrs = IOptionAggr[];
+export declare const markerMin: (_data: Array<DataView>, opt: IOption) => number;
+export declare const markerMax: (_data: Array<DataView>, opt: IOption) => number;
+export declare function markerSum(_data: Array<DataView>, opt: IOption): number;
+export declare function markerAverage(_data: Array<DataView>, opt: IOption): number;
+export declare function markerVariance(_data: Array<DataView>, opt: IOption): number;
+export declare function markerStandardDeviation(_data: Array<DataView>, opt: IOption): number;
+export declare function markerMedian(_data: Array<DataView>, opt: IOption): number;
+export declare function markerAggregation(_data: Array<DataView>, options: IOptionAggrs): {
+    x: string | number | null;
+    y: string | number | null;
+}[];

package/build/es5/data/transforms/box-plot.d.ts

@@ -0,0 +1,5 @@
+export interface IBoxPlotOutlierOpt {
+    dimensionField: string[];
+    outliersField: string;
+}
+export declare const foldOutlierData: (data: Array<DataView>, op: IBoxPlotOutlierOpt) => any;

package/build/es5/data/transforms/circle-packing.d.ts

@@ -0,0 +1,7 @@
+import type { Datum } from '../../typings';
+import type { CirclePackingOptions } from '@visactor/vgrammar-hierarchy';
+export interface ICirclePackingOpt extends CirclePackingOptions {
+    width: number;
+    height: number;
+}
+export declare const circlePackingLayout: (data: Array<Datum>, op: () => ICirclePackingOpt) => Datum[];

package/build/es5/data/transforms/copy-data-view.d.ts

@@ -0,0 +1,5 @@
+import { DataView } from '@visactor/vdataset';
+export declare const copyDataView: (data: Array<DataView>, options?: ICopyDataViewOption) => any;
+export interface ICopyDataViewOption {
+    deep?: boolean;
+}

package/build/es5/data/transforms/data-key.d.ts

@@ -0,0 +1,10 @@
+import type { BaseSeries } from '../../series/base/base-series';
+import type { TreeMapSeries } from '../../series/treemap/treemap';
+import type { AddVChartPropertyContext } from './add-property';
+import type { SunburstSeries } from '../../series/sunburst/sunburst';
+import type { CirclePackingSeries } from '../../series/circle-packing/circle-packing';
+export declare const initKeyMap: () => {
+    keyMap: Map<any, any>;
+};
+export declare function addDataKey(this: BaseSeries<any>, d: any, i: number, context: AddVChartPropertyContext): void;
+export declare function addHierarchyDataKey(this: TreeMapSeries | SunburstSeries | CirclePackingSeries, d: any, i: number, context: AddVChartPropertyContext, depth?: number, root?: string, rootIndex?: number): void;

package/build/es5/data/transforms/dimension-data.d.ts

@@ -0,0 +1,10 @@
+import type { DataView } from '@visactor/vdataset';
+export interface IDimensionTreeOpt {
+    fields: string[];
+}
+export declare const dimensionTree: (data: Array<DataView>, op: IDimensionTreeOpt) => DataView[] | {
+    dimensionValues: {};
+    dimensionData: any;
+};
+export declare function mapValues(target: object, fn: (value: any, key: string) => any): {};
+export declare function findDataInFields(data: any, fields: string[]): any;

package/build/es5/data/transforms/dimension-statistics.d.ts

@@ -0,0 +1,41 @@
+import type { DataView } from '@visactor/vdataset';
+export declare const StatisticsDefault: {
+    min: () => number;
+    max: () => number;
+    values: () => Set<unknown>;
+    'array-min': () => number;
+    'array-max': () => number;
+};
+export declare const StatisticsValueTransform: {
+    min: (v: any) => any;
+    max: (v: any) => any;
+    values: (v: Set<string>) => string[];
+    'array-min': (v: any) => any;
+    'array-max': (v: any) => any;
+};
+declare function StatisticsMin(last: any, value: any): any;
+declare function StatisticsMax(last: any, value: any): any;
+declare function StatisticsArrayMin(last: any, valueArr: any): any;
+declare function StatisticsArrayMax(last: any, valueArr: any): any;
+declare function StatisticsValues(last: Set<string>, value: any): Set<string>;
+export declare const StatisticsMethod: {
+    min: typeof StatisticsMin;
+    max: typeof StatisticsMax;
+    values: typeof StatisticsValues;
+    'array-min': typeof StatisticsArrayMin;
+    'array-max': typeof StatisticsArrayMax;
+};
+export type StatisticOperations = Array<'max' | 'min' | 'values' | 'array-max' | 'array-min'>;
+export interface IStatisticsOption {
+    fields: {
+        key: string;
+        operations: StatisticOperations;
+        customize?: {
+            max: number;
+            min: number;
+        } | any[];
+    }[];
+    target?: 'parser' | 'latest';
+}
+export declare const dimensionStatistics: (data: Array<DataView>, op: IStatisticsOption) => {};
+export {};

package/build/es5/data/transforms/drill.d.ts

@@ -0,0 +1,14 @@
+import type { Datum } from '../../typings';
+export declare enum DrillEnum {
+    DrillDown = "drillDown",
+    DrillUp = "drillUp"
+}
+export type DrillInfo = {
+    key: string;
+    type: DrillEnum;
+    path: string[];
+};
+export declare const drillFilter: (data: Array<Datum>, op: {
+    info: () => DrillInfo;
+    keyField: () => string;
+}) => any[];

package/build/es5/data/transforms/flatten.d.ts

@@ -0,0 +1,9 @@
+import type { Datum } from '../../typings';
+import type { TreemapNodeElement, SunburstNodeElement } from '@visactor/vgrammar-hierarchy';
+export type FlattenNodeElement = TreemapNodeElement | SunburstNodeElement;
+export interface IFlattenOpt {
+    output?: Datum[];
+    maxDepth?: number;
+    callback?: <T>(node: FlattenNodeElement) => T;
+}
+export declare const flatten: (data: Array<Datum>, op?: IFlattenOpt) => FlattenNodeElement[];

package/build/es5/data/transforms/funnel.d.ts

@@ -0,0 +1,51 @@
+import type { DataView } from '@visactor/vdataset';
+export interface IFunnelOpt {
+    valueField: string;
+    asTransformRatio: string;
+    asReachRatio: string;
+    asHeightRatio: string;
+    asValueRatio: string;
+    asLastValueRatio: string;
+    asNextValueRatio: string;
+    asCurrentValue: string;
+    asLastValue: string;
+    asNextValue: string;
+    isCone?: boolean;
+    heightVisual?: boolean;
+    range?: {
+        min: number;
+        max: number;
+    };
+}
+export declare const funnel: (originData: Array<DataView>, op: IFunnelOpt) => {
+    dataSet: import("@visactor/vdataset").DataSet;
+    options?: import("@visactor/vdataset").IDataViewOptions;
+    isDataView: boolean;
+    type: import("@visactor/vdataset/es/constants").DATAVIEW_TYPE;
+    name: string | number;
+    target: any;
+    parseOption: import("@visactor/vdataset/es/parser").IParserOptions;
+    transformsArr: import("@visactor/vdataset").ITransformOptions[];
+    isRunning: boolean;
+    rawData: any;
+    history: boolean;
+    historyData: any[];
+    parserData: any;
+    latestData: any;
+    _diffMap: Map<string, any>;
+    _diffRank: number;
+    latestDataAUD: {
+        add: any;
+        update: any;
+        del: any;
+    };
+    reRunAllTransform: (opt?: {
+        pushHistory: boolean;
+        emitMessage: boolean;
+    }) => DataView;
+    markRunning: () => void;
+}[];
+export interface IFunnelTransformOpt {
+    asIsTransformLevel: string;
+}
+export declare const funnelTransform: (originData: Array<DataView>, op: IFunnelTransformOpt) => any;

package/build/es5/data/transforms/hierarchy-dimension-statistics.d.ts

@@ -0,0 +1,3 @@
+import type { IStatisticsOption } from './dimension-statistics';
+import type { DataView } from '@visactor/vdataset';
+export declare const hierarchyDimensionStatistics: (data: Array<DataView>, op: IStatisticsOption) => {};

package/build/es5/data/transforms/invalid-travel.d.ts

@@ -0,0 +1,8 @@
+import type { IInvalidType, StringOrNumber } from '../../typings';
+export interface ITravelOpt {
+    config: () => {
+        invalidType: IInvalidType;
+        checkField: StringOrNumber;
+    };
+}
+export declare const invalidTravel: (data: Array<any>, op: ITravelOpt) => any[];

package/build/es5/data/transforms/legend-data/continuous/continuous.d.ts

@@ -0,0 +1,4 @@
+import type { ISeries } from '../../../../series/interface';
+import type { IContinuousLegendDataMakeOption, IContinuousLegendFilterOption } from './interface';
+export declare const continuousLegendDataMake: (data: Array<ISeries>, op: IContinuousLegendDataMakeOption) => any;
+export declare const continuousLegendFilter: (data: Array<any>, op: IContinuousLegendFilterOption) => any[];

package/build/es5/data/transforms/legend-data/continuous/index.d.ts

@@ -0,0 +1,2 @@
+export * from './continuous';
+export * from './interface';

package/build/es5/data/transforms/legend-data/continuous/interface.d.ts

@@ -0,0 +1,13 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { ISeries } from '../../../../series/interface';
+import type { StringOrNumber } from '../../../../typings';
+export interface IContinuousLegendDataMakeOption {
+    series: () => ISeries[];
+    field: () => string | undefined;
+    scale?: () => IBaseScale;
+}
+export interface IContinuousLegendFilterOption {
+    selected: () => StringOrNumber[];
+    field: () => string | undefined;
+    data: () => StringOrNumber[];
+}

package/build/es5/data/transforms/legend-data/discrete/discrete.d.ts

@@ -0,0 +1,4 @@
+import type { ISeries } from '../../../../series/interface';
+import type { IDiscreteLegendData, IDiscreteLegendDataMakeOption, IDiscreteLegendFilterOption } from './interface';
+export declare const discreteLegendDataMake: (data: Array<ISeries>, op: IDiscreteLegendDataMakeOption) => IDiscreteLegendData[];
+export declare const discreteLegendFilter: (data: Array<any>, op: IDiscreteLegendFilterOption) => any[];

package/build/es5/data/transforms/legend-data/discrete/index.d.ts

@@ -0,0 +1,2 @@
+export * from './discrete';
+export * from './interface';

package/build/es5/data/transforms/legend-data/discrete/interface.d.ts

@@ -0,0 +1,15 @@
+import type { ISeries } from '../../../../series/interface';
+import type { StringOrNumber } from '../../../../typings';
+export interface IDiscreteLegendData {
+    key: string;
+    style: (attribute: string) => any;
+}
+export interface IDiscreteLegendDataMakeOption {
+    series: () => ISeries[];
+    seriesField: (s: ISeries) => string;
+}
+export interface IDiscreteLegendFilterOption {
+    selected: () => StringOrNumber[];
+    field: () => string;
+    data: () => StringOrNumber[];
+}

package/build/es5/data/transforms/lookup.d.ts

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

package/build/es5/data/transforms/map.d.ts

@@ -0,0 +1,7 @@
+import type { GeoSourceType } from '../../typings/geo';
+export interface IMapOpt {
+    nameMap: Record<string, string>;
+    nameProperty: string;
+}
+export declare const DEFAULT_MAP_LOOK_UP_KEY: string;
+export declare const map: (data: GeoSourceType, opt: IMapOpt) => any;

package/build/es5/data/transforms/obj-flat.d.ts

@@ -0,0 +1,2 @@
+import type { DataView } from '@visactor/vdataset';
+export declare const objFlat: (data: Array<DataView>, op: string) => any[];