@visactor/vchart-types 0.10.0-alpha.2

package/types/series/radar/interface.d.ts

@@ -0,0 +1,22 @@
+import type { IAnimationSpec } from '../../animation/spec';
+import type { IMarkOverlap, IMarkProgressiveConfig } from '../../mark/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { IAreaMarkSpec, ILineMarkSpec, ISymbolMarkSpec } from '../../typings/visual';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { ILineLikeLabelSpec, ILineLikeSeriesTheme } from '../mixin/line-mixin';
+import type { IRoseLikeSeriesSpec, IRoseLikeSeriesTheme } from '../polar/rose-like';
+import type { RadarAppearPreset } from './animation';
+type RadarMarks = 'point' | 'line' | 'area';
+export interface IRadarSeriesSpec extends IRoseLikeSeriesSpec, IAnimationSpec<RadarMarks, RadarAppearPreset>, IMarkProgressiveConfig, IMarkOverlap {
+    type: 'radar';
+    [SeriesMarkNameEnum.point]?: IMarkSpec<ISymbolMarkSpec>;
+    [SeriesMarkNameEnum.line]?: IMarkSpec<ILineMarkSpec>;
+    [SeriesMarkNameEnum.area]?: IMarkSpec<IAreaMarkSpec>;
+    [SeriesMarkNameEnum.label]?: ILineLikeLabelSpec;
+    seriesMark?: 'point' | 'line' | 'area';
+    activePoint?: boolean;
+}
+export interface IRadarSeriesTheme extends IRoseLikeSeriesTheme, ILineLikeSeriesTheme {
+    [SeriesMarkNameEnum.area]?: Partial<IMarkTheme<IAreaMarkSpec>>;
+}
+export {};

package/types/series/radar/radar.d.ts

@@ -0,0 +1,31 @@
+import { LineLikeSeriesMixin } from '../mixin/line-mixin';
+import type { IMark, IMarkProgressiveConfig } from '../../mark/interface';
+import type { Datum } from '../../typings';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IRadarSeriesSpec } from './interface';
+import { RoseLikeSeries } from '../polar/rose-like';
+import { LineLikeSeriesSpecTransformer } from '../mixin/line-mixin-transformer';
+export interface RadarSeries<T extends IRadarSeriesSpec> extends Pick<LineLikeSeriesMixin, 'initLineMark' | 'initSymbolMark' | 'initLabelMarkStyle' | 'initLineMarkStyle' | 'initSymbolMarkStyle' | 'encodeDefined' | '_lineMark' | '_symbolMark' | 'addOverlapCompile'>, RoseLikeSeries<T> {
+}
+export declare class RadarSeries<T extends IRadarSeriesSpec = IRadarSeriesSpec> extends RoseLikeSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof LineLikeSeriesSpecTransformer;
+    private _areaMark;
+    protected _sortDataByAxis: boolean;
+    initGroups(): void;
+    compile(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    initAreaMark(progressive: IMarkProgressiveConfig, isSeriesMark: boolean): void;
+    initAreaMarkStyle(): void;
+    protected initTooltip(): void;
+    initAnimation(): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+    getSeriesStyle(datum: Datum): (attribute: string) => any;
+}
+export declare const registerRadarSeries: () => void;

package/types/series/range-area/constant.d.ts

@@ -0,0 +1,2 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const rangeAreaSeriesMark: SeriesMarkMap;

package/types/series/range-area/interface.d.ts

@@ -0,0 +1,7 @@
+import type { IAreaSeriesSpec, IAreaSeriesTheme } from '../area/interface';
+export interface IRangeAreaSeriesSpec extends Omit<IAreaSeriesSpec, 'type'> {
+    type: 'rangeArea';
+    minField?: string;
+    maxField?: string;
+}
+export type IRangeAreaSeriesTheme = IAreaSeriesTheme;

package/types/series/range-area/range-area.d.ts

@@ -0,0 +1,15 @@
+import type { DataView } from '@visactor/vdataset';
+import { AreaSeries } from '../area/area';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IAreaSeriesSpec } from '../area/interface';
+export declare class RangeAreaSeries<T extends IAreaSeriesSpec = IAreaSeriesSpec> extends AreaSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    initMark(): void;
+    initMarkStyle(): void;
+    protected initTooltip(): void;
+    viewDataStatisticsUpdate(d: DataView): void;
+}
+export declare const registerRangeAreaSeries: () => void;

package/types/series/range-area/tooltip-helper.d.ts

@@ -0,0 +1,7 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+import type { ITooltipPattern, TooltipActiveType } from '../../typings';
+import type { IDimensionInfo } from '../../event/events/dimension/interface';
+export declare class RangeAreaSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    getDefaultTooltipPattern(activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]): ITooltipPattern | null;
+}

package/types/series/range-column/3d/index.d.ts

@@ -0,0 +1,2 @@
+export * from './range-column-3d';
+export * from './range-column-3d-transformer';

package/types/series/range-column/3d/range-column-3d-transformer.d.ts

@@ -0,0 +1,5 @@
+import type { IRangeColumn3dSeriesSpec, IRangeColumnSeriesTheme } from '../interface';
+import { RangeColumnSeriesSpecTransformer } from '../range-column-transformer';
+export declare class RangeColumn3dSeriesSpecTransformer<T extends IRangeColumn3dSeriesSpec = IRangeColumn3dSeriesSpec, K extends IRangeColumnSeriesTheme = IRangeColumnSeriesTheme> extends RangeColumnSeriesSpecTransformer<any, K> {
+    protected _transformLabelSpec(spec: T): void;
+}

package/types/series/range-column/3d/range-column-3d.d.ts

@@ -0,0 +1,15 @@
+import { MarkTypeEnum } from '../../../mark/interface/type';
+import type { SeriesMarkMap } from '../../interface';
+import { SeriesTypeEnum } from '../../interface/type';
+import { RangeColumnSeries } from '../range-column';
+import type { AdaptiveSpec } from '../../../typings';
+import type { IRangeColumn3dSeriesSpec } from '../interface';
+export declare const DefaultBandWidth = 6;
+export declare class RangeColumn3dSeries<T extends IRangeColumn3dSeriesSpec = IRangeColumn3dSeriesSpec> extends RangeColumnSeries<AdaptiveSpec<T, 'type'>> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    protected _barMarkType: MarkTypeEnum;
+    protected _barName: string;
+    static readonly mark: SeriesMarkMap;
+}
+export declare const registerRangeColumn3dSeries: () => void;

package/types/series/range-column/animation.d.ts

@@ -0,0 +1,10 @@
+import type { DirectionType } from '../../typings';
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export interface IRangeColumnAnimationParams {
+    direction: DirectionType;
+}
+export type RangeColumnAppearPreset = 'fadeIn' | 'grow';
+export declare const rangeColumnGrowIn: (params: IRangeColumnAnimationParams) => IAnimationTypeConfig;
+export declare const rangeColumnGrowOut: (params: IRangeColumnAnimationParams) => IAnimationTypeConfig;
+export declare function rangeColumnPresetAnimation(params: IRangeColumnAnimationParams, preset: RangeColumnAppearPreset): IAnimationTypeConfig;
+export declare const registerRangeColumnAnimation: () => void;

package/types/series/range-column/constant.d.ts

@@ -0,0 +1,3 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const rangeColumnSeriesMark: SeriesMarkMap;
+export declare const rangeColumn3dSeriesMark: SeriesMarkMap;

package/types/series/range-column/interface.d.ts

@@ -0,0 +1,56 @@
+import type { IBarSeriesSpec } from '../bar/interface';
+import type { ICartesianSeriesTheme } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { IPositionedTextMarkSpec, IRectMarkSpec, ITextMarkSpec } from '../../typings/visual';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { RangeColumnAppearPreset } from './animation';
+import type { ILabelSpec } from '../../component/label';
+import type { SeriesMarkNameEnum } from '../interface/type';
+export declare const enum PositionEnum {
+    middle = "middle",
+    start = "start",
+    end = "end",
+    bothEnd = "bothEnd"
+}
+export declare const enum minMaxPositionEnum {
+    middle = "middle",
+    start = "start",
+    end = "end"
+}
+type RangeColumnMarks = 'rangeColumn';
+export interface IRangeColumnSeriesSpec extends Omit<IBarSeriesSpec, 'type' | 'label' | keyof IAnimationSpec<RangeColumnMarks, RangeColumnAppearPreset>>, IAnimationSpec<RangeColumnMarks, RangeColumnAppearPreset> {
+    type: 'rangeColumn';
+    minField: string;
+    maxField: string;
+    [SeriesMarkNameEnum.bar]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.label]?: Partial<ILabelSpec> & {
+        position?: PositionEnum;
+        [SeriesMarkNameEnum.minLabel]?: IMarkSpec<IPositionedTextMarkSpec> & {
+            visible: boolean;
+            position?: keyof typeof minMaxPositionEnum;
+            offset?: number;
+            formatMethod?: (text: string | string[], datum?: any) => string | string[];
+        };
+        [SeriesMarkNameEnum.maxLabel]?: IMarkSpec<IPositionedTextMarkSpec> & {
+            visible: boolean;
+            position?: minMaxPositionEnum;
+            offset?: number;
+            formatMethod?: (text: string | string[], datum?: any) => string | string[];
+        };
+    };
+}
+export interface IRangeColumnSeriesTheme extends ICartesianSeriesTheme {
+    [SeriesMarkNameEnum.bar]?: Partial<IMarkTheme<IRectMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: Partial<ILabelSpec> & {
+        [SeriesMarkNameEnum.minLabel]?: Partial<IMarkTheme<ITextMarkSpec> & {
+            position?: keyof typeof minMaxPositionEnum;
+        }>;
+        [SeriesMarkNameEnum.maxLabel]?: Partial<IMarkTheme<ITextMarkSpec> & {
+            position?: keyof typeof minMaxPositionEnum;
+        }>;
+    };
+}
+export interface IRangeColumn3dSeriesSpec extends Omit<IRangeColumnSeriesSpec, 'type'> {
+    type: 'rangeColumn3d';
+}
+export {};

package/types/series/range-column/range-column-3d.d.ts

@@ -0,0 +1,15 @@
+import { MarkTypeEnum } from '../../mark/interface/type';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import { RangeColumnSeries } from './range-column';
+import type { AdaptiveSpec } from '../../typings';
+import type { IRangeColumn3dSeriesSpec } from './interface';
+export declare const DefaultBandWidth = 6;
+export declare class RangeColumn3dSeries<T extends IRangeColumn3dSeriesSpec = IRangeColumn3dSeriesSpec> extends RangeColumnSeries<AdaptiveSpec<T, 'type'>> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    protected _barMarkType: MarkTypeEnum;
+    protected _barName: string;
+    static readonly mark: SeriesMarkMap;
+}
+export declare const registerRangeColumn3dSeries: () => void;

package/types/series/range-column/range-column-transformer.d.ts

@@ -0,0 +1,5 @@
+import { BarSeriesSpecTransformer } from '../bar/bar-transformer';
+import type { IRangeColumnSeriesSpec, IRangeColumnSeriesTheme } from './interface';
+export declare class RangeColumnSeriesSpecTransformer<T extends IRangeColumnSeriesSpec = IRangeColumnSeriesSpec, K extends IRangeColumnSeriesTheme = IRangeColumnSeriesTheme> extends BarSeriesSpecTransformer<any, K> {
+    protected _transformLabelSpec(spec: T): void;
+}

package/types/series/range-column/range-column.d.ts

@@ -0,0 +1,32 @@
+import { BarSeries } from '../bar/bar';
+import { MarkTypeEnum } from '../../mark/interface/type';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { ITextMark } from '../../mark/text';
+import type { Datum } from '../../typings';
+import type { IRangeColumnSeriesSpec } from './interface';
+export declare const DefaultBandWidth = 6;
+export declare class RangeColumnSeries<T extends IRangeColumnSeriesSpec = IRangeColumnSeriesSpec> extends BarSeries<any> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    protected _barMarkType: MarkTypeEnum;
+    protected _barName: string;
+    protected _spec: T;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: any;
+    protected _stack: boolean;
+    private _minLabelMark?;
+    private _maxLabelMark?;
+    private _labelMark?;
+    initMark(): void;
+    initMarkStyle(): void;
+    initLabelMarkStyle(labelMark: ITextMark): void;
+    protected _dataToPosX(datum: Datum): number;
+    protected _dataToPosX1(datum: Datum): number;
+    protected _dataToPosY(datum: Datum): number;
+    protected _dataToPosY1(datum: Datum): number;
+    initAnimation(): void;
+    protected initTooltip(): void;
+}
+export declare const registerRangeColumnSeries: () => void;

package/types/series/range-column/tooltip-helper.d.ts

@@ -0,0 +1,6 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+import type { ITooltipPattern, TooltipActiveType } from '../../typings';
+export declare class RangeColumnSeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    getDefaultTooltipPattern(activeType: TooltipActiveType): ITooltipPattern | null;
+}

package/types/series/rose/animation.d.ts

@@ -0,0 +1,13 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export interface IRoseAnimationParams {
+    innerRadius: () => number;
+    growField?: 'angle' | 'radius';
+}
+export type RoseAppearPreset = 'growAngle' | 'growRadius' | 'fadeIn';
+export declare const Appear_Grow: (params: IRoseAnimationParams) => IAnimationTypeConfig;
+export declare const Appear_FadeIn: IAnimationTypeConfig;
+export declare const roseEnter: (params: IRoseAnimationParams) => IAnimationTypeConfig;
+export declare const roseExit: (params: IRoseAnimationParams) => IAnimationTypeConfig;
+export declare const roseDisappear: (params: IRoseAnimationParams) => IAnimationTypeConfig;
+export declare function rosePresetAnimation(params: IRoseAnimationParams, preset: RoseAppearPreset | boolean): IAnimationTypeConfig;
+export declare const registerRoseAnimation: () => void;

package/types/series/rose/constant.d.ts

@@ -0,0 +1,2 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const roseSeriesMark: SeriesMarkMap;

package/types/series/rose/interface.d.ts

@@ -0,0 +1,19 @@
+import type { IAnimationSpec } from '../../animation/spec';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec';
+import type { IArcMarkSpec } from '../../typings/visual';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { IRoseLikeSeriesSpec, IRoseLikeSeriesTheme } from '../polar/rose-like';
+import type { RoseAppearPreset } from './animation';
+import type { IArcLabelSpec } from '../pie/interface';
+export type RoseMarks = 'rose';
+export interface IRoseSeriesSpec extends IRoseLikeSeriesSpec, IAnimationSpec<RoseMarks, RoseAppearPreset> {
+    type: 'rose';
+    categoryField: string | string[];
+    valueField: string | string[];
+    [SeriesMarkNameEnum.rose]?: IMarkSpec<IArcMarkSpec>;
+    [SeriesMarkNameEnum.label]?: IArcLabelSpec;
+}
+export interface IRoseSeriesTheme extends IRoseLikeSeriesTheme {
+    [SeriesMarkNameEnum.rose]?: Partial<IMarkTheme<IArcMarkSpec>>;
+    [SeriesMarkNameEnum.label]?: IArcLabelSpec;
+}

package/types/series/rose/rose-transformer.d.ts

@@ -0,0 +1,5 @@
+import { BaseSeriesSpecTransformer } from '../base';
+import type { IRoseSeriesSpec, IRoseSeriesTheme } from './interface';
+export declare class RoseSeriesSpecTransformer<T extends IRoseSeriesSpec = IRoseSeriesSpec, K extends IRoseSeriesTheme = IRoseSeriesTheme> extends BaseSeriesSpecTransformer<T, K> {
+    protected _transformLabelSpec(spec: T): void;
+}

package/types/series/rose/rose.d.ts

@@ -0,0 +1,33 @@
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { IRoseSeriesSpec } from './interface';
+import { RoseLikeSeries } from '../polar/rose-like';
+import type { ITextMark } from '../../mark/text';
+import type { IMark } from '../../mark/interface';
+import type { ILabelMark } from '../../mark/label';
+import { RoseSeriesSpecTransformer } from './rose-transformer';
+export declare const DefaultBandWidth = 0.5;
+export declare class RoseSeries<T extends IRoseSeriesSpec = IRoseSeriesSpec> extends RoseLikeSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof RoseSeriesSpecTransformer;
+    protected _supportStack: boolean;
+    private _roseMark;
+    protected _labelMark: ITextMark | null;
+    initMark(): void;
+    initMarkStyle(): void;
+    protected _buildMarkAttributeContext(): void;
+    private initRoseMark;
+    private getRoseAngle;
+    private startAngleScale;
+    private endAngleScale;
+    private initRoseMarkStyle;
+    protected initTooltip(): void;
+    initLabelMarkStyle(textMark: ILabelMark): void;
+    initAnimation(): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerRoseSeries: () => void;

package/types/series/sankey/animation.d.ts

@@ -0,0 +1,13 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { DirectionType } from '../../typings';
+export type SankeyMark = 'node' | 'link' | 'label';
+export type SankeyAppearPreset = 'growIn' | 'fadeIn';
+export interface ISankeyAnimationParams {
+    direction: DirectionType;
+    growFrom: () => number;
+}
+export declare const sankeyGrowIn: (params: ISankeyAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
+export declare const sankeyGrowOut: (params: ISankeyAnimationParams, isOverall?: boolean) => IAnimationTypeConfig;
+export declare const sankeyNodePresetAnimation: (params: ISankeyAnimationParams, preset: SankeyAppearPreset) => IAnimationTypeConfig;
+export declare const sankeyLinkPresetAnimation: (preset: SankeyAppearPreset) => IAnimationTypeConfig;
+export declare const registerSankeyAnimation: () => void;

package/types/series/sankey/constant.d.ts

@@ -0,0 +1,2 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const sankeySeriesMark: SeriesMarkMap;

package/types/series/sankey/interface.d.ts

@@ -0,0 +1,108 @@
+import type { ISeriesSpec, DirectionType, IMarkTheme } from '../../typings';
+import type { IMarkSpec } from '../../typings/spec/common';
+import type { IRectMarkSpec, ILinkPathMarkSpec } from '../../typings/visual';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { SankeyAppearPreset, SankeyMark } from './animation';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { ILabelSpec } from '../../component/label';
+export interface ISankeySeriesSpec extends Omit<ISeriesSpec, 'data'>, IAnimationSpec<SankeyMark, SankeyAppearPreset> {
+    nameKey: any;
+    type: 'sankey';
+    categoryField: string;
+    valueField: string;
+    sourceField?: string;
+    targetField?: string;
+    direction?: DirectionType;
+    nodeAlign?: 'left' | 'right' | 'center' | 'justify' | 'start' | 'end';
+    nodeGap?: number;
+    nodeWidth?: string | number | ((node: SankeyNodeElement) => number);
+    linkWidth?: number | ((link: SankeyLinkElement) => number);
+    minStepWidth?: number;
+    minNodeHeight?: number;
+    minLinkHeight?: number;
+    iterations?: number;
+    nodeKey?: string | number | ((datum: SankeyNodeDatum) => string | number);
+    linkSortBy?: (a: SankeyLinkElement, b: SankeyLinkElement) => number;
+    nodeSortBy?: (a: SankeyNodeElement, b: SankeyNodeElement) => number;
+    setNodeLayer?: (datum: SankeyNodeDatum) => number;
+    [SeriesMarkNameEnum.node]?: IMarkSpec<IRectMarkSpec>;
+    [SeriesMarkNameEnum.link]?: IMarkSpec<ILinkPathMarkSpec>;
+    emphasis?: {
+        enable: boolean;
+        trigger?: 'click' | 'hover';
+        effect: 'self' | 'adjacency' | 'related';
+    };
+    [SeriesMarkNameEnum.label]?: ILabelSpec & {
+        position: 'outside' | 'inside-start' | 'inside-middle' | 'inside-end' | 'left' | 'right';
+        limit: number;
+    };
+}
+export interface SankeyLinkDatum {
+    source: string | number;
+    target: string | number;
+    value?: number;
+}
+export interface SankeyNodeDatum {
+    value?: number;
+}
+export interface HierarchyNodeDatum {
+    value?: number;
+    children?: HierarchyNodeDatum[];
+}
+export type SankeyData = {
+    nodes?: SankeyNodeDatum[];
+    links: SankeyLinkDatum[];
+} | {
+    nodes: HierarchyNodeDatum[];
+};
+export interface SankeyNodeElement {
+    key: string | number;
+    index: number;
+    depth: number;
+    endDepth?: number;
+    layer?: number;
+    isLastLayer?: boolean;
+    value: number;
+    datum: SankeyNodeDatum;
+    sourceLinks: SankeyLinkElement[];
+    targetLinks: SankeyLinkElement[];
+    x0?: number;
+    y0?: number;
+    x1?: number;
+    y1?: number;
+}
+export interface SankeyLinkElement {
+    vertical?: boolean;
+    index: number;
+    source: string | number;
+    target: string | number;
+    value: number;
+    datum: SankeyLinkDatum | SankeyLinkDatum[];
+    thickness?: number;
+    sourceRect?: {
+        x0: number;
+        x1: number;
+        y0: number;
+        y1: number;
+    };
+    targetRect?: {
+        x0: number;
+        x1: number;
+        y0: number;
+        y1: number;
+    };
+    parents?: (string | number)[];
+    y0?: number;
+    y1?: number;
+    x0?: number;
+    x1?: number;
+}
+export type SankeyLayoutResult = {
+    nodes: SankeyNodeElement[];
+    links: SankeyLinkElement[];
+    columns: SankeyNodeElement[][];
+}[];
+export interface ISankeySeriesTheme {
+    [SeriesMarkNameEnum.node]?: IMarkTheme<IRectMarkSpec>;
+    [SeriesMarkNameEnum.link]?: IMarkTheme<ILinkPathMarkSpec>;
+}

package/types/series/sankey/sankey.d.ts

@@ -0,0 +1,67 @@
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { Datum } from '../../typings';
+import { SeriesData } from '../base/series-data';
+import type { ISankeySeriesSpec } from './interface';
+import type { ExtendEventParam } from '../../event/interface';
+import type { IElement, IGlyphElement } from '@visactor/vgrammar-core';
+import type { IMark } from '../../mark/interface';
+export declare class SankeySeries<T extends ISankeySeriesSpec = ISankeySeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    private _nodeMark;
+    private _linkMark;
+    private _labelMark?;
+    private _nodeLayoutZIndex;
+    private _labelLayoutZIndex;
+    private _labelLimit;
+    protected _nodesSeriesData?: SeriesData;
+    protected _linksSeriesData?: SeriesData;
+    private _viewBox;
+    protected _categoryField: string;
+    private _colorScale;
+    getCategoryField(): string;
+    setCategoryField(f: string): string;
+    protected _valueField: string;
+    getValueField(): string;
+    setValueField(f: string): string;
+    setAttrFromSpec(): void;
+    initData(): void;
+    initMark(): void;
+    initMarkStyle(): void;
+    protected _initNodeMarkStyle(): void;
+    protected _initLinkMarkStyle(): void;
+    protected _initLabelMarkStyle(): void;
+    private _createText;
+    initAnimation(): void;
+    protected initEvent(): void;
+    private nodesSeriesDataUpdate;
+    private linksSeriesDataUpdate;
+    protected _handleAdjacencyClick: (params: ExtendEventParam) => void;
+    protected _handleRelatedClick: (params: ExtendEventParam) => void;
+    protected _handleClearEmpty: () => void;
+    protected _handleNodeAdjacencyClick: (element: IElement) => void;
+    protected _handleLinkAdjacencyClick: (element: IGlyphElement) => void;
+    protected _handleNodeRelatedClick: (element: IElement) => void;
+    protected _handleLinkRelatedClick: (element: IGlyphElement) => void;
+    protected initTooltip(): void;
+    _setNodeOrdinalColorScale(): void;
+    getNodeList(): any;
+    _getNodeNameFromData(datum: Datum): any;
+    extractNamesFromTree(tree: any, categoryName: string): Set<unknown>;
+    getDimensionField(): string[];
+    getMeasureField(): string[];
+    getRawDataStatisticsByField(field: string, isNumeric?: boolean): {
+        values?: any[];
+        min?: number;
+        max?: number;
+    };
+    private _collectByField;
+    onLayoutEnd(ctx: any): void;
+    getDefaultShapeType(): string;
+    protected _noAnimationDataKey(datum: Datum, index: number): unknown | undefined;
+    getActiveMarks(): IMark[];
+}
+export declare const registerSankeySeries: () => void;

package/types/series/sankey/tooltip-helper.d.ts

@@ -0,0 +1,7 @@
+import type { ISeriesTooltipHelper } from '../interface';
+import { BaseSeriesTooltipHelper } from '../base/tooltip-helper';
+import type { ITooltipPattern, TooltipActiveType } from '../../typings';
+import type { IDimensionInfo } from '../../event/events/dimension/interface';
+export declare class SankeySeriesTooltipHelper extends BaseSeriesTooltipHelper implements ISeriesTooltipHelper {
+    getDefaultTooltipPattern(activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]): ITooltipPattern | null;
+}

package/types/series/scatter/animation.d.ts

@@ -0,0 +1,8 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+export type ScatterMarks = 'point' | 'label';
+export type ScatterAppearPreset = 'scaleIn' | 'fadeIn';
+export interface IScatterAnimationParams {
+    [key: string]: object;
+}
+export declare const scatterPresetAnimation: (_params: IScatterAnimationParams, preset: ScatterAppearPreset) => IAnimationTypeConfig;
+export declare const registerScatterAnimation: () => void;

package/types/series/scatter/constant.d.ts

@@ -0,0 +1,2 @@
+import type { SeriesMarkMap } from '../interface/common';
+export declare const scatterSeriesMark: SeriesMarkMap;

package/types/series/scatter/interface.d.ts

@@ -0,0 +1,24 @@
+import type { ICartesianSeriesSpec, ICartesianSeriesTheme } from '../cartesian/interface';
+import type { IMarkSpec, IMarkTheme } from '../../typings/spec/common';
+import type { ISymbolMarkSpec, IVisualSpecBase, ShapeType, FunctionType } from '../../typings';
+import type { IAnimationSpec } from '../../animation/spec';
+import type { ScatterAppearPreset, ScatterMarks } from './animation';
+import type { IMarkProgressiveConfig } from '../../mark/interface';
+import type { SeriesMarkNameEnum } from '../interface/type';
+import type { ILineLikeLabelSpec } from '../mixin/line-mixin';
+export interface IScatterSeriesSpec extends ICartesianSeriesSpec, IAnimationSpec<ScatterMarks, ScatterAppearPreset>, IMarkProgressiveConfig {
+    type: 'scatter';
+    xField?: string | string[];
+    yField?: string | string[];
+    [SeriesMarkNameEnum.point]?: IMarkSpec<ISymbolMarkSpec>;
+    sizeField?: string;
+    size?: number | number[] | FunctionType<number> | IVisualSpecBase<unknown, number>;
+    shapeField?: string;
+    shape?: ShapeType | ShapeType[] | FunctionType<ShapeType> | IVisualSpecBase<unknown, ShapeType>;
+    [SeriesMarkNameEnum.label]?: ILineLikeLabelSpec;
+}
+export interface IScatterSeriesTheme extends ICartesianSeriesTheme {
+    size?: number;
+    shape?: ShapeType;
+    [SeriesMarkNameEnum.point]?: Partial<IMarkTheme<ISymbolMarkSpec>>;
+}

package/types/series/scatter/scatter-transformer.d.ts

@@ -0,0 +1,5 @@
+import { BaseSeriesSpecTransformer } from '../base';
+import type { IScatterSeriesSpec, IScatterSeriesTheme } from './interface';
+export declare class ScatterSeriesSpecTransformer<T extends IScatterSeriesSpec = IScatterSeriesSpec, K extends IScatterSeriesTheme = IScatterSeriesTheme> extends BaseSeriesSpecTransformer<T, K> {
+    protected _transformLabelSpec(spec: T): void;
+}

package/types/series/scatter/scatter.d.ts

@@ -0,0 +1,39 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IScatterInvalidType } from '../../typings';
+import type { IScatterSeriesSpec } from './interface';
+import { CartesianSeries } from '../cartesian/cartesian';
+import type { SeriesMarkMap } from '../interface';
+import { SeriesTypeEnum } from '../interface/type';
+import type { ILabelMark } from '../../mark/label';
+import type { IMark } from '../../mark/interface';
+import { ScatterSeriesSpecTransformer } from './scatter-transformer';
+export declare class ScatterSeries<T extends IScatterSeriesSpec = IScatterSeriesSpec> extends CartesianSeries<T> {
+    static readonly type: string;
+    type: SeriesTypeEnum;
+    static readonly mark: SeriesMarkMap;
+    static readonly transformerConstructor: any;
+    readonly transformerConstructor: typeof ScatterSeriesSpecTransformer;
+    private _symbolMark;
+    private _labelMark;
+    private _size;
+    private _sizeField;
+    private _shape;
+    private _shapeField;
+    protected _invalidType: IScatterInvalidType;
+    setAttrFromSpec(): void;
+    private _getSeriesAttribute;
+    private getSizeAttribute;
+    private getShapeAttribute;
+    initMark(): void;
+    initMarkStyle(): void;
+    initAnimation(): void;
+    private initSymbolMarkStyle;
+    protected initTooltip(): void;
+    viewDataStatisticsUpdate(d: DataView): void;
+    initLabelMarkStyle(labelMark?: ILabelMark): void;
+    handleZoom(e: any): void;
+    handlePan(e: any): void;
+    getDefaultShapeType(): string;
+    getActiveMarks(): IMark[];
+}
+export declare const registerScatterSeries: () => void;

package/types/series/sunburst/animation/enter.d.ts

@@ -0,0 +1,3 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { ISunburstAnimationParams } from './interface';
+export declare const sunburstEnter: (params: ISunburstAnimationParams) => IAnimationTypeConfig;

package/types/series/sunburst/animation/exit.d.ts

@@ -0,0 +1,3 @@
+import type { IAnimationTypeConfig } from '@visactor/vgrammar-core';
+import type { ISunburstAnimationParams } from './interface';
+export declare const sunburstExit: (params: ISunburstAnimationParams) => IAnimationTypeConfig;