@visactor/vchart-types 0.10.0-alpha.2

package/types/compile/data/compilable-data.d.ts

@@ -0,0 +1,23 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IData as IVGrammarData } from '@visactor/vgrammar-core';
+import { GrammarItem } from '../grammar-item';
+import type { Maybe } from '../../typings';
+import type { ICompilableData } from './interface';
+import type { GrammarItemInitOption } from '../interface';
+import { GrammarType } from '../interface/compilable-item';
+export declare class CompilableData extends GrammarItem implements ICompilableData {
+    readonly grammarType = GrammarType.data;
+    protected _product: Maybe<IVGrammarData>;
+    getProduct: () => Maybe<IVGrammarData>;
+    protected _data: Maybe<DataView>;
+    getDataView(): DataView;
+    setDataView(d?: DataView): void;
+    getLatestData(): any;
+    constructor(option: GrammarItemInitOption, dataView?: DataView);
+    release(): void;
+    updateData(noRender?: boolean): void;
+    protected _compileProduct(): void;
+    protected _initProduct(data: any[]): void;
+    generateProductId(): string;
+    protected _lookupGrammar(id: string): IVGrammarData;
+}

package/types/compile/data/index.d.ts

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

package/types/compile/data/interface.d.ts

@@ -0,0 +1,8 @@
+import type { DataView } from '@visactor/vdataset';
+import type { IGrammarItem } from '../interface';
+export interface ICompilableData extends IGrammarItem {
+    getDataView: () => DataView;
+    setDataView: (d?: DataView) => void;
+    getLatestData: () => any[];
+    updateData: (noRender?: boolean) => void;
+}

package/types/compile/grammar-item.d.ts

@@ -0,0 +1,24 @@
+import type { IGrammarBase } from '@visactor/vgrammar-core';
+import type { Maybe } from '../typings';
+import { CompilableBase } from './compilable-base';
+import type { GrammarItemCompileOption, GrammarType, IGrammarItem, GrammarItemInitOption } from './interface';
+export declare abstract class GrammarItem extends CompilableBase implements IGrammarItem {
+    grammarType: GrammarType;
+    protected _option: GrammarItemInitOption;
+    readonly id: number;
+    protected _product: Maybe<IGrammarBase>;
+    getProduct(): IGrammarBase;
+    protected abstract _lookupGrammar(id: string): IGrammarBase;
+    protected _compiledProductId: string;
+    abstract generateProductId(): string;
+    getProductId(): string;
+    protected _depend: IGrammarItem[];
+    getDepend(): IGrammarItem[];
+    setDepend(...depend: IGrammarItem[]): void;
+    compile(option?: GrammarItemCompileOption): void;
+    protected abstract _compileProduct(option?: GrammarItemCompileOption): void;
+    protected _afterCompile(option?: GrammarItemCompileOption): void;
+    updateDepend(): boolean;
+    release(): void;
+    removeProduct(reserveVGrammarModel?: boolean): void;
+}

package/types/compile/interface/compilable-item.d.ts

@@ -0,0 +1,36 @@
+import type { IGroupMark, IGrammarBase, IView } from '@visactor/vgrammar-core';
+import type { Compiler } from '../compiler';
+import type { Maybe, IPerformanceHook } from '../../typings';
+export interface ICompilable {
+    getCompiler: () => Compiler;
+    getVGrammarView: () => IView;
+    compile: () => void;
+    compileMarks?: (group?: string | IGroupMark) => void;
+    compileData?: () => void;
+    compileSignal?: () => void;
+    clear?: () => void;
+    afterCompile?: () => void;
+    release: () => void;
+}
+export interface ICompilableInitOption {
+    getCompiler: () => Compiler;
+    performanceHook?: IPerformanceHook;
+}
+export declare enum GrammarType {
+    data = "data",
+    signal = "signal",
+    mark = "mark"
+}
+export interface IGrammarItem extends ICompilable {
+    id: number;
+    grammarType: GrammarType;
+    getProduct: () => Maybe<IGrammarBase>;
+    generateProductId: () => string;
+    getProductId: () => string;
+    removeProduct: (reserveVGrammarModel?: boolean) => void;
+    getDepend: () => IGrammarItem[];
+    setDepend: (...depend: IGrammarItem[]) => void;
+    updateDepend: () => boolean;
+}
+export type GrammarItemInitOption = ICompilableInitOption;
+export type GrammarItemCompileOption = Record<string, any>;

package/types/compile/interface/compiler.d.ts

@@ -0,0 +1,57 @@
+import type { IColor, IStageParams, IStage, ILayer } from '@visactor/vrender-core';
+import type { EventSourceType, EventType } from '../../event/interface';
+import type { RenderMode } from '../../typings/spec/common';
+import type { IBoundsLike } from '@visactor/vutils';
+import type { GrammarType, IGrammarItem } from './compilable-item';
+import type { StringOrNumber } from '../../typings';
+export interface IRenderContainer {
+    dom?: HTMLElement | 'none';
+    canvas?: HTMLCanvasElement | string;
+}
+export type IOptimizeType = {
+    skipRenderWithOutRange?: boolean;
+    disableCheckGraphicWidthOutRange?: boolean;
+};
+export interface IRenderOption {
+    mode?: RenderMode;
+    modeParams?: {
+        tooltipCanvasId?: StringOrNumber;
+        [key: string]: any;
+    } | unknown;
+    dpr?: number;
+    interactive?: boolean;
+    viewBox?: IBoundsLike;
+    canvasControled?: boolean;
+    stage?: IStage;
+    layer?: ILayer;
+    beforeRender?: IStageParams['beforeRender'];
+    afterRender?: IStageParams['afterRender'];
+    background?: IColor;
+    logLevel?: number;
+    onError?: (...args: any[]) => void;
+    disableDirtyBounds?: boolean;
+    enableView3dTransform?: boolean;
+    pluginList?: string[];
+    optimize?: IOptimizeType;
+    enableHtmlAttribute?: boolean;
+    supportsTouchEvents?: boolean;
+    supportsPointerEvents?: boolean;
+}
+export type CompilerListenerParameters = {
+    type: EventType;
+    event: Event;
+    source: EventSourceType;
+    item: any | null;
+    datum: any | null;
+    markId: number | null;
+    modelId: number | null;
+    markUserId: StringOrNumber | null;
+    modelUserId: StringOrNumber | null;
+};
+export type CompilerModel = Record<GrammarType, IProductMap<IGrammarItem>>;
+export interface IProductMap<T extends IGrammarItem> {
+    [productId: string]: IGrammarItemMap<T>;
+}
+export interface IGrammarItemMap<T extends IGrammarItem> {
+    [id: number]: T;
+}

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

@@ -0,0 +1,2 @@
+export * from './compilable-item';
+export * from './compiler';

package/types/compile/mark/compilable-mark.d.ts

@@ -0,0 +1,116 @@
+import type { IGroupMark, IMark, MarkAnimationSpec, MarkFunctionCallback, Nil, TransformSpec } from '@visactor/vgrammar-core';
+import type { DataView } from '@visactor/vdataset';
+import { GrammarItem } from '../grammar-item';
+import type { Maybe, Datum, StringOrNumber } from '../../typings';
+import type { IMarkProgressiveConfig, IMarkStateStyle, MarkType } from '../../mark/interface';
+import type { IModel } from '../../model/interface';
+import { MarkStateManager } from './mark-state-manager';
+import type { ICompilableMark, IMarkDataInitOption, ICompilableMarkOption, StateValueType, IMarkCompileOption, IAttributeOpt } from './interface';
+import { MarkData } from './mark-data';
+import { GrammarType } from '../interface/compilable-item';
+import type { IEvent } from '../../event/interface';
+import type { ICustomPath2D } from '@visactor/vrender-core';
+export declare abstract class CompilableMark extends GrammarItem implements ICompilableMark {
+    readonly grammarType = GrammarType.mark;
+    readonly type: MarkType;
+    readonly name: string;
+    readonly key: ICompilableMark['key'];
+    protected _skipTheme?: boolean;
+    getSkipTheme(): boolean;
+    setSkipTheme(skipTheme: boolean): void;
+    protected _support3d?: boolean;
+    getSupport3d(): boolean;
+    setSupport3d(support3d: boolean): void;
+    protected _facet?: string;
+    getFacet(): string;
+    setFacet(facet: string): void;
+    protected _interactive: boolean;
+    getInteractive(): boolean;
+    setInteractive(interactive: boolean): void;
+    protected _zIndex: number;
+    getZIndex(): number;
+    setZIndex(zIndex: number): void;
+    protected _visible: boolean;
+    getVisible(): boolean;
+    setVisible(visible: boolean): void;
+    protected _userId: StringOrNumber;
+    getUserId(): StringOrNumber;
+    setUserId(userId: StringOrNumber): void;
+    readonly model: IModel;
+    protected _data: Maybe<MarkData>;
+    getDataView(): DataView | undefined;
+    setDataView(d?: DataView, productId?: string): void;
+    getData(): MarkData;
+    setData(d?: MarkData): void;
+    stateStyle: IMarkStateStyle<any>;
+    state: MarkStateManager;
+    protected _unCompileChannel: {
+        [key in string]: boolean;
+    };
+    hasState(state: string): boolean;
+    getState(state: string): unknown;
+    protected _event: IEvent;
+    protected _animationConfig: Partial<MarkAnimationSpec>;
+    getAnimationConfig(): Partial<MarkAnimationSpec>;
+    setAnimationConfig(config: Partial<MarkAnimationSpec>): void;
+    private _skipBeforeLayouted;
+    setSkipBeforeLayouted(skip: boolean): void;
+    getSkipBeforeLayouted(): boolean;
+    protected _morph: boolean;
+    getMorph(): boolean;
+    setMorph(morph: boolean): void;
+    protected _morphKey?: string;
+    getMorphKey(): string;
+    setMorphKey(morphKey: string): void;
+    protected _morphElementKey?: string;
+    getMorphElementKey(): string;
+    setMorphElementKey(key: string): void;
+    protected _groupKey?: string;
+    getGroupKey(): string;
+    setGroupKey(groupKey: string): void;
+    protected _progressiveConfig: IMarkProgressiveConfig;
+    getProgressiveConfig(): IMarkProgressiveConfig;
+    setProgressiveConfig(config: IMarkProgressiveConfig): void;
+    protected _setCustomizedShape?: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D;
+    setCustomizedShapeCallback(callback: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D): void;
+    protected _enableSegments: boolean;
+    setEnableSegments(enable: boolean): void;
+    protected _stateSort?: (stateA: string, stateB: string) => number;
+    setStateSortCallback(stateSort: (stateA: string, stateB: string) => number): void;
+    protected _option: ICompilableMarkOption;
+    constructor(option: ICompilableMarkOption, name: string, model: IModel);
+    protected _product: Maybe<IMark>;
+    getProduct: () => Maybe<IMark>;
+    protected _transform: TransformSpec[] | Nil;
+    setTransform(transform: TransformSpec[] | Nil): void;
+    protected initMarkData(option: IMarkDataInitOption): void;
+    protected stateKeyToSignalName(key: string): string;
+    getAttribute(key: any, datum: any, state: StateValueType, opt?: IAttributeOpt): void;
+    protected _compileProduct(option?: IMarkCompileOption): void;
+    protected _initProduct(group?: string | IGroupMark): void;
+    generateProductId(): string;
+    compileData(): void;
+    updateStaticEncode(): void;
+    protected _separateStyle(): {
+        enterStyles: Record<string, any>;
+        updateStyles: Record<string, any>;
+    };
+    compileEncode(): void;
+    compileState(): void;
+    compileAnimation(): void;
+    compileContext(): void;
+    compileSignal(): void;
+    protected _computeAttribute(key: string, state: StateValueType): (datum: Datum, opt: IAttributeOpt) => any;
+    protected compileCommonAttributeCallback(key: string, state: string): MarkFunctionCallback<any>;
+    protected compileTransform(): void;
+    protected _lookupGrammar(id: string): IMark;
+    updateState(newState: Record<string, unknown>, noRender?: boolean): void;
+    updateLayoutState(noRender?: boolean, recursion?: boolean): void;
+    updateMarkState(key: string): void;
+    getMarks(): ICompilableMark[];
+    runAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimateArranger;
+    stopAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimate;
+    pauseAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimate;
+    resumeAnimationByState(state?: string): import("@visactor/vgrammar-core").IAnimate;
+    release(): void;
+}

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

@@ -0,0 +1,3 @@
+export * from './interface';
+export * from './compilable-mark';
+export * from './mark-state-manager';

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

@@ -0,0 +1,147 @@
+import type { IMarkProgressiveConfig, IMarkStateStyle, MarkType } from '../../mark/interface';
+import type { IModel } from '../../model/interface';
+import type { GrammarItemCompileOption, GrammarItemInitOption } from '../interface';
+import type { IGrammarItem } from '../interface';
+import type { MarkStateManager } from './mark-state-manager';
+import type { DataView } from '@visactor/vdataset';
+import type { IAnimate, IAnimateArranger, IElement, IGroupMark, IMark, MarkAnimationSpec, Nil, TransformSpec } from '@visactor/vgrammar-core';
+import type { Maybe, Datum, StringOrNumber } from '../../typings';
+import type { MarkData } from './mark-data';
+import type { IRegion } from '../../region/interface';
+import type { ICustomPath2D } from '@visactor/vrender-core';
+export interface ICompilableMarkOption extends GrammarItemInitOption {
+    key?: string | ((datum: Datum) => string);
+    groupKey?: string;
+    skipBeforeLayouted?: boolean;
+    support3d?: boolean;
+    mode?: '2d' | '3d';
+    skipTheme?: boolean;
+    noSeparateStyle?: boolean;
+}
+export interface ICompilableMark extends IGrammarItem {
+    readonly type: MarkType;
+    readonly id: number;
+    readonly name: string;
+    readonly key?: string | ((datum: Datum) => string);
+    readonly model: IModel;
+    getData: () => MarkData | undefined;
+    setData: (d: MarkData) => void;
+    getDataView: () => DataView | undefined;
+    setDataView: (d?: DataView, productId?: string) => void;
+    getFacet: () => string | undefined;
+    setFacet: (facet: string) => void;
+    state: MarkStateManager;
+    readonly stateStyle: IMarkStateStyle<any>;
+    hasState: (state: string) => boolean;
+    getState: (state: string) => any;
+    updateState: (newState: Record<string, unknown>) => void;
+    updateStaticEncode: () => void;
+    compileEncode: () => void;
+    updateLayoutState: (noRender?: boolean, recursion?: boolean) => void;
+    updateMarkState: (key: string) => void;
+    setTransform: (transform: TransformSpec[] | Nil) => void;
+    getInteractive: () => boolean;
+    setInteractive: (interactive: boolean) => void;
+    setAnimationConfig: (config: Partial<MarkAnimationSpec>) => void;
+    getAnimationConfig: () => Partial<MarkAnimationSpec>;
+    getZIndex: () => number;
+    setZIndex: (zIndex: number) => void;
+    getVisible: () => boolean;
+    setVisible: (visible: boolean) => void;
+    getMorph: () => boolean;
+    setMorph: (morph: boolean) => void;
+    getProgressiveConfig: () => IMarkProgressiveConfig;
+    setProgressiveConfig: (config: IMarkProgressiveConfig) => void;
+    getMorphKey: () => string | undefined;
+    setMorphKey: (morphKey: string) => void;
+    getMorphElementKey: () => string | undefined;
+    setMorphElementKey: (morphKey: string) => void;
+    getGroupKey: () => string | undefined;
+    setGroupKey: (groupKey: string) => void;
+    getUserId: () => StringOrNumber | undefined;
+    setUserId: (id: StringOrNumber) => void;
+    getSupport3d: () => boolean | undefined;
+    setSupport3d: (support3d: boolean) => void;
+    compile: (option?: IMarkCompileOption) => void;
+    getProduct: () => Maybe<IMark>;
+    getMarks: () => ICompilableMark[];
+    setSkipBeforeLayouted: (skip: boolean) => void;
+    getSkipBeforeLayouted: () => boolean;
+    setCustomizedShapeCallback: (callback: (datum: any[], attrs: any, path: ICustomPath2D) => ICustomPath2D) => void;
+    setStateSortCallback: (stateSort: (stateA: string, stateB: string) => number) => void;
+    runAnimationByState: (animationState?: string) => IAnimateArranger;
+    stopAnimationByState: (animationState?: string) => IAnimate;
+    pauseAnimationByState: (animationState: string) => IAnimate;
+    resumeAnimationByState: (animationState: string) => IAnimate;
+}
+export interface IMarkDataInitOption extends ICompilableMarkOption {
+    mark: ICompilableMark;
+}
+export interface IMarkCompileOption extends GrammarItemCompileOption {
+    group?: string | IGroupMark;
+    ignoreChildren?: boolean;
+}
+export interface IStateInfo {
+    stateValue: StateValue;
+    fields?: any | null | undefined;
+    datums?: any[] | null | undefined;
+    datumKeys?: string[] | null | undefined;
+    items?: any[] | null | undefined;
+    filter?: ((datum: any, options: Record<string, any>) => boolean) | null | undefined;
+    cache?: {
+        [key: string]: {
+            [key: string]: boolean;
+        };
+    };
+    level?: number | undefined;
+}
+export interface IStateSpec {
+    stateValue: StateValue;
+    datums?: any[] | null | undefined;
+    datumKeys?: string[] | null | undefined;
+    level?: number | undefined;
+}
+export interface IMarkState {
+    readonly id: number;
+    getStates: () => IStateInfo[];
+    getState: (stateValue: StateValue) => IStateInfo | undefined;
+    addState: (stateInfo: IStateInfo) => void;
+    changeState: (stateInfo: Partial<IStateInfo>, update?: boolean) => void;
+    checkState: (item: any, datum: any) => string[];
+    clearState: (stateValues: StateValue[], update?: boolean) => void;
+    update: () => void;
+}
+export declare enum STATE_VALUE_ENUM {
+    STATE_NORMAL = "normal",
+    STATE_HOVER = "hover",
+    STATE_HOVER_REVERSE = "hover_reverse",
+    STATE_DIMENSION_HOVER = "dimension_hover",
+    STATE_DIMENSION_HOVER_REVERSE = "dimension_hover_reverse",
+    STATE_SELECTED = "selected",
+    STATE_SELECTED_REVERSE = "selected_reverse"
+}
+export declare enum STATE_VALUE_ENUM_REVERSE {
+    STATE_HOVER_REVERSE = "hover_reverse",
+    STATE_DIMENSION_HOVER_REVERSE = "dimension_hover_reverse",
+    STATE_SELECTED_REVERSE = "selected_reverse"
+}
+export type STATE_NORMAL = typeof STATE_VALUE_ENUM.STATE_NORMAL;
+export type STATE_HOVER = typeof STATE_VALUE_ENUM.STATE_HOVER;
+export type STATE_HOVER_REVERSE = typeof STATE_VALUE_ENUM.STATE_HOVER_REVERSE;
+export type STATE_CUSTOM = string;
+export type StateValueNot = STATE_HOVER_REVERSE | STATE_CUSTOM;
+export type StateValue = STATE_NORMAL | STATE_HOVER | STATE_CUSTOM;
+export type StateValueType = StateValue | StateValueNot;
+export interface IAttributeOpt {
+    element: IElement;
+    mark: IElement['mark'];
+    parent: IElement['mark']['group'];
+}
+export interface IModelMarkAttributeContext {
+    [key: string]: unknown;
+}
+export interface ISeriesMarkAttributeContext extends IModelMarkAttributeContext {
+    globalScale: (scaleKey: string, value: string | number) => unknown;
+    seriesColor: (seriesValue?: string | number) => string;
+    getRegion: () => IRegion;
+}

package/types/compile/mark/mark-data.d.ts

@@ -0,0 +1,9 @@
+import { CompilableData } from '../data/compilable-data';
+import type { ICompilableMark, IMarkDataInitOption } from './interface';
+export declare class MarkData extends CompilableData {
+    protected _mark: ICompilableMark;
+    constructor(option: IMarkDataInitOption);
+    setCompiledProductId(name: string): void;
+    generateProductId(): string;
+    protected _compileProduct(): void;
+}

package/types/compile/mark/mark-state-manager.d.ts

@@ -0,0 +1,26 @@
+import type { IElement, IMark as IVGrammarMark } from '@visactor/vgrammar-core';
+import type { Datum, StringOrNumber } from '../../typings';
+import type { IStateManagerOption } from '../signal/interface';
+import { StateManager } from '../signal/state-manager';
+import type { CompilableMark } from './compilable-mark';
+import type { IStateInfo, StateValue } from './interface';
+export declare class MarkStateManager extends StateManager {
+    protected _mark: CompilableMark;
+    private _stateInfoList;
+    getStateInfoList(): IStateInfo[];
+    constructor(option: IStateManagerOption, mark: CompilableMark);
+    protected _getDefaultStateMap(): Record<string, unknown>;
+    getStateInfo(stateValue: StateValue): IStateInfo;
+    addStateInfo(stateInfo: IStateInfo): void;
+    private _clearStateBeforeSet;
+    changeStateInfo(stateInfo: Partial<IStateInfo>): void;
+    clearStateInfo(stateValues: StateValue[]): void;
+    checkOneState(renderNode: IElement, datum: Datum | Datum[], state: IStateInfo, isMultiMark?: boolean): 'in' | 'out' | 'skip';
+    checkState(renderNode: IElement, datum: Datum | Datum[]): StateValue[];
+    checkDatumState(state: IStateInfo, datum: Datum | Datum[], isMultiMark: boolean): boolean;
+    checkItemsState(state: IStateInfo, item: any): boolean | undefined;
+    checkFieldsState(state: IStateInfo, datum: Datum | Datum[], item: any, isMultiMark: boolean): boolean;
+    checkLinearFieldState(domain: StringOrNumber[], key: string, datum: any, item: any, isMultiMark: boolean): boolean;
+    updateLayoutState(noRender?: boolean): void;
+    compileState(product: IVGrammarMark, stateSort?: (stateA: string, stateB: string) => number): void;
+}

package/types/compile/mark/util.d.ts

@@ -0,0 +1,5 @@
+import type { IAttrs, IMarkStateStyle } from '../../mark/interface';
+export declare function isAttrChangeable<T>(key: string, stateStyle: IMarkStateStyle<T>): boolean;
+export declare function isStateAttrChangeable<T>(key: string, stateStyle: Partial<IAttrs<T>>, facetField: string): boolean;
+export declare function stateInDefaultEnum(state: string): boolean;
+export declare function stateToReverse(state: string): any;

package/types/compile/signal/compilable-signal.d.ts

@@ -0,0 +1,21 @@
+import type { ISignal, SignalFunctionType } from '@visactor/vgrammar-core';
+import { GrammarItem } from '../grammar-item';
+import type { Maybe } from '../../typings';
+import type { GrammarItemInitOption } from '../interface';
+import { GrammarType } from '../interface/compilable-item';
+import type { ICompilableSignal } from './interface';
+export declare class CompilableSignal<T> extends GrammarItem implements ICompilableSignal<T> {
+    readonly grammarType = GrammarType.signal;
+    protected _product: Maybe<ISignal<T>>;
+    getProduct: () => Maybe<ISignal<T>>;
+    readonly name: string;
+    protected _value: Maybe<T>;
+    getValue(): T;
+    protected _updateFunc: Maybe<SignalFunctionType<T>>;
+    getUpdateFunc(): SignalFunctionType<T>;
+    constructor(option: GrammarItemInitOption, name: string, value?: T, updateFunc?: SignalFunctionType<T>);
+    updateSignal(value?: T, updateFunc?: SignalFunctionType<T>): void;
+    protected _compileProduct(): void;
+    generateProductId(): string;
+    protected _lookupGrammar(id: string): ISignal<unknown>;
+}

package/types/compile/signal/index.d.ts

@@ -0,0 +1,4 @@
+export * from './compilable-signal';
+export * from './interface';
+export * from './signal-manager';
+export * from './state-manager';

package/types/compile/signal/interface.d.ts

@@ -0,0 +1,12 @@
+import type { SignalFunctionType } from '@visactor/vgrammar-core';
+import type { Maybe } from '../../typings';
+import type { IGrammarItem, ICompilableInitOption } from '../interface';
+export interface IStateManagerOption extends ICompilableInitOption {
+    stateKeyToSignalName?: (key: string) => string;
+}
+export type StateValueMap = Record<string, unknown>;
+export interface ICompilableSignal<T> extends IGrammarItem {
+    updateSignal: (value?: T, updateFunc?: SignalFunctionType<T>) => void;
+    getValue: () => Maybe<T>;
+    getUpdateFunc: () => Maybe<SignalFunctionType<T>>;
+}

package/types/compile/signal/signal-manager.d.ts

@@ -0,0 +1,11 @@
+import type { SignalFunctionType } from '@visactor/vgrammar-core';
+import { CompilableSignal } from './compilable-signal';
+import { CompilableBase } from '../compilable-base';
+export declare class SignalManager extends CompilableBase {
+    protected _signalMap: Record<string, CompilableSignal<any>>;
+    getSignalMap(): Record<string, CompilableSignal<any>>;
+    getSignal(name: string): CompilableSignal<any>;
+    updateSignal(name: string, value: any, updateFunc?: SignalFunctionType<any>): void;
+    compile(): void;
+    release(): void;
+}

package/types/compile/signal/state-manager.d.ts

@@ -0,0 +1,12 @@
+import type { IStateManagerOption, StateValueMap } from './interface';
+import { SignalManager } from './signal-manager';
+export declare class StateManager extends SignalManager {
+    protected _stateMap: StateValueMap;
+    getStateMap(): StateValueMap;
+    protected _getDefaultStateMap(): StateValueMap;
+    protected stateKeyToSignalName: (key: string) => string;
+    constructor(option: IStateManagerOption);
+    initStateMap(state?: StateValueMap): void;
+    compile(stateMap?: StateValueMap): void;
+    updateState(newState: Partial<StateValueMap>, noRender?: boolean): void;
+}

package/types/compile/util.d.ts

@@ -0,0 +1,2 @@
+import type { RenderMode } from '../typings/spec';
+export declare function toRenderMode(mode: RenderMode): any;