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

package/build/es5/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';
+import type { IGroupMark as IVGrammarGroupMark } from '@visactor/vgrammar';
+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/build/es5/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';
+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/build/es5/mark/index.d.ts

@@ -0,0 +1,21 @@
+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 { 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, IProgressArcMarkSpec, ConvertToMarkStyleSpec, ICellMarkSpec } from '../typings/visual';
+export { BoxPlotMark, LineMark, SymbolMark, GroupMark, RuleMark, TextMark, AreaMark, Rect3dMark, RectMark, PathMark, Arc3dMark, ArcMark, ComponentMark, PolygonMark, Pyramid3dMark, LinkPathMark, ProgressArcMark, CellMark, BaseMark };

package/build/es5/mark/interface/common.d.ts

@@ -0,0 +1,67 @@
+import type { DataView } from '@visactor/vdataset';
+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;
+    dataStatistics?: DataView;
+    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;
+}

package/build/es5/mark/interface/index.d.ts

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

package/build/es5/mark/interface/type.d.ts

@@ -0,0 +1,22 @@
+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",
+    component = "component"
+}

package/build/es5/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';
+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/build/es5/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';
+import type { IGroupMark } from '@visactor/vgrammar';
+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/build/es5/mark/mark-set/index.d.ts

@@ -0,0 +1,21 @@
+import type { IMark } from '../interface';
+export interface IMarkInfo {
+    styleWithSeriesField?: boolean;
+}
+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/build/es5/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';
+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/build/es5/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/build/es5/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';
+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/build/es5/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';
+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/build/es5/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';
+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/build/es5/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';
+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/build/es5/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';
+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/build/es5/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';
+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/build/es5/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';
+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/build/es5/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';
+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/build/es5/mark/utils/common.d.ts

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

package/build/es5/mark/utils/index.d.ts

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

package/build/es5/model/base-model.d.ts

@@ -0,0 +1,85 @@
+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 { ITooltipHelper } from './tooltip-helper';
+import type { CompilableData } from '../compile/data/compilable-data';
+import { ModelStateManager } from './model-state-manager';
+import type { IElement, IGroupMark, IMark as IVGrammarMark } from '@visactor/vgrammar';
+import { MarkSet } from '../mark/mark-set';
+export declare abstract class BaseModel extends LayoutItem 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 _spec: any;
+    getSpec(): any;
+    protected _specIndex: number;
+    getSpecIndex(): number;
+    readonly specKey: string;
+    protected _originalSpec: any;
+    protected _option: IModelOption;
+    getOption(): IModelOption;
+    protected _sceneNodeMap: Map<string, IElement>;
+    protected _marks: MarkSet;
+    getMarks(): IMark[];
+    getMarkNameMap(): Record<string, IMark>;
+    getMarkSet(): MarkSet;
+    getMarkInfoList(): IModelMarkInfo[];
+    getChart(): import("../chart/interface").IChart;
+    state: ModelStateManager;
+    getState(): {
+        [key: string]: unknown;
+        layoutUpdateRank: number;
+    };
+    protected _theme?: any;
+    protected _lastLayoutRect: ILayoutRect;
+    protected _tooltipHelper: ITooltipHelper | undefined;
+    get tooltipHelper(): ITooltipHelper;
+    protected _isLayout: boolean;
+    constructor(spec: IModelSpec, option: IModelOption);
+    coordinate?: CoordinateType;
+    protected _releaseEvent(): void;
+    created(): void;
+    updateState(newState: Record<string, unknown>): Promise<void>;
+    init(option: IModelInitOption): 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;
+    release(): void;
+    updateSpec(spec: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    reInit(theme?: any): void;
+    protected _initTheme(theme?: any): void;
+    protected _mergeMarkTheme(): void;
+    protected _preprocessSpec(obj?: any): any;
+    setCurrentTheme(theme: any, noRender?: boolean): 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;
+    compileSignal(): void;
+    bindSceneNode(node: IElement): void;
+    getSceneNodes(): IElement[];
+    getSceneNodeMarks(): IVGrammarMark[];
+    protected _createMark<T extends IMark>(markInfo: IModelMarkInfo, option?: Partial<IMarkOption>): T;
+    protected _getDataIdKey(): string | ((datum: Datum) => string) | undefined;
+}

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

@@ -0,0 +1,176 @@
+import type { IBoundsLike } from '@visactor/vutils';
+import type { DataSet } from '@visactor/vdataset';
+import type { IEvent, IEventDispatcher } from '../event/interface';
+import type { IMark, IMarkRaw, IMarkStyle, MarkTypeEnum } from '../mark/interface';
+import type { RenderMode } from '../typings/spec/common';
+import type { VChart } from '../vchart-all';
+import type { IData, IElement, IMark as IVGrammarMark } from '@visactor/vgrammar';
+import type { IOrientType, IPoint, IGroupMarkSpec, ConvertToMarkStyleSpec, CoordinateType, ICommonSpec, IRect, StringOrNumber } from '../typings';
+import type { ITheme } from '../theme';
+import type { StateValueType } from '../typings/spec';
+import type { ITooltipHelper } from './tooltip-helper';
+import type { ModelStateManager } from './model-state-manager';
+import type { ICompilable, ICompilableInitOption } from '../compile/interface';
+import type { ICompilableData } from '../compile/data';
+import type { IGlobalScale } from '../scale/interface';
+import type { IChart } from '../chart/interface';
+export type ILayoutNumber = number | IPercent | ((layoutRect: ILayoutRect) => number);
+export interface ILayoutPoint {
+    x: number;
+    y: number;
+}
+export interface ILayoutRectLevel {
+    width: number;
+    height: number;
+}
+export interface ILayoutRect {
+    width: number;
+    height: number;
+}
+export type IPercent = `${number}%`;
+export type ILayoutPercent = IPercent | number;
+type ILayoutType = 'region-relative' | 'region' | 'normal' | 'absolute' | 'normal-inline';
+export type ILayoutOrientPadding = {
+    left?: ILayoutNumber;
+    right?: ILayoutNumber;
+    top?: ILayoutNumber;
+    bottom?: ILayoutNumber;
+};
+export type ILayoutPaddingSpec = ILayoutOrientPadding | ILayoutNumber | ILayoutNumber[];
+export interface ILayoutItem {
+    directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
+    layoutClip: boolean;
+    layoutType: ILayoutType;
+    layoutBindRegionID: number | number[];
+    layoutOrient: IOrientType;
+    layoutPaddingLeft: number;
+    layoutPaddingTop: number;
+    layoutPaddingRight: number;
+    layoutPaddingBottom: number;
+    layoutOffsetX: number;
+    layoutOffsetY: number;
+    layoutLevel: number;
+    layoutZIndex: number;
+    chartLayoutRect: ILayoutRect;
+    getAutoIndent: () => boolean;
+    getLayoutStartPoint: () => ILayoutPoint;
+    getLayoutRect: () => ILayoutRect;
+    getLastComputeOutBounds: () => IBoundsLike;
+    setLayoutRect: (rect: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRectLevel>) => void;
+    computeBoundsInRect: (rect: ILayoutRect) => ILayoutRect;
+    setLayoutStartPosition: (pos: Partial<IPoint>) => void;
+    absoluteLayoutInRect: (rect: IRect) => void;
+    updateLayoutAttribute: () => void;
+}
+export interface ILayoutItemSpec {
+    layoutType?: ILayoutType;
+    layoutLevel?: number;
+    orient?: IOrientType;
+    padding?: ILayoutPaddingSpec;
+    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 IModelInitOption {
+}
+export interface IModelLayoutOption {
+}
+export interface IModelEvaluateOption {
+}
+export interface IModelRenderOption {
+}
+export interface IEffect {
+    [key: string]: (e?: any) => any;
+}
+export interface IMarkTreeGroup extends Partial<IMarkStyle<IGroupMarkSpec>> {
+    type: 'group';
+    name: string;
+    marks: (IMarkTreeGroup | IMark)[];
+}
+export type IMarkTree = IMarkTreeGroup | IMark | (IMarkTreeGroup | IMark)[];
+export interface IUpdateSpecResult {
+    change: boolean;
+    reMake: boolean;
+    reRender?: boolean;
+    reSize?: boolean;
+    reCompile?: boolean;
+}
+export interface IModelProduct {
+    srData: IData;
+}
+export interface IModel extends ICompilable, ILayoutItem {
+    readonly modelType: string;
+    readonly type: string;
+    readonly specKey: string;
+    readonly id: number;
+    readonly userId?: StringOrNumber;
+    readonly event: IEvent;
+    readonly effect: IEffect;
+    readonly state: ModelStateManager;
+    getState: () => ModelStateManager['_stateMap'];
+    coordinate?: CoordinateType;
+    getOption: () => IModelOption;
+    getMarks: () => IMark[];
+    getMarkNameMap: () => Record<string, IMark>;
+    getMarkInfoList: () => IModelMarkInfo[];
+    getData: () => ICompilableData;
+    getChart: () => IChart;
+    created: () => void;
+    init: (option: IModelInitOption) => void;
+    reInit: (theme?: any) => void;
+    onLayoutStart: (layoutRect: IRect, viewRect: ILayoutRect, ctx: IModelLayoutOption) => void;
+    onLayoutEnd: (ctx: IModelLayoutOption) => void;
+    onEvaluateEnd: (ctx: IModelEvaluateOption) => void;
+    onRender: (ctx: IModelRenderOption) => void;
+    onDataUpdate: () => void;
+    updateSpec: (spec: any) => IUpdateSpecResult;
+    getSpec?: () => any;
+    getSpecIndex: () => number;
+    setCurrentTheme: (theme: any, noRender?: boolean) => void;
+    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;
+    tooltipHelper: ITooltipHelper;
+    bindSceneNode: (node: IElement) => void;
+    getSceneNodes: () => IElement[];
+    getSceneNodeMarks: () => IVGrammarMark[];
+}
+export interface IModelOption extends ICompilableInitOption {
+    eventDispatcher: IEventDispatcher;
+    dataSet: DataSet;
+    map: Map<StringOrNumber, IModel | IMark>;
+    mode: RenderMode;
+    globalInstance: VChart;
+    specIndex?: number;
+    specKey?: string;
+    getTheme?: () => ITheme;
+    getChartLayoutRect: () => IRect;
+    getChartViewRect: () => ILayoutRect;
+    getChart: () => IChart;
+    globalScale: IGlobalScale;
+    animation: boolean;
+    onError: (...args: any[]) => void;
+}
+export interface IModelConstructor {
+    new (ctx: IModelOption): IModel;
+}
+export type ILayoutModelState = ModelStateManager['_stateMap'];
+export type IModelSpec = ILayoutItemSpec & {
+    id?: StringOrNumber;
+};
+export interface IModelMarkInfo {
+    type: MarkTypeEnum | string | (MarkTypeEnum | string)[];
+    name: string;
+}
+export {};

package/build/es5/model/layout-item.d.ts

@@ -0,0 +1,54 @@
+import type { IRect, IPoint } from '../typings';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { ILayoutItem, ILayoutItemSpec, ILayoutPoint, ILayoutRect, ILayoutRectLevel } from './interface';
+import { CompilableBase } from '../compile/compilable-base';
+export declare class LayoutItem extends CompilableBase implements ILayoutItem {
+    protected _spec: ILayoutItemSpec;
+    getSpec(): any;
+    layoutClip: boolean;
+    protected _autoIndent: boolean;
+    getAutoIndent(): boolean;
+    private _layoutStartPoint;
+    getLayoutStartPoint(): ILayoutPoint;
+    private _layoutRect;
+    private _minWidth;
+    private _maxWidth;
+    private _minHeight;
+    private _maxHeight;
+    protected _layoutRectLevelMap: ILayoutRectLevel;
+    protected _lastComputeRect: ILayoutRect;
+    protected _lastComputeOutBounds: IBoundsLike;
+    getLastComputeOutBounds(): IBoundsLike;
+    protected _forceLayoutTag: boolean;
+    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'];
+    layoutZIndex: ILayoutItem['layoutZIndex'];
+    chartLayoutRect: ILayoutRect;
+    private _setLayoutAttributeFromSpec;
+    setAttrFromSpec(spec: ILayoutItemSpec, chartViewRect: ILayoutRect): void;
+    onLayoutStart(layoutRect: IRect, viewRect: ILayoutRect, _ctx: any): void;
+    private _getAbsoluteSpecValue;
+    absoluteLayoutInRect(layoutRect: IRect): void;
+    setLayoutStartPosition({ x, y }: Partial<IPoint>): void;
+    setLayoutRect({ width, height }: Partial<ILayoutRect>, levelMap?: Partial<ILayoutRectLevel>): void;
+    mergeLayoutRect({ width, height }: ILayoutRect): ILayoutRect;
+    getOrientPosAttribute(): "x" | "y";
+    getOrientSizeAttribute(): "width" | "height";
+    protected changeBoundsBySetting(bounds: IBoundsLike): IBoundsLike;
+    private _setRectInSpec;
+    computeBoundsInRect(rect: ILayoutRect): ILayoutRect;
+    boundsInRect(rect: ILayoutRect, fullSpace: ILayoutRect): IBoundsLike;
+    updateLayoutAttribute(): void;
+    compile(): void;
+}