@visactor/vchart-types 0.16.17-alpha.0

package/types/mark/arc.d.ts

@@ -0,0 +1,20 @@
+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;
+}

package/types/mark/area.d.ts

@@ -0,0 +1,11 @@
+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[];
+}

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, datum: Datum, state: StateValueType, opt: IAttributeOpt): any;
+    protected _computeStateAttribute<U extends keyof T>(stateStyle: any, key: U, datum: Datum, state: StateValueType, opt: IAttributeOpt): 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,12 @@
+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;
+}

package/types/mark/cell.d.ts

@@ -0,0 +1,10 @@
+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>;
+}

package/types/mark/component.d.ts

@@ -0,0 +1,14 @@
+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;
+}

package/types/mark/group.d.ts

@@ -0,0 +1,31 @@
+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;
+}

package/types/mark/image.d.ts

@@ -0,0 +1,10 @@
+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>;
+}

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,24 @@
+export type MarkType = keyof typeof MarkTypeEnum | string;
+export declare 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",
+    component = "component",
+    label = "label"
+}

package/types/mark/label.d.ts

@@ -0,0 +1,27 @@
+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;
+}

package/types/mark/line.d.ts

@@ -0,0 +1,11 @@
+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[];
+}

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

@@ -0,0 +1,12 @@
+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;
+}

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,10 @@
+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>;
+}

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

@@ -0,0 +1,6 @@
+import type { ICommonSpec } from '../../typings/visual';
+import { BaseMark } from '../base/base-mark';
+import type { IMarkStyle } from '../interface';
+export declare class BasePolygonMark<T extends ICommonSpec> extends BaseMark<T> {
+    protected _getDefaultStyle(): IMarkStyle<T>;
+}

package/types/mark/polygon/polygon.d.ts

@@ -0,0 +1,10 @@
+import type { IPolygonMarkSpec } from '../../typings/visual';
+import { BasePolygonMark } from './base-polygon';
+import type { IMarkRaw, IMarkStyle } from '../interface';
+import { MarkTypeEnum } from '../interface/type';
+export type IPolygonMark = IMarkRaw<IPolygonMarkSpec>;
+export declare class PolygonMark extends BasePolygonMark<IPolygonMarkSpec> implements IPolygonMark {
+    static readonly type = MarkTypeEnum.polygon;
+    readonly type = MarkTypeEnum.polygon;
+    protected _getDefaultStyle(): IMarkStyle<IPolygonMarkSpec>;
+}

package/types/mark/polygon/pyramid-3d.d.ts

@@ -0,0 +1,9 @@
+import type { IPyramid3dMarkSpec } from '../../typings/visual';
+import type { IMarkRaw } from '../interface';
+import { MarkTypeEnum } from '../interface/type';
+import { BasePolygonMark } from './base-polygon';
+export type IPyramid3dMark = IMarkRaw<IPyramid3dMarkSpec>;
+export declare class Pyramid3dMark extends BasePolygonMark<IPyramid3dMarkSpec> implements IPyramid3dMark {
+    static readonly type = MarkTypeEnum.pyramid3d;
+    readonly type = MarkTypeEnum.pyramid3d;
+}

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

@@ -0,0 +1,13 @@
+import type { StateValueType } from '../typings/spec';
+import type { ConvertToMarkStyleSpec, IProgressArcMarkSpec } from '../typings/visual';
+import type { IMarkRaw, IMarkStateStyle, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+import { BaseArcMark } from './arc';
+export type IProgressArcMark = IMarkRaw<IProgressArcMarkSpec>;
+export declare class ProgressArcMark extends BaseArcMark<IProgressArcMarkSpec> implements IProgressArcMark {
+    static readonly type = MarkTypeEnum.arc;
+    static readonly constructorType = MarkTypeEnum.progressArc;
+    protected _cacheStateStyle: IMarkStateStyle<IProgressArcMarkSpec>;
+    protected _getDefaultStyle(): IMarkStyle<IProgressArcMarkSpec>;
+    protected _filterStyle(style: Partial<IMarkStyle<IProgressArcMarkSpec>>, state: StateValueType, level: number, stateStyle?: IMarkStateStyle<IProgressArcMarkSpec>): Partial<ConvertToMarkStyleSpec<IProgressArcMarkSpec>> | Partial<IMarkStyle<IProgressArcMarkSpec>>;
+}

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

@@ -0,0 +1,10 @@
+import type { IRect3dMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IRect3dMark = IMarkRaw<IRect3dMarkSpec>;
+export declare class Rect3dMark extends BaseMark<IRect3dMarkSpec> implements IRect3dMark {
+    static readonly type = MarkTypeEnum.rect3d;
+    readonly type = MarkTypeEnum.rect3d;
+    protected _getDefaultStyle(): IMarkStyle<IRect3dMarkSpec>;
+}

package/types/mark/rect.d.ts

@@ -0,0 +1,10 @@
+import type { IRectMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IRectMark = IMarkRaw<IRectMarkSpec>;
+export declare class RectMark extends BaseMark<IRectMarkSpec> implements IRectMark {
+    static readonly type = MarkTypeEnum.rect;
+    readonly type = MarkTypeEnum.rect;
+    protected _getDefaultStyle(): IMarkStyle<IRectMarkSpec>;
+}

package/types/mark/ripple.d.ts

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

package/types/mark/rule.d.ts

@@ -0,0 +1,10 @@
+import type { IRuleMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type IRuleMark = IMarkRaw<IRuleMarkSpec>;
+export declare class RuleMark extends BaseMark<IRuleMarkSpec> implements IRuleMark {
+    static readonly type = MarkTypeEnum.rule;
+    readonly type = MarkTypeEnum.rule;
+    protected _getDefaultStyle(): IMarkStyle<IRuleMarkSpec>;
+}

package/types/mark/symbol.d.ts

@@ -0,0 +1,12 @@
+import type { ISymbolMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type ISymbolMark = IMarkRaw<ISymbolMarkSpec>;
+export declare class BaseSymbolMark<T extends ISymbolMarkSpec> extends BaseMark<T> {
+    protected _getDefaultStyle(): IMarkStyle<T>;
+}
+export declare class SymbolMark extends BaseSymbolMark<ISymbolMarkSpec> implements ISymbolMark {
+    static readonly type = MarkTypeEnum.symbol;
+    readonly type = MarkTypeEnum.symbol;
+}

package/types/mark/text.d.ts

@@ -0,0 +1,10 @@
+import type { ITextMarkSpec } from '../typings/visual';
+import { BaseMark } from './base/base-mark';
+import type { IMarkRaw, IMarkStyle } from './interface';
+import { MarkTypeEnum } from './interface/type';
+export type ITextMark = IMarkRaw<ITextMarkSpec>;
+export declare class TextMark extends BaseMark<ITextMarkSpec> implements ITextMark {
+    static readonly type = MarkTypeEnum.text;
+    readonly type = MarkTypeEnum.text;
+    protected _getDefaultStyle(): IMarkStyle<ITextMarkSpec>;
+}

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

@@ -0,0 +1,3 @@
+import { MarkTypeEnum } from '../interface/type';
+export declare const MultiDatumMark: string[];
+export declare function isMultiDatumMark(type: MarkTypeEnum): boolean;

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

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

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

@@ -0,0 +1,84 @@
+import type { IEvent } from '../event/interface';
+import { LayoutItem } from './layout-item';
+import type { IEffect, IModel, IModelInitOption, IModelOption, IModelRenderOption, IModelEvaluateOption, IModelSpec, ILayoutRect, IModelMarkInfo } from './interface';
+import type { CoordinateType } from '../typings/coordinate';
+import type { IMark, IMarkOption, IMarkRaw, IMarkStyle } from '../mark/interface';
+import type { Datum, StateValueType, ConvertToMarkStyleSpec, ICommonSpec, StringOrNumber, IRect } from '../typings';
+import type { CompilableData } from '../compile/data/compilable-data';
+import type { IGroupMark } from '@visactor/vgrammar-core';
+import { MarkSet } from '../mark/mark-set';
+export declare abstract class BaseModel<T extends IModelSpec> extends LayoutItem<T> implements IModel {
+    readonly type: string;
+    readonly modelType: string;
+    readonly id: number;
+    userId: StringOrNumber | undefined;
+    readonly event: IEvent;
+    readonly effect: IEffect;
+    protected _data: CompilableData;
+    getData(): CompilableData;
+    protected _specIndex: number;
+    getSpecIndex(): number;
+    readonly specKey: string;
+    protected _originalSpec: any;
+    protected _option: IModelOption;
+    getOption(): IModelOption;
+    protected _marks: MarkSet;
+    getMarks(): IMark[];
+    getMarkNameMap(): Record<string, IMark>;
+    getMarkSet(): MarkSet;
+    getMarkInfoList(): IModelMarkInfo[];
+    getChart(): import("../chart/interface").IChart;
+    protected _theme?: any;
+    protected _lastLayoutRect: ILayoutRect;
+    protected _isLayout: boolean;
+    constructor(spec: T, option: IModelOption);
+    coordinate?: CoordinateType;
+    protected _releaseEvent(): void;
+    created(): void;
+    init(option: IModelInitOption): void;
+    afterInit(): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, ctx: any): void;
+    onLayoutEnd(ctx: any): void;
+    protected _forceLayout(): void;
+    onEvaluateEnd(ctx: IModelEvaluateOption): void;
+    abstract onRender(ctx: IModelRenderOption): void;
+    onDataUpdate(): void;
+    beforeRelease(): void;
+    release(): void;
+    updateSpec(spec: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    protected _transformSpec(): void;
+    protected _compareSpec(): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    reInit(theme?: any): void;
+    protected _initTheme(theme?: any): void;
+    protected _getTheme(): any;
+    protected _mergeThemeToSpec(): void;
+    protected _getDefaultSpecFromChart(chartSpec: any): Partial<T>;
+    protected _shouldMergeThemeToSpec(): boolean;
+    protected _prepareSpecBeforeMergingTheme(obj?: any): any;
+    protected _prepareSpecAfterMergingTheme(obj?: any): any;
+    setCurrentTheme(noRender?: boolean): Promise<void>;
+    updateLayoutAttribute(): void;
+    setAttrFromSpec(): void;
+    protected _convertMarkStyle<T extends ICommonSpec = ICommonSpec>(style: Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>): Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>;
+    setMarkStyle<T extends ICommonSpec>(mark: IMarkRaw<T>, style?: Partial<IMarkStyle<T> | ConvertToMarkStyleSpec<T>>, state?: StateValueType, level?: number): void;
+    initMarkStyleWithSpec(mark?: IMark, spec?: any, key?: string): void;
+    protected stateKeyToSignalName(key: string, opt?: string): string;
+    compileData(): void;
+    compileMarks(group?: string | IGroupMark): void;
+    protected _createMark<T extends IMark>(markInfo: IModelMarkInfo, option?: Partial<IMarkOption>): T;
+    protected _getDataIdKey(): string | ((datum: Datum) => string) | undefined;
+    getColorScheme(): import("..").IThemeColorScheme;
+    protected _getChartLevelTheme(): import("../core/interface").IChartLevelTheme;
+}