@visactor/vchart 1.2.0-beta.7 → 1.2.0

package/build/es5/compile/compiler.d.ts

@@ -1,56 +0,0 @@
-import type { IView } from '@visactor/vgrammar';
-import type { CompilerListenerParameters, CompilerModel, IGrammarItem, IRenderContainer, IRenderOption } from './interface';
-import type { IBoundsLike } from '@visactor/vutils';
-import type { EventSourceType } from '../event/interface';
-import type { IChart } from '../chart/interface';
-import type { VChart } from '../core/vchart';
-import type { Stage } from '@visactor/vrender';
-import type { IMorphConfig } from '../animation/spec';
-type EventListener = {
-    type: string;
-    callback: (...args: any[]) => void;
-};
-export declare class Compiler {
-    protected _view: IView;
-    getVGrammarView(): IView;
-    protected _viewListeners: Map<(...args: any[]) => any, EventListener>;
-    protected _windowListeners: Map<(...args: any[]) => any, EventListener>;
-    isInited: boolean;
-    isReleased: boolean;
-    protected _width: number;
-    protected _height: number;
-    protected _container: IRenderContainer;
-    protected _option: IRenderOption;
-    protected _model: CompilerModel;
-    getModel(): CompilerModel;
-    private _compileChart;
-    private _rafId;
-    constructor(container: IRenderContainer, option: IRenderOption);
-    getRenderer(): import("@visactor/vgrammar/es/types/renderer").IRenderer;
-    getCanvas(): HTMLCanvasElement | undefined;
-    getStage(): Stage | undefined;
-    initView(): void;
-    private _setCanvasStyle;
-    compile(ctx: {
-        chart: IChart;
-        vChart: VChart;
-    }, option: any): void;
-    renderAsync(morphConfig?: IMorphConfig): Promise<any>;
-    renderSync(morphConfig?: IMorphConfig): void;
-    updateViewBox(viewBox: IBoundsLike, reRender?: boolean): void;
-    resize(width: number, height: number): Promise<void>;
-    reRenderAsync(morphConfig?: IMorphConfig): Promise<void>;
-    setSize(width: number, height: number): void;
-    setViewBox(viewBox: IBoundsLike, reRender?: boolean): void;
-    addEventListener(source: EventSourceType, type: string, callback: (params: CompilerListenerParameters) => void): void;
-    removeEventListener(source: EventSourceType, type: string, callback: (params: CompilerListenerParameters) => void): void;
-    protected releaseEvent(): void;
-    release(): void;
-    releaseGrammar(): void;
-    protected _releaseModel(): void;
-    addGrammarItem(grammarItem: IGrammarItem): void;
-    removeGrammarItem(grammarItem: IGrammarItem, reserveVGrammarModel?: boolean): void;
-    updateDepend(items?: IGrammarItem[]): boolean;
-    private _getGlobalThis;
-}
-export {};

package/build/es5/compile/data/compilable-data.d.ts

@@ -1,23 +0,0 @@
-import type { DataView } from '@visactor/vdataset';
-import type { IData as IVGrammarData } from '@visactor/vgrammar';
-import { GrammarItem } from '../grammar-item';
-import type { Maybe } from '../../typings';
-import type { ICompilableData } from './interface';
-import type { GrammarItemInitOption } from '../interface';
-import { GrammarType } from '../interface';
-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): Promise<void>;
-    protected _compileProduct(): void;
-    protected _initProduct(data: any[]): void;
-    generateProductId(): string;
-    protected _lookupGrammar(id: string): IVGrammarData;
-}

package/build/es5/compile/data/index.d.ts

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

package/build/es5/compile/data/interface.d.ts

@@ -1,8 +0,0 @@
-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) => Promise<any>;
-}

package/build/es5/compile/grammar-item.d.ts

@@ -1,24 +0,0 @@
-import type { IGrammarBase } from '@visactor/vgrammar';
-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/build/es5/compile/interface/compilable-item.d.ts

@@ -1,35 +0,0 @@
-import type { IGroupMark, IGrammarBase, IView } from '@visactor/vgrammar';
-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;
-    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/build/es5/compile/interface/compiler.d.ts

@@ -1,49 +0,0 @@
-import type { IColor, IStageParams, IStage, ILayer } from '@visactor/vrender';
-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 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[];
-}
-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/build/es5/compile/interface/index.d.ts

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

package/build/es5/compile/mark/compilable-mark.d.ts

@@ -1,104 +0,0 @@
-import type { IGroupMark, IMark, MarkAnimationSpec, MarkFunctionCallback, Nil, TransformSpec } from '@visactor/vgrammar';
-import type { DataView } from '@visactor/vdataset';
-import { GrammarItem } from '../grammar-item';
-import type { Maybe, 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';
-import type { IEvent } from '../../event/interface';
-import type { ILabelSpec } from '../../component/label';
-export declare abstract class CompilableMark extends GrammarItem implements ICompilableMark {
-    readonly grammarType = GrammarType.mark;
-    readonly type: MarkType;
-    readonly name: string;
-    readonly key: ICompilableMark['key'];
-    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 _label?: ILabelSpec;
-    getLabelSpec(): ILabelSpec;
-    setLabelSpec(label: ILabelSpec): void;
-    protected _progressiveConfig: IMarkProgressiveConfig;
-    getProgressiveConfig(): IMarkProgressiveConfig;
-    setProgressiveConfig(config: IMarkProgressiveConfig): 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;
-    compileEncode(): void;
-    compileState(): void;
-    compileAnimation(): void;
-    compileContext(): void;
-    compileSignal(): void;
-    protected compileCommonAttributeCallback(key: string, state: string): MarkFunctionCallback<any>;
-    protected compileTransform(): void;
-    protected _lookupGrammar(id: string): IMark;
-    updateState(newState: Record<string, unknown>, noRender?: boolean): Promise<void>;
-    updateLayoutState(noRender?: boolean, recursion?: boolean): Promise<void>;
-    updateMarkState(key: string): void;
-    getMarks(): ICompilableMark[];
-    runAnimationByState(state?: string): import("@visactor/vgrammar").IAnimateArranger;
-    stopAnimationByState(state?: string): import("@visactor/vgrammar").IAnimate;
-    pauseAnimationByState(state?: string): import("@visactor/vgrammar").IAnimate;
-    resumeAnimationByState(state?: string): import("@visactor/vgrammar").IAnimate;
-    release(): void;
-}

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

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

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

@@ -1,149 +0,0 @@
-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';
-import type { Maybe, Datum, StringOrNumber } from '../../typings';
-import type { MarkData } from './mark-data';
-import type { ILabelSpec } from '../../component/label';
-export interface ICompilableMarkOption extends GrammarItemInitOption {
-    key?: string | ((datum: Datum) => string);
-    groupKey?: string;
-    skipBeforeLayouted?: boolean;
-    support3d?: boolean;
-    mode?: '2d' | '3d';
-}
-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;
-    getLabelSpec: () => ILabelSpec;
-    setLabelSpec: (label: ILabelSpec) => void;
-    state: MarkStateManager;
-    readonly stateStyle: IMarkStateStyle<any>;
-    hasState: (state: string) => boolean;
-    getState: (state: string) => any;
-    updateState: (newState: Record<string, unknown>) => Promise<void>;
-    updateLayoutState: (noRender?: boolean, recursion?: boolean) => Promise<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;
-    compile: (option?: IMarkCompileOption) => void;
-    getProduct: () => Maybe<IMark>;
-    getMarks: () => ICompilableMark[];
-    setSkipBeforeLayouted: (skip: boolean) => void;
-    getSkipBeforeLayouted: () => boolean;
-    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 declare enum STATE_LEVEL {
-    NORMAL = 0,
-    DIMENSION_SELECTED = 1,
-    RELATIONAL_SELECTED = 2,
-    SELECTED = 3,
-    DIMENSION_HOVER = 4,
-    RELATIONAL_HOVER = 5,
-    HOVER = 6
-}
-export interface IAttributeOpt {
-    element: IElement;
-    mark: IElement['mark'];
-    parent: IElement['mark']['group'];
-    states: string[];
-}
-export interface IModelMarkAttributeContext {
-    [key: string]: unknown;
-}
-export interface ISeriesMarkAttributeContext extends IModelMarkAttributeContext {
-    globalScale: (scaleKey: string, value: string | number) => unknown;
-    seriesColor: (seriesValue?: string | number) => string;
-}

package/build/es5/compile/mark/mark-data.d.ts

@@ -1,9 +0,0 @@
-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/build/es5/compile/mark/mark-state-manager.d.ts

@@ -1,26 +0,0 @@
-import type { IElement, IMark as IVGrammarMark } from '@visactor/vgrammar';
-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): Promise<void>;
-    compileState(product: IVGrammarMark): void;
-}

package/build/es5/compile/mark/util.d.ts

@@ -1,6 +0,0 @@
-import type { IAttrs, IMarkStateStyle, MarkType } 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>>): boolean;
-export declare function attrTransform(type: MarkType, attr: string, value: any): any;
-export declare function stateInDefaultEnum(state: string): boolean;
-export declare function stateToReverse(state: string): any;

package/build/es5/compile/signal/compilable-signal.d.ts

@@ -1,21 +0,0 @@
-import type { ISignal, SignalFunctionType } from '@visactor/vgrammar';
-import { GrammarItem } from '../grammar-item';
-import type { Maybe } from '../../typings';
-import type { GrammarItemInitOption } from '../interface';
-import { GrammarType } from '../interface';
-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/build/es5/compile/signal/index.d.ts

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

package/build/es5/compile/signal/interface.d.ts

@@ -1,12 +0,0 @@
-import type { SignalFunctionType } from '@visactor/vgrammar';
-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/build/es5/compile/signal/signal-manager.d.ts

@@ -1,11 +0,0 @@
-import type { SignalFunctionType } from '@visactor/vgrammar';
-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/build/es5/compile/signal/state-manager.d.ts

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

package/build/es5/compile/util.d.ts

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