@visactor/vchart-types 0.10.0-alpha.2

package/types/layout/interface.d.ts

@@ -0,0 +1,115 @@
+import type { IBoundsLike } from '@visactor/vutils';
+import type { StringOrNumber } from '../typings/common';
+import type { IOrientType, IRect } from '../typings/space';
+import type { IPoint } from '../typings/coordinate';
+import type { ILayoutNumber, ILayoutPaddingSpec, ILayoutPoint, ILayoutRect, ILayoutType } from '../typings/layout';
+import type { ILayoutModel } from '../model/interface';
+export interface IBaseLayout {
+    layoutItems: LayoutCallBack;
+}
+export type LayoutCallBack = (chart: any, item: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike) => void;
+export interface ILayoutSpecBase {
+    type: string;
+}
+export type ElementSpec = ({
+    modelKey: string;
+    modelIndex: number;
+} | {
+    modelId: string;
+}) & {
+    col: number;
+    colSpan?: number;
+    row: number;
+    rowSpan?: number;
+};
+export interface IGridLayoutSpec extends ILayoutSpecBase {
+    type: 'grid';
+    col: number;
+    row: number;
+    colWidth?: {
+        index: number;
+        size: number | ((maxSize: number) => number);
+    }[];
+    rowHeight?: {
+        index: number;
+        size: number | ((maxSize: number) => number);
+    }[];
+    elements: ElementSpec[];
+}
+export interface IBaseLayoutSpec extends ILayoutSpecBase {
+    type: 'base';
+}
+export type ILayoutSpec = IBaseLayoutSpec | IGridLayoutSpec;
+export interface ILayoutConstructor {
+    type: string;
+    new (spec: ILayoutSpec | any, ctx?: any): IBaseLayout;
+}
+export interface ILayoutItem {
+    readonly type: string;
+    directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
+    layoutClip: boolean;
+    layoutType: ILayoutType;
+    layoutBindRegionID: number | number[];
+    layoutOrient: IOrientType;
+    autoIndent: boolean;
+    alignSelf?: 'start' | 'end' | 'middle';
+    layoutPaddingLeft: number;
+    layoutPaddingTop: number;
+    layoutPaddingRight: number;
+    layoutPaddingBottom: number;
+    layoutOffsetX: number;
+    layoutOffsetY: number;
+    layoutLevel: number;
+    chartLayoutRect: ILayoutRect;
+    readonly layoutRectLevelMap: ILayoutRect;
+    minWidth: number;
+    maxWidth: number;
+    minHeight: number;
+    maxHeight: number;
+    readonly model: ILayoutModel;
+    getModelId: () => StringOrNumber;
+    getModelVisible: () => boolean;
+    getSpec?: () => any;
+    setAttrFromSpec: (spec: ILayoutItemSpec, chartViewRect: ILayoutRect) => void;
+    setRectInSpec: (rect: ILayoutRect) => ILayoutRect;
+    getLayoutStartPoint: () => ILayoutPoint;
+    getLayoutRect: () => ILayoutRect;
+    getLayout: () => IRect;
+    getLastComputeOutBounds: () => IBoundsLike;
+    onLayoutStart: (layoutRect: IRect, viewRect: ILayoutRect, ctx: any) => void;
+    onLayoutEnd: (option: any) => void;
+    setLayoutRect: (rect: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRect>) => void;
+    computeBoundsInRect: (rect: ILayoutRect) => ILayoutRect;
+    setLayoutStartPosition: (pos: Partial<IPoint>) => void;
+    absoluteLayoutInRect: (rect: IRect) => void;
+}
+export interface ILayoutItemSpec {
+    layoutType?: ILayoutType;
+    layoutLevel?: number;
+    alignSelf?: 'start' | 'end' | 'middle';
+    orient?: IOrientType;
+    padding?: ILayoutPaddingSpec;
+    noOuterPadding?: boolean;
+    width?: ILayoutNumber;
+    maxWidth?: ILayoutNumber;
+    minWidth?: ILayoutNumber;
+    height?: ILayoutNumber;
+    maxHeight?: ILayoutNumber;
+    minHeight?: ILayoutNumber;
+    offsetX?: ILayoutNumber;
+    offsetY?: ILayoutNumber;
+    zIndex?: number;
+    clip?: boolean;
+    left?: ILayoutNumber;
+    right?: ILayoutNumber;
+    top?: ILayoutNumber;
+    bottom?: ILayoutNumber;
+    center?: boolean;
+}
+export interface ILayoutItemInitOption {
+    layoutType: ILayoutType;
+    layoutLevel: number;
+    layoutOrient?: IOrientType;
+    transformLayoutRect?: (rect: ILayoutRect) => ILayoutRect;
+    transformLayoutPosition?: (pos: Partial<IPoint>) => Partial<IPoint>;
+}

package/types/layout/layout-item.d.ts

@@ -0,0 +1,72 @@
+import type { ILayoutModel } from './../model/interface';
+import type { IRect, IPoint } from '../typings';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { ILayoutItem, ILayoutItemInitOption, ILayoutItemSpec } from './interface';
+import type { IChartLayoutOption } from '../chart/interface/common';
+import type { ILayoutAlignSelf, ILayoutPoint, ILayoutRect } from '../typings/layout';
+export declare class LayoutItem implements ILayoutItem {
+    protected _spec: ILayoutItemSpec;
+    getSpec(): ILayoutItemSpec;
+    layoutClip: boolean;
+    autoIndent: boolean;
+    private _layoutStartPoint;
+    getLayoutStartPoint(): ILayoutPoint;
+    private _layoutRect;
+    protected _layoutRectLevelMap: ILayoutRect;
+    get layoutRectLevelMap(): ILayoutRect;
+    protected _minWidth: number;
+    get minWidth(): number;
+    set minWidth(v: number);
+    protected _maxWidth: number;
+    get maxWidth(): number;
+    set maxWidth(v: number);
+    protected _minHeight: number;
+    get minHeight(): number;
+    set minHeight(v: number);
+    protected _maxHeight: number;
+    get maxHeight(): number;
+    set maxHeight(v: number);
+    protected _lastComputeRect: ILayoutRect;
+    protected _lastComputeOutBounds: IBoundsLike;
+    getLastComputeOutBounds(): IBoundsLike;
+    getLayoutRect: () => ILayoutRect;
+    layoutType: ILayoutItem['layoutType'];
+    layoutBindRegionID: ILayoutItem['layoutBindRegionID'];
+    _layoutOrient: ILayoutItem['layoutOrient'];
+    get layoutOrient(): ILayoutItem['layoutOrient'];
+    set layoutOrient(v: ILayoutItem['layoutOrient']);
+    layoutPaddingLeft: ILayoutItem['layoutPaddingLeft'];
+    layoutPaddingTop: ILayoutItem['layoutPaddingTop'];
+    layoutPaddingRight: ILayoutItem['layoutPaddingRight'];
+    layoutPaddingBottom: ILayoutItem['layoutPaddingBottom'];
+    layoutOffsetX: ILayoutItem['layoutOffsetX'];
+    layoutOffsetY: ILayoutItem['layoutOffsetY'];
+    layoutLevel: ILayoutItem['layoutLevel'];
+    chartLayoutRect: ILayoutRect;
+    alignSelf: ILayoutAlignSelf;
+    protected _model: ILayoutModel;
+    get model(): ILayoutModel;
+    get type(): string;
+    protected _option: ILayoutItemInitOption;
+    constructor(model: ILayoutModel, option: ILayoutItemInitOption);
+    private _setLayoutAttributeFromSpec;
+    setAttrFromSpec(spec: ILayoutItemSpec, chartViewRect: ILayoutRect): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
+    onLayoutEnd(option: IChartLayoutOption): void;
+    private _getAbsoluteSpecValue;
+    absoluteLayoutInRect(layoutRect: IRect): void;
+    setLayoutStartPosition(pos: Partial<IPoint>): void;
+    setLayoutRect({ width, height }: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRect>): void;
+    getLayout(): IRect;
+    mergeLayoutRect({ width, height }: ILayoutRect): ILayoutRect;
+    getOrientPosAttribute(): "x" | "y";
+    getOrientSizeAttribute(): "width" | "height";
+    protected changeBoundsBySetting(bounds: IBoundsLike): IBoundsLike;
+    setRectInSpec(rect: ILayoutRect): {
+        width: number;
+        height: number;
+    };
+    computeBoundsInRect(rect: ILayoutRect): ILayoutRect;
+    getModelId(): number;
+    getModelVisible(): boolean;
+}

package/types/layout/layout3d/index.d.ts

@@ -0,0 +1,22 @@
+import type { IChart } from '../../chart/interface/chart';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IRect } from '../../typings/space';
+import type { IBaseLayout, ILayoutItem } from '../interface';
+import type { IOffset } from '../base-layout';
+import { Layout } from '../base-layout';
+export declare class Layout3d extends Layout implements IBaseLayout {
+    static type: string;
+    layoutItems(_chart: IChart, items: ILayoutItem[], chartLayoutRect: IRect, chartViewBox: IBoundsLike): void;
+    protected layoutZAxisItems(zItems: ILayoutItem[], zRect: IRect): void;
+    getItemComputeLayoutRect(item: ILayoutItem, extraOffset?: IOffset): {
+        width: number;
+        height: number;
+    };
+    protected _checkAutoIndent(items: ILayoutItem[]): {
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+    };
+}
+export declare const registerLayout3d: () => void;

package/types/layout/util.d.ts

@@ -0,0 +1,6 @@
+import type { Layout } from './base-layout';
+import type { ILayoutItem } from './interface';
+export declare function layoutLeftInlineItems(items: ILayoutItem[], layout: Layout, limitHeight: number): void;
+export declare function layoutRightInlineItems(items: ILayoutItem[], layout: Layout, limitHeight: number): void;
+export declare function layoutTopInlineItems(items: ILayoutItem[], layout: Layout, limitWidth: number): void;
+export declare function layoutBottomInlineItems(items: ILayoutItem[], layout: Layout, limitWidth: number): void;

package/types/mark/arc-3d.d.ts

@@ -0,0 +1,11 @@
+import type { IArc3dMarkSpec } from '../typings';
+import { BaseArcMark } from './arc';
+import type { IMarkRaw } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IArc3dMark = IMarkRaw<IArc3dMarkSpec>;
+export declare class Arc3dMark extends BaseArcMark<IArc3dMarkSpec> implements IArc3dMark {
+    static readonly type = MarkTypeEnum.arc3d;
+    readonly type: MarkTypeEnum;
+    protected _support3d?: boolean;
+}
+export declare const registerArc3dMark: () => void;

package/types/mark/arc.d.ts

@@ -0,0 +1,21 @@
+import type { IArcMarkSpec, Datum, StateValueType } from '../typings';
+import { BaseMark } from './base/base-mark';
+import type { IMarkOption, IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IArcMark = IMarkRaw<IArcMarkSpec>;
+export declare class BaseArcMark<T extends IArcMarkSpec> extends BaseMark<T> implements IMarkRaw<T> {
+    readonly type: MarkTypeEnum;
+    _unCompileChannel: {
+        centerOffset: boolean;
+        radiusOffset: boolean;
+    };
+    constructor(name: string, option: IMarkOption);
+    protected _getDefaultStyle(): IMarkStyle<T>;
+    protected computeOuterRadius: (key: string, datum: Datum, states: StateValueType, opt: any, superValue: number) => number;
+    protected computeCenter: (key: 'x' | 'y', datum: Datum, states: StateValueType, opt: any, center: number) => number;
+}
+export declare class ArcMark extends BaseArcMark<IArcMarkSpec> implements IArcMark {
+    static readonly type = MarkTypeEnum.arc;
+    readonly type: MarkTypeEnum;
+}
+export declare const registerArcMark: () => void;

package/types/mark/area.d.ts

@@ -0,0 +1,12 @@
+import type { IAreaMarkSpec } from '../typings/visual';
+import { BaseLineMark } from './base/base-line';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IAreaMark = IMarkRaw<IAreaMarkSpec>;
+export declare class AreaMark extends BaseLineMark<IAreaMarkSpec> implements IAreaMark {
+    static readonly type = MarkTypeEnum.area;
+    readonly type = MarkTypeEnum.area;
+    protected _getDefaultStyle(): IMarkStyle<IAreaMarkSpec>;
+    protected _getIgnoreAttributes(): string[];
+}
+export declare const registerAreaMark: () => void;

package/types/mark/base/base-line.d.ts

@@ -0,0 +1,8 @@
+import type { StateValueType } from '../../compile/mark';
+import type { ConvertToMarkStyleSpec, ILineLikeMarkSpec } from '../../typings/visual';
+import { BaseMark } from './base-mark';
+import type { IMarkStyle } from '../interface';
+export declare abstract class BaseLineMark<T extends ILineLikeMarkSpec = ILineLikeMarkSpec> extends BaseMark<T> {
+    protected abstract _getIgnoreAttributes(): string[];
+    setStyle<T>(style: Partial<ConvertToMarkStyleSpec<T>> | Partial<IMarkStyle<T>>, state?: StateValueType, level?: number, stateStyle?: import("../interface").IMarkStateStyle<T>): void;
+}

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

@@ -0,0 +1,38 @@
+import type { IAttributeOpt, IModelMarkAttributeContext } from '../../compile/mark/interface';
+import type { Datum, IMarkSpec, ICommonSpec } from '../../typings';
+import type { IMarkRaw, IMarkStateStyle, IMarkStyle, IMarkOption, StyleConvert, MarkInputStyle } from '../interface';
+import { CompilableMark } from '../../compile/mark/compilable-mark';
+import type { StateValueType } from '../../compile/mark';
+export type ExChannelCall = (key: string | number | symbol, datum: Datum, states: StateValueType, opt: unknown, baseValue: unknown) => unknown;
+export declare class BaseMark<T extends ICommonSpec> extends CompilableMark implements IMarkRaw<T> {
+    stateStyle: IMarkStateStyle<T>;
+    protected _option: IMarkOption;
+    protected _attributeContext: IModelMarkAttributeContext;
+    _extensionChannel: {
+        [key: string | number | symbol]: string[];
+    };
+    _computeExChannel: {
+        [key: string | number | symbol]: ExChannelCall;
+    };
+    constructor(name: string, option: IMarkOption);
+    created(): void;
+    initStyleWithSpec(spec: IMarkSpec<T>, key?: string): void;
+    convertAngleToRadian(styleConverter: StyleConvert<number>): StyleConvert<any>;
+    isUserLevel(level: number): boolean;
+    setStyle<U extends keyof T>(style: Partial<IMarkStyle<T>>, state?: StateValueType, level?: number, stateStyle?: IMarkStateStyle<T>): void;
+    getStyle(key: string, state?: StateValueType): any;
+    protected _filterStyle(style: Partial<IMarkStyle<T>>, state: StateValueType, level: number, stateStyle?: IMarkStateStyle<T>): Partial<IMarkStyle<T>>;
+    protected _filterAttribute<U extends keyof T>(attr: U, style: MarkInputStyle<T[U]>, state: StateValueType, level: number, isUserLevel: boolean, stateStyle?: IMarkStateStyle<T>): StyleConvert<T[U]>;
+    setReferer<U extends keyof T>(mark: IMarkRaw<T>, styleKey?: U, state?: StateValueType, stateStyle?: IMarkStateStyle<T>): void;
+    setPostProcess<U extends keyof T>(key: U, postProcessFunc: any, state?: StateValueType): void;
+    getAttribute<U extends keyof T>(key: U, datum: Datum, state?: StateValueType, opt?: IAttributeOpt): any;
+    setAttribute<U extends keyof T>(attr: U, style: MarkInputStyle<T[U]>, state?: StateValueType, level?: number, stateStyle?: IMarkStateStyle<T>): void;
+    protected _getDefaultStyle(): IMarkStyle<T>;
+    protected _styleConvert<U extends keyof T>(style?: MarkInputStyle<T[U]>): StyleConvert<T[U]> | undefined;
+    protected _computeAttribute<U extends keyof T>(key: U, state: StateValueType): any;
+    protected _computeStateAttribute<U extends keyof T>(stateStyle: any, key: U, state: StateValueType): any;
+    private _initStyle;
+    private _initSpecStyle;
+    private _computeGradientAttr;
+    private _computeBorderAttr;
+}

package/types/mark/base/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base-mark';
+export * from './base-line';

package/types/mark/box-plot.d.ts

@@ -0,0 +1,13 @@
+import type { IBoxPlotMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IGroupMark } from '@visactor/vgrammar-core';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IBoxPlotMark = IMarkRaw<IBoxPlotMarkSpec>;
+export declare class BoxPlotMark extends BaseMark<IBoxPlotMarkSpec> implements IBoxPlotMark {
+    static readonly type = MarkTypeEnum.boxPlot;
+    readonly type = MarkTypeEnum.boxPlot;
+    protected _getDefaultStyle(): IMarkStyle<IBoxPlotMarkSpec>;
+    protected _initProduct(group?: string | IGroupMark): void;
+}
+export declare const registerBoxPlotMark: () => void;

package/types/mark/cell.d.ts

@@ -0,0 +1,11 @@
+import type { ICellMarkSpec } from '../typings';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+import { BaseSymbolMark } from './symbol';
+export type ICellMark = IMarkRaw<ICellMarkSpec>;
+export declare class CellMark extends BaseSymbolMark<ICellMarkSpec> implements ICellMark {
+    static readonly type = MarkTypeEnum.cell;
+    readonly type = MarkTypeEnum.cell;
+    protected _getDefaultStyle(): IMarkStyle<ICellMarkSpec>;
+}
+export declare const registerCellMark: () => void;

package/types/mark/component.d.ts

@@ -0,0 +1,15 @@
+import type { IGroupMark } from '@visactor/vgrammar-core';
+import type { ICommonSpec } from '../typings';
+import { BaseMark } from './base/base-mark';
+import type { IMarkOption, IMarkRaw } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IComponentMark = IMarkRaw<ICommonSpec>;
+export declare class ComponentMark extends BaseMark<ICommonSpec> implements IComponentMark {
+    static readonly type = MarkTypeEnum.component;
+    type: string;
+    private _componentType;
+    private _mode;
+    constructor(name: string, option: IMarkOption);
+    protected _initProduct(group?: string | IGroupMark): void;
+}
+export declare const registerComponentMark: () => void;

package/types/mark/group.d.ts

@@ -0,0 +1,32 @@
+import type { Maybe } from '../typings';
+import type { IGroupMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMark, IMarkRaw, IMarkStyle, MarkType } from './interface';
+import { MarkTypeEnum } from './interface/type';
+import type { IGroupMark as IVGrammarGroupMark } from '@visactor/vgrammar-core';
+import type { IMarkCompileOption } from '../compile/mark';
+export interface IGroupMark extends IMarkRaw<IGroupMarkSpec> {
+    addMark: (m: IMark) => boolean;
+    removeMark: (m: IMark) => boolean;
+    getMarks: () => IMark[];
+    getMarkInType: (type: MarkType) => IMark[];
+    getMarkInId: (id: number) => IMark | undefined;
+    getMarkInName: (name: string) => IMark | undefined;
+}
+export declare class GroupMark extends BaseMark<IGroupMarkSpec> implements IGroupMark {
+    static readonly type = MarkTypeEnum.group;
+    readonly type = MarkTypeEnum.group;
+    protected _marks: IMark[];
+    getMarks(): IMark[];
+    protected _product: Maybe<IVGrammarGroupMark>;
+    getProduct: () => Maybe<IVGrammarGroupMark>;
+    protected _getDefaultStyle(): IMarkStyle<IGroupMarkSpec>;
+    protected isMarkExist(mark: IMark): boolean;
+    addMark(mark: IMark): boolean;
+    removeMark(mark: IMark): boolean;
+    getMarkInType(type: MarkType): IMark[];
+    getMarkInId(id: number): IMark;
+    getMarkInName(name: string): IMark;
+    protected _compileProduct(option?: IMarkCompileOption): void;
+}
+export declare const registerGroupMark: () => void;

package/types/mark/image.d.ts

@@ -0,0 +1,11 @@
+import type { IImageMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IImageMark = IMarkRaw<IImageMarkSpec>;
+export declare class ImageMark extends BaseMark<IImageMarkSpec> implements IImageMark {
+    static readonly type = MarkTypeEnum.image;
+    readonly type = MarkTypeEnum.image;
+    protected _getDefaultStyle(): IMarkStyle<IImageMarkSpec>;
+}
+export declare const registerImageMark: () => void;

package/types/mark/index.d.ts

@@ -0,0 +1,22 @@
+import { BoxPlotMark } from './box-plot';
+import { LineMark } from './line';
+import { SymbolMark } from './symbol';
+import { GroupMark } from './group';
+import { RuleMark } from './rule';
+import { TextMark } from './text';
+import { AreaMark } from './area';
+import { RectMark } from './rect';
+import { Rect3dMark } from './rect-3d';
+import { PathMark } from './path';
+import { ArcMark } from './arc';
+import { Arc3dMark } from './arc-3d';
+import { ComponentMark } from './component';
+import { LinkPathMark } from './link-path';
+import { RippleMark } from './ripple';
+import { ProgressArcMark } from './progress-arc';
+import { CellMark } from './cell';
+import { BaseMark } from './base';
+import { PolygonMark } from './polygon/polygon';
+import { Pyramid3dMark } from './polygon/pyramid-3d';
+export type { IBoxPlotMarkSpec, ILineMarkSpec, ISymbolMarkSpec, IGroupMarkSpec, IRuleMarkSpec, ITextMarkSpec, IAreaMarkSpec, IRect3dMarkSpec, IRectMarkSpec, IPathMarkSpec, IArcMarkSpec, IArc3dMarkSpec, ICommonSpec, IPolygonMarkSpec, IPyramid3dMarkSpec, ILinkPathMarkSpec, IRippleMarkSpec, IProgressArcMarkSpec, ConvertToMarkStyleSpec, ICellMarkSpec } from '../typings/visual';
+export { BoxPlotMark, LineMark, SymbolMark, GroupMark, RuleMark, TextMark, AreaMark, Rect3dMark, RectMark, PathMark, Arc3dMark, ArcMark, ComponentMark, PolygonMark, Pyramid3dMark, LinkPathMark, RippleMark, ProgressArcMark, CellMark, BaseMark };

package/types/mark/interface/common.d.ts

@@ -0,0 +1,77 @@
+import type { IGlobalScale } from '../../scale/interface';
+import type { ICommonSpec, VisualType, ValueType, FunctionType } from '../../typings/visual';
+import type { IModel } from '../../model/interface';
+import type { IBaseScale } from '@visactor/vscale';
+import type { MarkType } from './type';
+import type { ICompilableMark, ICompilableMarkOption, IModelMarkAttributeContext, StateValueType } from '../../compile/mark';
+import type { StringOrNumber } from '../../typings';
+export interface VisualScaleType {
+    scale: IBaseScale;
+    field: StringOrNumber;
+    changeDomain?: 'none' | 'replace' | 'expand';
+}
+export type MarkInputStyle<T> = StyleConvert<T> | VisualType<T>;
+export type StyleConvert<T> = ValueType<T> | FunctionType<T> | VisualScaleType;
+export interface IAttrConfig<A, R extends ICommonSpec> {
+    level: number;
+    style: StyleConvert<A>;
+    referer?: IMarkRaw<R>;
+    postProcess?: (result: A, ...args: Parameters<FunctionType<A>>) => A;
+}
+export type IAttrs<T extends ICommonSpec> = {
+    [K in keyof T]: IAttrConfig<T[K], T>;
+};
+export type IMarkProgressiveConfig = {
+    large?: boolean;
+    largeThreshold?: number;
+    progressiveStep?: number;
+    progressiveThreshold?: number;
+};
+export type IMarkStateStyle<T extends ICommonSpec> = Record<StateValueType, Partial<IAttrs<T>>>;
+export type IMarkStyle<T extends ICommonSpec> = {
+    [key in keyof T]: MarkInputStyle<T[key]>;
+};
+export interface IMarkRaw<T extends ICommonSpec> extends ICompilableMark {
+    readonly stateStyle: IMarkStateStyle<T>;
+    getAttribute: <U extends keyof T>(key: U, datum: any, state?: StateValueType, opt?: any) => unknown;
+    setAttribute: <U extends keyof T>(attr: U, style: StyleConvert<T[U]>, state?: StateValueType, level?: number) => void;
+    setStyle: (style: Partial<IMarkStyle<T>>, state?: StateValueType, level?: number) => void;
+    setReferer: (mark: IMarkRaw<T>, styleKey?: string, state?: StateValueType, stateStyle?: IMarkStateStyle<T>) => void;
+    initStyleWithSpec: (spec: any, key?: string) => void;
+    created: () => void;
+    setPostProcess: <U extends keyof T, A>(key: U, postProcessFunc: IAttrConfig<A, T>['postProcess'], state?: StateValueType) => void;
+}
+export type IMark = IMarkRaw<ICommonSpec>;
+export interface IMarkOption extends ICompilableMarkOption {
+    model: IModel;
+    map: Map<StringOrNumber, IModel | IMark>;
+    globalScale: IGlobalScale;
+    seriesId?: number;
+    componentType?: string;
+    attributeContext?: IModelMarkAttributeContext;
+}
+export interface IMarkConstructor {
+    type: MarkType;
+    constructorType?: MarkType;
+    new (name: string, options: IMarkOption): IMark;
+}
+export interface IComponentMarkConstructor {
+    type: MarkType;
+    constructorType?: MarkType;
+    new (componentType: string, name: string, options: IMarkOption): IMark;
+}
+export type MarkConstructor = IMarkConstructor | IComponentMarkConstructor;
+export interface IMarkDataInitOption extends IMarkOption {
+    mark: IMark;
+}
+export type ISamplingMethod = 'lttb' | 'min' | 'max' | 'sum' | 'average';
+export interface IDataSamping {
+    activePoint?: boolean;
+    sampling?: ISamplingMethod;
+    samplingFactor?: number;
+}
+export interface IMarkOverlap {
+    pointDis?: number;
+    pointDisMul?: number;
+    markOverlap?: boolean;
+}

package/types/mark/interface/index.d.ts

@@ -0,0 +1,2 @@
+export * from './common';
+export * from './type';

package/types/mark/interface/type.d.ts

@@ -0,0 +1,25 @@
+export type MarkType = keyof typeof MarkTypeEnum | string;
+export declare const enum MarkTypeEnum {
+    group = "group",
+    symbol = "symbol",
+    rule = "rule",
+    line = "line",
+    text = "text",
+    rect = "rect",
+    rect3d = "rect3d",
+    image = "image",
+    path = "path",
+    area = "area",
+    arc = "arc",
+    arc3d = "arc3d",
+    polygon = "polygon",
+    pyramid3d = "pyramid3d",
+    boxPlot = "boxPlot",
+    linkPath = "linkPath",
+    progressArc = "progressArc",
+    cell = "cell",
+    ripple = "ripple",
+    liquid = "liquid",
+    component = "component",
+    label = "label"
+}

package/types/mark/label.d.ts

@@ -0,0 +1,28 @@
+import type { IComponentMark } from './component';
+import type { IMark } from './interface/common';
+import { MarkTypeEnum } from './interface/type';
+import { TextMark } from './text';
+export declare class LabelMark extends TextMark implements ILabelMark {
+    static readonly type = MarkTypeEnum.text;
+    static readonly constructorType = MarkTypeEnum.label;
+    skipEncode: boolean;
+    private _rule;
+    getRule(): string;
+    setRule(rule: string): void;
+    private _target;
+    getTarget(): IMark;
+    setTarget(target: IMark): void;
+    private _component;
+    getComponent(): IMark;
+    setComponent(component: IMark): void;
+}
+export interface ILabelMark extends IMark {
+    skipEncode: boolean;
+    getRule: () => string;
+    setRule: (rule: string) => void;
+    getTarget: () => IMark;
+    setTarget: (target: IMark) => void;
+    getComponent: () => IComponentMark;
+    setComponent: (component: IComponentMark) => void;
+}
+export declare const registerLabelMark: () => void;

package/types/mark/line.d.ts

@@ -0,0 +1,12 @@
+import type { ILineMarkSpec } from '../typings/visual';
+import { BaseLineMark } from './base/base-line';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type ILineMark = IMarkRaw<ILineMarkSpec>;
+export declare class LineMark extends BaseLineMark<ILineMarkSpec> implements ILineMark {
+    static readonly type = MarkTypeEnum.line;
+    readonly type = MarkTypeEnum.line;
+    protected _getDefaultStyle(): IMarkStyle<ILineMarkSpec>;
+    protected _getIgnoreAttributes(): string[];
+}
+export declare const registerLineMark: () => void;

package/types/mark/link-path.d.ts

@@ -0,0 +1,13 @@
+import { BaseMark } from './base/base-mark';
+import type { ILinkPathMarkSpec } from '../typings/visual';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+import type { IGroupMark } from '@visactor/vgrammar-core';
+export type ILinkPathMark = IMarkRaw<ILinkPathMarkSpec>;
+export declare class LinkPathMark extends BaseMark<ILinkPathMarkSpec> implements ILinkPathMark {
+    static readonly type = MarkTypeEnum.linkPath;
+    readonly type = MarkTypeEnum.linkPath;
+    protected _getDefaultStyle(): IMarkStyle<ILinkPathMarkSpec>;
+    protected _initProduct(group?: string | IGroupMark): void;
+}
+export declare const registerLinkPathMark: () => void;

package/types/mark/liquid.d.ts

@@ -0,0 +1,13 @@
+import type { ILiquidMarkSpec } from '../typings';
+import type { IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+import { BaseMark } from './base';
+import type { ILiquidMark } from '../series/liquid/liquid';
+import type { IGroupMark } from '@visactor/vgrammar-core';
+export declare class LiquidMark extends BaseMark<ILiquidMarkSpec> implements ILiquidMark {
+    static readonly type = MarkTypeEnum.liquid;
+    readonly type = MarkTypeEnum.liquid;
+    protected _getDefaultStyle(): IMarkStyle<ILiquidMarkSpec>;
+    protected _initProduct(group?: string | IGroupMark): void;
+}
+export declare const registerLiquidMark: () => void;

package/types/mark/mark-set/index.d.ts

@@ -0,0 +1,22 @@
+import type { IMark } from '../interface';
+export interface IMarkInfo {
+    styleWithSeriesField?: boolean;
+    name?: string;
+}
+export declare class MarkSet {
+    protected _children: IMark[];
+    protected _markNameMap: Record<string, IMark>;
+    getMarkNameMap(): Record<string, IMark>;
+    protected readonly _infoMap: Map<IMark, IMarkInfo>;
+    static readonly defaultMarkInfo: IMarkInfo;
+    addMark(mark?: IMark, markInfo?: IMarkInfo): void;
+    removeMark(markName: string): void;
+    clear(): void;
+    forEach(callbackfn: (value: IMark, index: number, array: IMark[]) => void): void;
+    includes(mark: IMark, fromIndex?: number): boolean;
+    get(key: number | string): any;
+    getMarks(): IMark[];
+    getMarksInType(type: string | string[]): IMark[];
+    getMarkInId(markId: number): IMark | undefined;
+    getMarkWithInfo(info: Partial<IMarkInfo>): IMark;
+}

package/types/mark/path.d.ts

@@ -0,0 +1,11 @@
+import type { IPathMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IPathMark = IMarkRaw<IPathMarkSpec>;
+export declare class PathMark extends BaseMark<IPathMarkSpec> implements IPathMark {
+    static readonly type = MarkTypeEnum.path;
+    readonly type = MarkTypeEnum.path;
+    protected _getDefaultStyle(): IMarkStyle<IPathMarkSpec>;
+}
+export declare const registerPathMark: () => void;