@visactor/vgrammar-core 0.7.0

package/cjs/types/data.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});

package/cjs/types/data.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/data.ts"],"names":[],"mappings":"","file":"data.js","sourcesContent":["import type { GrammarSpec, IData } from './grammar';\nimport type { GenericFunctionType, ParameterFunctionType } from './signal';\nimport type { TransformSpec } from './transform';\n\nexport type Datum = any;\n\nexport type DataFunctionCallback<T> = (datum: any, parameters: any) => T;\n\nexport type DataFunctionType<T> = GenericFunctionType<DataFunctionCallback<T>, T>;\n\nexport type DataType = 'boolean' | 'number' | 'date' | 'string';\nexport type DataParseSpec =\n  | 'auto'\n  | {\n      [f: string]: DataType | string;\n    };\nexport interface FormatJSONSpec {\n  type: 'json';\n  parse?: DataParseSpec;\n  property?: string;\n  copy?: boolean;\n}\nexport interface FormatSVSpec {\n  type: 'csv' | 'tsv';\n  header?: string[];\n  parse?: DataParseSpec;\n}\nexport interface FormatDSVSpec {\n  type: 'dsv';\n  header?: string[];\n  parse?: DataParseSpec;\n  delimiter: string;\n}\nexport type FormatTopoJSONSpec = {\n  type: 'topojson';\n  property?: string;\n} & (\n  | {\n      feature: string;\n    }\n  | {\n      mesh: string;\n      filter: 'interior' | 'exterior' | null;\n    }\n);\nexport type DataFormatSpec = FormatJSONSpec | FormatSVSpec | FormatDSVSpec;\n// | FormatTopoJSONSpec\n// | { parse: DataParseSpec };\n\nexport interface IDataFilter {\n  source?: string;\n  rank?: number;\n  filter: (data: Datum[], parameters?: any) => Datum[];\n}\n\n/** 语法元素 Data 配置 */\nexport interface DataSpec extends GrammarSpec {\n  /** 数据的唯一标识符 */\n  name?: string;\n  /** 数据变换配置 */\n  transform?: TransformSpec[];\n  /**\n   * 原始数据配置，解析优先级最高\n   */\n  values?: Datum[];\n  /**\n   * 数据url配置，解析优先级第二\n   */\n  url?: ParameterFunctionType<string>;\n  /**\n   * 数据源配置，对应的其他Data元素的name\n   */\n  source?: string | string[] | IData | IData[];\n  /**\n   * 格式化方法\n   */\n  format?: ParameterFunctionType<DataFormatSpec>;\n}\n/**\n * the type of sort\n */\nexport type SortOrderType = 'desc' | 'asc';\n\n/**\n * config of sort\n */\nexport interface SortConfigSpec {\n  /** the field to be sort */\n  field: string | string[];\n  /**\n   * the order of each field\n   */\n  order?: SortOrderType | SortOrderType[];\n}\n"]}

package/cjs/types/dataflow.d.ts

@@ -0,0 +1,13 @@
+import type { IGrammarBase } from './grammar';
+export type IDataflowCallback = (df: IDataflow) => void;
+export interface IDataflow {
+    logger: any;
+    add: (grammar: IGrammarBase) => boolean | undefined;
+    remove: (grammar: IGrammarBase) => void;
+    hasCommitted: () => boolean;
+    commit: (grammar: IGrammarBase) => this;
+    evaluate: () => Promise<boolean>;
+    evaluateSync: () => boolean;
+    runBefore: (callback?: IDataflowCallback) => void;
+    runAfter: (callback?: IDataflowCallback) => void;
+}

package/cjs/types/dataflow.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+//# sourceMappingURL=dataflow.js.map

package/cjs/types/dataflow.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/dataflow.ts"],"names":[],"mappings":"","file":"dataflow.js","sourcesContent":["import type { IGrammarBase } from './grammar';\n\nexport type IDataflowCallback = (df: IDataflow) => void;\n\n/**\n * Dataflow定义，\n */\nexport interface IDataflow {\n  logger: any;\n  add: (grammar: IGrammarBase) => boolean | undefined;\n  remove: (grammar: IGrammarBase) => void;\n  hasCommitted: () => boolean;\n  commit: (grammar: IGrammarBase) => this;\n  evaluate: () => Promise<boolean>;\n  evaluateSync: () => boolean;\n  runBefore: (callback?: IDataflowCallback) => void;\n  runAfter: (callback?: IDataflowCallback) => void;\n}\n"]}

package/cjs/types/element.d.ts

@@ -0,0 +1,117 @@
+import type { IArc, IArc3d, IArea, ICircle, IGlyph, IGraphic, IGroup, IImage, ILine, IPath, IPolygon, IPyramid3d, IRect, IRect3d, IRichText, ISymbol, IText } from '@visactor/vrender';
+import type { DiffState } from '../graph/enums';
+import type { IMark, IGlyphMark } from './grammar';
+import type { BaseEncodeSpec, IMarkConfig, MarkFunctionType, MarkKeySpec, MarkType } from './mark';
+export interface ElementGraphicMap {
+    circle: ICircle;
+    arc: IArc;
+    area: IArea;
+    image: IImage;
+    line: ILine;
+    path: IPath;
+    rule: ILine;
+    shape: IPath;
+    symbol: ISymbol;
+    text: IText;
+    richtext: IRichText;
+    polygon: IPolygon;
+    cell: ISymbol;
+    interval: IGraphic;
+    rect: IRect;
+    rect3d: IRect3d;
+    arc3d: IArc3d;
+    pyramid3d: IPyramid3d;
+    group: IGroup;
+    glyph: IGlyph;
+    linkPath: IGlyph;
+    treePath: IGlyph;
+    wave: IGlyph;
+    ripplePoint: IGlyph;
+    barBoxplot: IGlyph;
+    boxPlot: IGlyph;
+    component: IGroup;
+    axis: IGroup;
+    legend: IGroup;
+    corsshair: IGroup;
+    slider: IGroup;
+    datazoom: IGroup;
+    label: IGroup;
+    player: IGroup;
+}
+export type GetGraphicByType<T> = T extends keyof ElementGraphicMap ? ElementGraphicMap[T] : IGraphic;
+export interface MarkElementItem {
+    key: string;
+    datum: any;
+    view: any;
+    nextAttrs?: any;
+}
+export interface IElement {
+    mark: IMark;
+    isReserved: boolean;
+    diffState: DiffState;
+    key: string;
+    groupKey?: string;
+    data?: any[];
+    items: MarkElementItem[];
+    initGraphicItem: (attrs?: any) => void;
+    updateGraphicItem: (config: IMarkConfig) => void;
+    getDatum: () => any;
+    getBounds: () => any;
+    getGraphicItem: () => IGraphic;
+    getGraphicAttribute: (channel: string, prev?: boolean) => any;
+    setGraphicAttribute: (channel: string, value: any, final?: boolean) => void;
+    setGraphicAttributes: (attributes: {
+        [channel: string]: any;
+    }, final?: boolean) => void;
+    getItemAttribute: (channel?: string) => any;
+    setItemAttributes: (attributes: {
+        [channel: string]: any;
+    } | any[]) => void;
+    updateData: (groupKey: string, data: any[], keyGenerator: MarkKeySpec, view: any) => void;
+    state: (markState: MarkFunctionType<string | string[]>, parameters?: any) => void;
+    encodeItems: (items: MarkElementItem[], encoders: BaseEncodeSpec, isReentered?: boolean, parameters?: any) => void;
+    encodeGraphic: (attributes?: any) => void;
+    transformElementItems: (items: MarkElementItem[], markType: MarkType, computePoints?: boolean) => Record<string, any>;
+    remove: () => void;
+    release: () => void;
+    getFinalGraphicAttributes: () => {
+        [key: string]: any;
+    };
+    getPrevGraphicAttributes: () => {
+        [key: string]: any;
+    };
+    getNextGraphicAttributes: () => {
+        [key: string]: any;
+    };
+    clearChangedGraphicAttributes: () => void;
+    clearGraphicAttributes: () => void;
+    getStates: () => string[];
+    hasState: (state: string) => boolean;
+    clearStates: (noAnimation?: boolean) => void;
+    addState: (state: string | string[], attrs?: any) => void;
+    removeState: (state: string | string[]) => void;
+    useStates: (states: string[], noAnimation?: boolean) => void;
+}
+export interface IGlyphElement<P = any> extends IElement {
+    mark: IGlyphMark;
+    getGlyphGraphicItems: () => {
+        [markName: string]: any;
+    };
+    getGraphicAttribute: (channel: string, prev?: boolean, markName?: any) => any;
+    setGraphicAttribute: (channel: string, value: any, final?: boolean, markName?: any) => void;
+    setGraphicAttributes: (attributes: {
+        [channel: string]: any;
+    }, final?: boolean, markName?: any) => void;
+    getFinalGraphicAttributes: (markName?: string) => {
+        [key: string]: any;
+    };
+    getPrevGraphicAttributes: (markName?: string) => {
+        [key: string]: any;
+    };
+    getNextGraphicAttributes: (markName?: string) => {
+        [key: string]: any;
+    };
+    encodeCustom: (nextAttrs?: any) => {
+        [markName: string]: any;
+    };
+}

package/cjs/types/element.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+//# sourceMappingURL=element.js.map

package/cjs/types/element.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/element.ts"],"names":[],"mappings":"","file":"element.js","sourcesContent":["import type {\n  IArc,\n  IArc3d,\n  IArea,\n  ICircle,\n  IGlyph,\n  IGraphic,\n  IGroup,\n  IImage,\n  ILine,\n  IPath,\n  IPolygon,\n  IPyramid3d,\n  IRect,\n  IRect3d,\n  IRichText,\n  ISymbol,\n  IText\n} from '@visactor/vrender';\nimport type { DiffState } from '../graph/enums';\nimport type { IMark, IGlyphMark } from './grammar';\nimport type { BaseEncodeSpec, IMarkConfig, MarkFunctionType, MarkKeySpec, MarkType } from './mark';\n\nexport interface ElementGraphicMap {\n  circle: ICircle;\n  arc: IArc;\n  area: IArea;\n  image: IImage;\n  line: ILine;\n  path: IPath;\n  rule: ILine;\n  shape: IPath;\n  symbol: ISymbol;\n  text: IText;\n  richtext: IRichText;\n  polygon: IPolygon;\n  cell: ISymbol;\n  interval: IGraphic;\n  rect: IRect;\n  rect3d: IRect3d;\n  arc3d: IArc3d;\n  pyramid3d: IPyramid3d;\n  group: IGroup;\n  glyph: IGlyph;\n  linkPath: IGlyph;\n  treePath: IGlyph;\n  wave: IGlyph;\n  ripplePoint: IGlyph;\n  barBoxplot: IGlyph;\n  boxPlot: IGlyph;\n  component: IGroup;\n  axis: IGroup;\n  legend: IGroup;\n  corsshair: IGroup;\n  slider: IGroup;\n  datazoom: IGroup;\n  label: IGroup;\n  player: IGroup;\n}\n\nexport type GetGraphicByType<T> = T extends keyof ElementGraphicMap ? ElementGraphicMap[T] : IGraphic;\n\n/**\n * 保存graphicItem状态\n */\nexport interface MarkElementItem {\n  /** 唯一key */\n  key: string;\n  /** 原始数据 */\n  datum: any;\n  /** VGrammar view */\n  view: any;\n  /** 当前渲染帧下graphicItem对应的最新属性 */\n  nextAttrs?: any;\n  /** 是否初始化过，用于解决collection mark对应的item，可能跳过enter状态的问题 */\n  // hasEntered: boolean;\n}\nexport interface IElement {\n  mark: IMark;\n  isReserved: boolean;\n  diffState: DiffState;\n  key: string;\n  groupKey?: string;\n  data?: any[];\n  /**\n   * 不推荐使用，但是collection图元暂时可能回涉及到相关修改\n   */\n  items: MarkElementItem[];\n\n  initGraphicItem: (attrs?: any) => void;\n  updateGraphicItem: (config: IMarkConfig) => void;\n\n  getDatum: () => any;\n  getBounds: () => any;\n  getGraphicItem: () => IGraphic;\n\n  /**\n   * 获取 graphic 视觉通道属性\n   * @param channel 视觉通道\n   * @param prev 是否从之前的 graphic 属性上获取，默认为 false\n   * @returns 视觉通道值\n   */\n  getGraphicAttribute: (channel: string, prev?: boolean) => any;\n  /**\n   * 设置 graphic 视觉通道属性\n   * @param channel 视觉通道\n   * @param value 视觉通道属性\n   * @param final 是否更新 graphic 最终变更的视觉通道结果，默认为 false\n   */\n  setGraphicAttribute: (channel: string, value: any, final?: boolean) => void;\n  /**\n   * 设置一系列 graphic 视觉通道属性\n   * @param attributes 视觉通道键值对\n   * @param final 是否更新 graphic 最终变更的视觉通道结果，默认为 false\n   */\n  setGraphicAttributes: (attributes: { [channel: string]: any }, final?: boolean) => void;\n\n  /**\n   * 【慎重使用】获取 VGrammar 自身的视觉通道属性\n   * 只有在 'afterEncodeItems' 时机的mark transform中才能调用\n   */\n  getItemAttribute: (channel?: string) => any;\n  /**\n   * 【慎重使用】设置 VGrammar 自身的视觉通道\n   * 只有在 'afterEncodeItems' 时机的mark transform中才能调用\n   * @param attributes\n   * @returns\n   */\n  setItemAttributes: (attributes: { [channel: string]: any } | any[]) => void;\n\n  // element 执行流程相关接口\n  updateData: (groupKey: string, data: any[], keyGenerator: MarkKeySpec, view: any) => void;\n  state: (markState: MarkFunctionType<string | string[]>, parameters?: any) => void;\n  encodeItems: (items: MarkElementItem[], encoders: BaseEncodeSpec, isReentered?: boolean, parameters?: any) => void;\n  encodeGraphic: (attributes?: any) => void;\n  transformElementItems: (items: MarkElementItem[], markType: MarkType, computePoints?: boolean) => Record<string, any>;\n  remove: () => void;\n  release: () => void;\n\n  // 动画相关接口\n\n  getFinalGraphicAttributes: () => { [key: string]: any };\n  getPrevGraphicAttributes: () => { [key: string]: any };\n  getNextGraphicAttributes: () => { [key: string]: any };\n  clearChangedGraphicAttributes: () => void;\n  clearGraphicAttributes: () => void;\n\n  // state相关接口\n  getStates: () => string[];\n  hasState: (state: string) => boolean;\n  clearStates: (noAnimation?: boolean) => void;\n  addState: (state: string | string[], attrs?: any) => void;\n  removeState: (state: string | string[]) => void;\n  useStates: (states: string[], noAnimation?: boolean) => void;\n}\n\nexport interface IGlyphElement<P = any> extends IElement {\n  mark: IGlyphMark;\n\n  getGlyphGraphicItems: () => { [markName: string]: any };\n\n  getGraphicAttribute: (channel: string, prev?: boolean, markName?: any) => any;\n  setGraphicAttribute: (channel: string, value: any, final?: boolean, markName?: any) => void;\n  setGraphicAttributes: (attributes: { [channel: string]: any }, final?: boolean, markName?: any) => void;\n\n  getFinalGraphicAttributes: (markName?: string) => { [key: string]: any };\n  getPrevGraphicAttributes: (markName?: string) => { [key: string]: any };\n  getNextGraphicAttributes: (markName?: string) => { [key: string]: any };\n\n  encodeCustom: (nextAttrs?: any) => { [markName: string]: any };\n}\n"]}

package/cjs/types/event.d.ts

@@ -0,0 +1,58 @@
+import type { IAnimationConfig, IElement, IMark } from '.';
+import type { MarkType } from './mark';
+import type { SignalDependency } from './signal';
+export type AnimationEvent = {
+    mark: IMark;
+    animationState: string;
+    animationConfig: IAnimationConfig;
+};
+export type GrammarEvent = MouseEvent & TouchEvent & KeyboardEvent & AnimationEvent;
+export type EventHandler<T> = (event?: GrammarEvent, value?: T) => void;
+export type BaseEventHandler = EventHandler<any>;
+export type ResizeHandler = EventHandler<{
+    width?: number;
+    height?: number;
+}>;
+export type AnimationEventType = 'animationStart' | 'animationEnd' | 'elementAnimationStart' | 'elementAnimationEnd';
+export type AnimationListenerHandler = (event?: AnimationEvent, el?: IElement) => void;
+export type EventType = 'pointerdown' | 'pointerup' | 'pointerupoutside' | 'pointertap' | 'pointerover' | 'pointerenter' | 'pointerleave' | 'pointerout' | 'mousedown' | 'mouseup' | 'mouseupoutside' | 'rightdown' | 'rightup' | 'rightupoutside' | 'click' | 'dblclick' | 'mousemove' | 'mouseover' | 'mouseout' | 'mouseenter' | 'mouseleave' | 'wheel' | 'tap' | 'touchstart' | 'touchend' | 'touchendoutside' | 'touchmove' | 'touchcancel' | 'dragstart' | 'drag' | 'dragenter' | 'dragleave' | 'dragover' | 'dragend' | 'drop' | 'pan' | 'panstart' | 'panend' | 'press' | 'pressup' | 'pressend' | 'pinch' | 'pinchstart' | 'pinchend' | 'swipe' | 'resize';
+export type WindowEventType = string;
+export interface EventCallbackContext extends Event {
+    element?: any;
+    datum?: any;
+}
+export type EventCallback = (context: EventCallbackContext, params?: any) => any;
+export interface BaseEventSpec {
+    type: string;
+    filter?: (context: EventCallbackContext) => boolean;
+    throttle?: number;
+    debounce?: number;
+    consume?: boolean;
+    callback?: EventCallback;
+    dependency?: SignalDependency | SignalDependency[];
+    target?: string | Array<{
+        target: string;
+        callback: EventCallback;
+    }>;
+}
+export type MergeEventSpec = Omit<BaseEventSpec, 'type'> & {
+    merge: string[] | BaseEventSpec[];
+};
+export interface ParsedViewEventSpec extends BaseEventSpec {
+    source?: 'view';
+    type: EventType;
+    markId?: string;
+    markName?: string;
+    markType?: string;
+}
+export interface ParsedWindowEventSpec extends BaseEventSpec {
+    source: 'window';
+    type: WindowEventType;
+    markId?: string;
+    markName?: string;
+    markType?: MarkType;
+}
+export type EventSpec = BaseEventSpec | ({
+    between: [BaseEventSpec, BaseEventSpec];
+} & BaseEventSpec) | MergeEventSpec;
+export type EventSourceType = 'window' | 'view';

package/cjs/types/event.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+//# sourceMappingURL=event.js.map

package/cjs/types/event.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/event.ts"],"names":[],"mappings":"","file":"event.js","sourcesContent":["import type { IAnimationConfig, IElement, IMark } from '.';\nimport type { MarkType } from './mark';\nimport type { SignalDependency } from './signal';\n\nexport type AnimationEvent = {\n  mark: IMark;\n  animationState: string;\n  animationConfig: IAnimationConfig;\n};\n\nexport type GrammarEvent = MouseEvent & TouchEvent & KeyboardEvent & AnimationEvent;\n\nexport type EventHandler<T> = (event?: GrammarEvent, value?: T) => void;\nexport type BaseEventHandler = EventHandler<any>;\nexport type ResizeHandler = EventHandler<{ width?: number; height?: number }>;\n\nexport type AnimationEventType = 'animationStart' | 'animationEnd' | 'elementAnimationStart' | 'elementAnimationEnd';\n\nexport type AnimationListenerHandler = (event?: AnimationEvent, el?: IElement) => void;\n\nexport type EventType =\n  | 'pointerdown'\n  | 'pointerup'\n  // 指针抬起与按下的图形不同时触发\n  | 'pointerupoutside'\n  | 'pointertap'\n  | 'pointerover'\n  | 'pointerenter'\n  | 'pointerleave'\n  | 'pointerout'\n  | 'mousedown'\n  | 'mouseup'\n  | 'mouseupoutside'\n  // 右键操作\n  | 'rightdown'\n  | 'rightup'\n  | 'rightupoutside'\n  | 'click'\n  // 双击\n  | 'dblclick'\n  | 'mousemove'\n  | 'mouseover'\n  | 'mouseout'\n  // 不会冒泡\n  | 'mouseenter'\n  // 不会冒泡\n  | 'mouseleave'\n  | 'wheel'\n  | 'tap'\n  | 'touchstart'\n  | 'touchend'\n  | 'touchendoutside'\n  | 'touchmove'\n  | 'touchcancel'\n  // dragNdrop\n  | 'dragstart'\n  | 'drag'\n  | 'dragenter'\n  | 'dragleave'\n  | 'dragover'\n  | 'dragend'\n  | 'drop'\n  // gesture\n  | 'pan'\n  | 'panstart'\n  | 'panend'\n  | 'press'\n  | 'pressup'\n  | 'pressend'\n  | 'pinch'\n  | 'pinchstart'\n  | 'pinchend'\n  | 'swipe'\n  // resize\n  | 'resize';\n\nexport type WindowEventType = string;\n\nexport interface EventCallbackContext extends Event {\n  element?: any;\n  datum?: any;\n}\n\nexport type EventCallback = (context: EventCallbackContext, params?: any) => any;\nexport interface BaseEventSpec {\n  type: string;\n  filter?: (context: EventCallbackContext) => boolean;\n  throttle?: number;\n  debounce?: number;\n  /** 阻止事件的执行和传播 */\n  consume?: boolean;\n  callback?: EventCallback;\n  dependency?: SignalDependency | SignalDependency[];\n  target?:\n    | string\n    | Array<{\n        target: string;\n        callback: EventCallback;\n      }>;\n}\n\nexport type MergeEventSpec = Omit<BaseEventSpec, 'type'> & { merge: string[] | BaseEventSpec[] };\n\nexport interface ParsedViewEventSpec extends BaseEventSpec {\n  source?: 'view';\n  type: EventType;\n  markId?: string;\n  markName?: string;\n  markType?: string;\n}\n\nexport interface ParsedWindowEventSpec extends BaseEventSpec {\n  source: 'window';\n  type: WindowEventType;\n  markId?: string;\n  markName?: string;\n  markType?: MarkType;\n}\n\nexport type EventSpec =\n  | BaseEventSpec\n  | ({\n      between: [BaseEventSpec, BaseEventSpec];\n    } & BaseEventSpec)\n  | MergeEventSpec;\n\nexport type EventSourceType = 'window' | 'view';\n"]}

package/cjs/types/glyph.d.ts

@@ -0,0 +1,29 @@
+import type { Nil } from './base';
+import type { IGlyphElement } from './element';
+import type { MarkType } from './mark';
+export interface IGlyphMeta<EncodeValuesType = any, GlyphConfigType = any> {
+    getMarks: () => {
+        [markName: string]: MarkType;
+    };
+    getChannelEncoder: () => {
+        [channel: string]: GlyphChannelEncoder<any, EncodeValuesType, GlyphConfigType>;
+    };
+    getDefaultEncoder: () => GlyphDefaultEncoder<GlyphConfigType>;
+    getFunctionEncoder: () => GlyphFunctionEncoder<GlyphConfigType>;
+    getProgressiveChannels: () => string[];
+    registerChannelEncoder: ((encoders: {
+        [markName: string]: GlyphChannelEncoder<any, EncodeValuesType, GlyphConfigType>;
+    }) => this) & ((channel: string, encoder: GlyphChannelEncoder<any, EncodeValuesType, GlyphConfigType>) => this);
+    registerDefaultEncoder: (encoder: GlyphDefaultEncoder<GlyphConfigType>) => this;
+    registerFunctionEncoder: (encoder: GlyphFunctionEncoder<GlyphConfigType>) => this;
+    registerProgressiveChannels: (channels: string | string[]) => this;
+}
+export type GlyphChannelEncoder<EncodeValueType = any, EncodeValuesType = any, GlyphConfigType = any> = (channel: string, encodeValue: EncodeValueType, encodeValues: EncodeValuesType, datum: any, element: IGlyphElement, glyphConfig: GlyphConfigType) => {
+    [markName: string]: any;
+} | Nil;
+export type GlyphDefaultEncoder<GlyphConfigType = any> = (datum: any, element: IGlyphElement, glyphConfig: GlyphConfigType) => {
+    [markName: string]: any;
+};
+export type GlyphFunctionEncoder<GlyphConfigType = any> = (encodeValues: any, datum: any, element: IGlyphElement, glyphConfig: GlyphConfigType) => {
+    [markName: string]: any;
+} | Nil;

package/cjs/types/glyph.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+//# sourceMappingURL=glyph.js.map

package/cjs/types/glyph.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/glyph.ts"],"names":[],"mappings":"","file":"glyph.js","sourcesContent":["import type { Nil } from './base';\nimport type { IGlyphElement } from './element';\nimport type { MarkType } from './mark';\nexport interface IGlyphMeta<EncodeValuesType = any, GlyphConfigType = any> {\n  getMarks: () => { [markName: string]: MarkType };\n\n  getChannelEncoder: () => { [channel: string]: GlyphChannelEncoder<any, EncodeValuesType, GlyphConfigType> };\n  getDefaultEncoder: () => GlyphDefaultEncoder<GlyphConfigType>;\n  getFunctionEncoder: () => GlyphFunctionEncoder<GlyphConfigType>;\n  getProgressiveChannels: () => string[];\n\n  registerChannelEncoder: ((encoders: {\n    [markName: string]: GlyphChannelEncoder<any, EncodeValuesType, GlyphConfigType>;\n  }) => this) &\n    ((channel: string, encoder: GlyphChannelEncoder<any, EncodeValuesType, GlyphConfigType>) => this);\n  registerDefaultEncoder: (encoder: GlyphDefaultEncoder<GlyphConfigType>) => this;\n  registerFunctionEncoder: (encoder: GlyphFunctionEncoder<GlyphConfigType>) => this;\n  registerProgressiveChannels: (channels: string | string[]) => this;\n}\n\nexport type GlyphChannelEncoder<EncodeValueType = any, EncodeValuesType = any, GlyphConfigType = any> = (\n  channel: string,\n  encodeValue: EncodeValueType,\n  encodeValues: EncodeValuesType,\n  datum: any,\n  element: IGlyphElement,\n  glyphConfig: GlyphConfigType\n) => { [markName: string]: any } | Nil;\n\nexport type GlyphDefaultEncoder<GlyphConfigType = any> = (\n  datum: any,\n  element: IGlyphElement,\n  glyphConfig: GlyphConfigType\n) => { [markName: string]: any };\n\nexport type GlyphFunctionEncoder<GlyphConfigType = any> = (\n  encodeValues: any,\n  datum: any,\n  element: IGlyphElement,\n  glyphConfig: GlyphConfigType\n) => { [markName: string]: any } | Nil;\n"]}

package/cjs/types/grammar.d.ts

@@ -0,0 +1,184 @@
+import type { EventEmitter, IBounds, IPointLike } from '@visactor/vutils';
+import type { IGraphic, IGroup } from '@visactor/vrender';
+import type { IBaseScale, TickData } from '@visactor/vscale';
+import type { ITransform, TransformSpec } from './transform';
+import type { DataFormatSpec, IDataFilter } from './data';
+import type { ParameterFunctionType, SignalFunctionType } from './signal';
+import type { IAnimate } from './animate';
+import type { IGlyphMeta } from './glyph';
+import type { GrammarTypeEnum } from '../graph/enums';
+import type { Nil } from './base';
+import type { CoordinateFunctionType } from './coordinate';
+import type { IElement } from './element';
+import type { MarkFunctionType, MarkAnimationSpec, MarkType, MarkLayoutSpec, MarkLayoutCallback, MarkSortSpec, MarkKeySpec, IMarkConfig, ChannelEncodeType, AttributeTransform, BaseSignleEncodeSpec } from './mark';
+import type { ScaleConfigureSpec, ScaleData, ScaleFunctionType, GrammarScaleType, MultiScaleData } from './scale';
+import type { IView } from './view';
+import type { BaseEventHandler } from './event';
+import type { ICartesianCoordinate, IPolarCoordinate } from '@visactor/vgrammar-coordinate';
+export type BuiltInGrammarType = keyof typeof GrammarTypeEnum;
+export type GrammarType = BuiltInGrammarType | string;
+export interface IGrammarTask extends ITransform {
+    options?: Record<string, any | IGrammarBase> | (IGrammarBase | any)[];
+    references?: IGrammarBase[];
+    isRawOptions?: boolean;
+}
+export interface GrammarSpec {
+    id?: string;
+    dependency?: IGrammarBase[] | IGrammarBase | string[] | string;
+}
+export interface IGrammarBase {
+    readonly grammarType: GrammarType;
+    readonly view: IView;
+    readonly uid: number;
+    grammarSource: IGrammarBase;
+    targets: IGrammarBase[];
+    references: Map<IGrammarBase, number>;
+    depend: (grammar: IGrammarBase[] | IGrammarBase | string[] | string) => this;
+    addEventListener: (type: string, handler: BaseEventHandler, options?: any) => this;
+    removeEventListener: (type: string, handler: BaseEventHandler) => this;
+    emit: <T extends EventEmitter.EventNames<string | symbol>>(event: T, ...args: EventEmitter.EventArgs<string | symbol, T>) => boolean;
+    emitGrammarEvent: <T extends EventEmitter.EventNames<string | symbol>>(event: T, ...args: EventEmitter.EventArgs<string | symbol, T>) => boolean;
+    tasks?: IGrammarTask[];
+    rank?: number;
+    set: (value: any) => boolean;
+    id: (() => string) & ((id: string) => this);
+    name: (() => string) & ((name: string) => this);
+    attach: (reference: IGrammarBase | IGrammarBase[], count?: number) => this;
+    detach: (reference: IGrammarBase | IGrammarBase[], count?: number) => this;
+    detachAll: () => void;
+    commit: () => void;
+    output: () => any;
+    parse: (spec: any) => this;
+    parameters: () => {
+        [key: string]: any;
+    };
+    evaluateSync?: (upstream: any, parameters: any) => this;
+    getSpec: () => any;
+    reuse: (grammar: IGrammarBase) => this;
+    clear: () => void;
+    release: () => void;
+}
+export interface IData extends IGrammarBase {
+    values: (values: any | Nil, format?: ParameterFunctionType<DataFormatSpec>, load?: boolean) => this;
+    url: (url: ParameterFunctionType<string> | Nil, format?: ParameterFunctionType<DataFormatSpec>, load?: boolean) => this;
+    source: (source: string | string[] | IData | IData[], format?: ParameterFunctionType<DataFormatSpec>, load?: boolean) => this;
+    transform: (transform: TransformSpec[] | Nil) => this;
+    addDataFilter: (filter: IDataFilter | IDataFilter[]) => this;
+    removeDataFilter: (filter: IDataFilter | IDataFilter[]) => this;
+    field: (field: string) => any[];
+    getValue: () => any[];
+    getInput: () => any[];
+    getDataIDKey: () => string;
+}
+export interface ISignal<T> extends IGrammarBase {
+    value: (value: T | Nil) => this;
+    update: (update: SignalFunctionType<T> | Nil) => this;
+    getValue: () => T;
+}
+export interface IScale extends IGrammarBase {
+    domain: (domain: ScaleFunctionType<any[]> | ScaleData | MultiScaleData | Nil) => this;
+    range: (range: ScaleFunctionType<any[]> | ScaleData | MultiScaleData | Nil) => this;
+    configure: (config: ScaleConfigureSpec | Nil) => this;
+    getScaleType: () => GrammarScaleType;
+    getScale: () => IBaseScale;
+    ticks: (count?: number) => TickData[];
+    getCoordinateAxisPoints: (baseValue?: number) => [IPointLike, IPointLike];
+    getCoordinate: () => IPolarCoordinate | ICartesianCoordinate;
+    getCoordinateAxisPosition: () => 'top' | 'bottom' | 'left' | 'right' | 'inside' | 'outside' | 'start' | 'end';
+}
+export interface ICoordinate extends IGrammarBase {
+    start: (start: CoordinateFunctionType<[number, number]> | Nil) => this;
+    end: (end: CoordinateFunctionType<[number, number]> | Nil) => this;
+    origin: (origin: CoordinateFunctionType<[number, number]> | Nil) => this;
+    translate: (offset: CoordinateFunctionType<[number, number]> | Nil) => this;
+    rotate: (angle: CoordinateFunctionType<number> | Nil) => this;
+    scale: (ratio: CoordinateFunctionType<[number, number]> | Nil) => this;
+    transpose: (isTransposed: CoordinateFunctionType<boolean> | Nil) => this;
+}
+export interface IGroupMark extends IMark {
+    children: (IMark | IGroupMark | IGlyphMark)[];
+    layoutChildren?: (IMark | IGroupMark | IGlyphMark)[];
+    appendChild: (mark: IMark | IGroupMark | IGlyphMark) => this;
+    removeChild: (mark: IMark | IGroupMark | IGlyphMark) => this;
+    includesChild: (mark: IMark, descendant?: boolean) => boolean;
+    updateLayoutChildren: () => this;
+}
+export interface IGlyphMark extends IMark {
+    glyphType: string;
+    getGlyphMeta: () => IGlyphMeta;
+    configureGlyph: (config: any) => this;
+    getGlyphConfig: () => any;
+}
+export interface IComponent extends IMark {
+    componentType: string;
+    configureComponent: (config: any) => this;
+}
+export interface IProgressiveGrammar {
+    isProgressive: () => boolean;
+    isDoingProgressive: () => boolean;
+    clearProgressive: () => void;
+    restartProgressive: () => void;
+    evaluateProgressive: () => void;
+}
+export interface IMark extends IGrammarBase, IProgressiveGrammar {
+    group?: IGroupMark;
+    markType: MarkType;
+    context: any;
+    coord: ICoordinate;
+    disableCoordinateTransform?: boolean;
+    elements: IElement[];
+    elementMap: Map<string, IElement>;
+    graphicIndex: number;
+    graphicItem?: IGroup;
+    animate: IAnimate;
+    join: (data: IData | string | Nil, key?: MarkKeySpec, sort?: MarkSortSpec, groupBy?: MarkKeySpec, groupSort?: MarkSortSpec) => this;
+    coordinate: (coordinate: ICoordinate | string | Nil) => this;
+    state: (state: MarkFunctionType<string | string[]> | Nil) => this;
+    encode: ((encoders: BaseSignleEncodeSpec) => this) & ((channel: string, value: ChannelEncodeType) => this);
+    encodeState: ((state: string, channel: string, value: ChannelEncodeType) => this) & ((state: string, encoders: BaseSignleEncodeSpec) => this);
+    animation: (animationConfig: MarkAnimationSpec | Nil) => this;
+    animationState: (animationState: MarkFunctionType<string> | Nil) => this;
+    layout: (layout: MarkLayoutSpec | MarkLayoutCallback | Nil) => this;
+    configure: (config: IMarkConfig | Nil) => this;
+    transform: (transform: TransformSpec[] | Nil) => this;
+    needAnimate: () => boolean;
+    getBounds: () => IBounds;
+    isCollectionMark: () => boolean;
+    getAllElements: () => IElement[];
+    isUpdated: boolean;
+    getGroupGraphicItem: () => any;
+    cleanExitElements: () => void;
+    addGraphicItem: (attrs: any, groupKey?: string) => IGraphic;
+    getMorphConfig: () => {
+        morph: boolean;
+        morphKey: string | undefined;
+        morphElementKey: string | undefined;
+    };
+    prepareRelease: () => void;
+    layoutBounds?: IBounds;
+    relativePosition?: {
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    };
+    needLayout: () => boolean;
+    handleLayoutEnd: () => void;
+    handleRenderEnd: () => void;
+    isLargeMode: () => boolean;
+    getAttributeTransforms: () => AttributeTransform[];
+    getScalesByChannel: () => Record<string, IBaseScale> | undefined;
+    getFieldsByChannel: () => Record<string, string> | undefined;
+    getScales: () => Record<string, IBaseScale> | undefined;
+}
+export interface IGrammarBaseConstructor {
+    new (view: IView): IGrammarBase;
+}
+export interface ProgressiveContext {
+    currentIndex: number;
+    totalStep: number;
+    step: number;
+    data: any[];
+    groupKeys?: string[];
+    groupedData?: Map<string, any[]>;
+}

package/cjs/types/grammar.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+//# sourceMappingURL=grammar.js.map

package/cjs/types/grammar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/grammar.ts"],"names":[],"mappings":"","file":"grammar.js","sourcesContent":["import type { EventEmitter, IBounds, IPointLike } from '@visactor/vutils';\nimport type { IGraphic, IGroup } from '@visactor/vrender';\nimport type { IBaseScale, TickData } from '@visactor/vscale';\nimport type { ITransform, TransformSpec } from './transform';\nimport type { DataFormatSpec, IDataFilter } from './data';\nimport type { ParameterFunctionType, SignalFunctionType } from './signal';\nimport type { IAnimate } from './animate';\nimport type { IGlyphMeta } from './glyph';\nimport type { GrammarTypeEnum } from '../graph/enums';\nimport type { Nil } from './base';\nimport type { CoordinateFunctionType } from './coordinate';\nimport type { IElement } from './element';\nimport type {\n  MarkFunctionType,\n  MarkAnimationSpec,\n  MarkType,\n  MarkLayoutSpec,\n  MarkLayoutCallback,\n  MarkSortSpec,\n  MarkKeySpec,\n  IMarkConfig,\n  ChannelEncodeType,\n  AttributeTransform,\n  BaseSignleEncodeSpec\n} from './mark';\nimport type { ScaleConfigureSpec, ScaleData, ScaleFunctionType, GrammarScaleType, MultiScaleData } from './scale';\nimport type { IView } from './view';\nimport type { BaseEventHandler } from './event';\nimport type { ICartesianCoordinate, IPolarCoordinate } from '@visactor/vgrammar-coordinate';\n\nexport type BuiltInGrammarType = keyof typeof GrammarTypeEnum;\nexport type GrammarType = BuiltInGrammarType | string;\n\n/** 语法元素内置运行的任务 */\nexport interface IGrammarTask extends ITransform {\n  /**\n   * 参数依赖\n   * 只做一级解析\n   */\n  options?: Record<string, any | IGrammarBase> | (IGrammarBase | any)[];\n  /**\n   * 依赖的语法元素\n   */\n  references?: IGrammarBase[];\n  /**\n   * 是否只支持简单的options配置，不支持在options引用语法元素\n   */\n  isRawOptions?: boolean;\n}\n\nexport interface GrammarSpec {\n  id?: string;\n  dependency?: IGrammarBase[] | IGrammarBase | string[] | string;\n}\n\nexport interface IGrammarBase {\n  readonly grammarType: GrammarType;\n  readonly view: IView;\n  readonly uid: number;\n  /**\n   * 执行的上游节点\n   */\n  grammarSource: IGrammarBase;\n  /**\n   * 影响的下游节点\n   */\n  targets: IGrammarBase[];\n  /**\n   * 依赖的上游节点，由于不同 spec 配置项中可能引用同一个节点，需要进行计数\n   */\n  references: Map<IGrammarBase, number>;\n\n  depend: (grammar: IGrammarBase[] | IGrammarBase | string[] | string) => this;\n\n  addEventListener: (type: string, handler: BaseEventHandler, options?: any) => this;\n  removeEventListener: (type: string, handler: BaseEventHandler) => this;\n\n  // extended from EventEmitter\n  emit: <T extends EventEmitter.EventNames<string | symbol>>(\n    event: T,\n    ...args: EventEmitter.EventArgs<string | symbol, T>\n  ) => boolean;\n  emitGrammarEvent: <T extends EventEmitter.EventNames<string | symbol>>(\n    event: T,\n    ...args: EventEmitter.EventArgs<string | symbol, T>\n  ) => boolean;\n\n  tasks?: IGrammarTask[];\n  // value?: any;\n  /** FIXME: operator执行顺序，改造后，dataflow执行元素，应该抽象出来 */\n  rank?: number;\n  // todo\n  set: (value: any) => boolean;\n  id: (() => string) & ((id: string) => this);\n  name: (() => string) & ((name: string) => this);\n  attach: (reference: IGrammarBase | IGrammarBase[], count?: number) => this;\n  detach: (reference: IGrammarBase | IGrammarBase[], count?: number) => this;\n  detachAll: () => void;\n  commit: () => void;\n  output: () => any;\n  parse: (spec: any) => this;\n  parameters: () => { [key: string]: any };\n  evaluateSync?: (upstream: any, parameters: any) => this;\n  getSpec: () => any;\n  reuse: (grammar: IGrammarBase) => this;\n  /** clear references */\n  clear: () => void;\n  /** release all memory storage */\n  release: () => void;\n}\n\nexport interface IData extends IGrammarBase {\n  values: (values: any | Nil, format?: ParameterFunctionType<DataFormatSpec>, load?: boolean) => this;\n  url: (\n    url: ParameterFunctionType<string> | Nil,\n    format?: ParameterFunctionType<DataFormatSpec>,\n    load?: boolean\n  ) => this;\n  source: (\n    source: string | string[] | IData | IData[],\n    format?: ParameterFunctionType<DataFormatSpec>,\n    load?: boolean\n  ) => this;\n  transform: (transform: TransformSpec[] | Nil) => this;\n\n  // only used in VGrammar\n  addDataFilter: (filter: IDataFilter | IDataFilter[]) => this;\n  removeDataFilter: (filter: IDataFilter | IDataFilter[]) => this;\n\n  // data util methods\n  field: (field: string) => any[];\n  getValue: () => any[];\n  getInput: () => any[];\n  getDataIDKey: () => string;\n}\n\n/** 语法元素,TODO */\nexport interface ISignal<T> extends IGrammarBase {\n  value: (value: T | Nil) => this;\n  update: (update: SignalFunctionType<T> | Nil) => this;\n\n  getValue: () => T;\n}\n\n/** 语法元素,TODO */\nexport interface IScale extends IGrammarBase {\n  domain: (domain: ScaleFunctionType<any[]> | ScaleData | MultiScaleData | Nil) => this;\n  range: (range: ScaleFunctionType<any[]> | ScaleData | MultiScaleData | Nil) => this;\n  configure: (config: ScaleConfigureSpec | Nil) => this;\n\n  // scale util methods\n  getScaleType: () => GrammarScaleType;\n  getScale: () => IBaseScale;\n  ticks: (count?: number) => TickData[];\n  getCoordinateAxisPoints: (baseValue?: number) => [IPointLike, IPointLike];\n  getCoordinate: () => IPolarCoordinate | ICartesianCoordinate;\n  getCoordinateAxisPosition: () => 'top' | 'bottom' | 'left' | 'right' | 'inside' | 'outside' | 'start' | 'end';\n}\n\nexport interface ICoordinate extends IGrammarBase {\n  start: (start: CoordinateFunctionType<[number, number]> | Nil) => this;\n  end: (end: CoordinateFunctionType<[number, number]> | Nil) => this;\n  origin: (origin: CoordinateFunctionType<[number, number]> | Nil) => this;\n\n  translate: (offset: CoordinateFunctionType<[number, number]> | Nil) => this;\n  rotate: (angle: CoordinateFunctionType<number> | Nil) => this;\n  scale: (ratio: CoordinateFunctionType<[number, number]> | Nil) => this;\n  transpose: (isTransposed: CoordinateFunctionType<boolean> | Nil) => this;\n\n  // coordinate util methods\n}\n\n/** 语法元素,TODO */\n\n/** group mark */\nexport interface IGroupMark extends IMark {\n  children: (IMark | IGroupMark | IGlyphMark)[];\n\n  layoutChildren?: (IMark | IGroupMark | IGlyphMark)[];\n\n  appendChild: (mark: IMark | IGroupMark | IGlyphMark) => this;\n  removeChild: (mark: IMark | IGroupMark | IGlyphMark) => this;\n  includesChild: (mark: IMark, descendant?: boolean) => boolean;\n\n  updateLayoutChildren: () => this;\n}\n\nexport interface IGlyphMark extends IMark {\n  glyphType: string;\n  getGlyphMeta: () => IGlyphMeta;\n  configureGlyph: (config: any) => this;\n  getGlyphConfig: () => any;\n}\n\nexport interface IComponent extends IMark {\n  componentType: string;\n  configureComponent: (config: any) => this;\n}\n\nexport interface IProgressiveGrammar {\n  /** 是否启动了增量渲染模式 */\n  isProgressive: () => boolean;\n  /** 是否正在执行增量渲染 */\n  isDoingProgressive: () => boolean;\n  /** 清除增量渲染相关状态 */\n  clearProgressive: () => void;\n  /** 从第一帧开始增量计算 */\n  restartProgressive: () => void;\n  /** 分片执行 */\n  evaluateProgressive: () => void;\n}\n\nexport interface IMark extends IGrammarBase, IProgressiveGrammar {\n  group?: IGroupMark;\n\n  markType: MarkType;\n  context: any;\n  coord: ICoordinate;\n  /**\n   * disable coordinate transform when need\n   */\n  disableCoordinateTransform?: boolean;\n  elements: IElement[];\n  elementMap: Map<string, IElement>;\n  graphicIndex: number;\n  graphicItem?: IGroup;\n  animate: IAnimate;\n\n  join: (\n    data: IData | string | Nil,\n    key?: MarkKeySpec,\n    sort?: MarkSortSpec,\n    groupBy?: MarkKeySpec,\n    groupSort?: MarkSortSpec\n  ) => this;\n  coordinate: (coordinate: ICoordinate | string | Nil) => this;\n  state: (state: MarkFunctionType<string | string[]> | Nil) => this;\n  encode: ((encoders: BaseSignleEncodeSpec) => this) & ((channel: string, value: ChannelEncodeType) => this);\n  encodeState: ((state: string, channel: string, value: ChannelEncodeType) => this) &\n    ((state: string, encoders: BaseSignleEncodeSpec) => this);\n  animation: (animationConfig: MarkAnimationSpec | Nil) => this;\n  animationState: (animationState: MarkFunctionType<string> | Nil) => this;\n  layout: (layout: MarkLayoutSpec | MarkLayoutCallback | Nil) => this;\n  configure: (config: IMarkConfig | Nil) => this;\n  transform: (transform: TransformSpec[] | Nil) => this;\n\n  needAnimate: () => boolean;\n  getBounds: () => IBounds;\n  isCollectionMark: () => boolean;\n  getAllElements: () => IElement[];\n\n  // position: () => this;\n  // color: () => this;\n  // shape: () => this;\n\n  // mark 执行流程相关接口\n\n  isUpdated: boolean;\n  getGroupGraphicItem: () => any;\n  cleanExitElements: () => void;\n  addGraphicItem: (attrs: any, groupKey?: string) => IGraphic;\n  getMorphConfig: () => { morph: boolean; morphKey: string | undefined; morphElementKey: string | undefined };\n  prepareRelease: () => void;\n\n  layoutBounds?: IBounds;\n  relativePosition?: { top?: number; bottom?: number; left?: number; right?: number };\n  needLayout: () => boolean;\n  handleLayoutEnd: () => void;\n  handleRenderEnd: () => void;\n  isLargeMode: () => boolean;\n  getAttributeTransforms: () => AttributeTransform[];\n\n  getScalesByChannel: () => Record<string, IBaseScale> | undefined;\n  getFieldsByChannel: () => Record<string, string> | undefined;\n  getScales: () => Record<string, IBaseScale> | undefined;\n}\n\nexport interface IGrammarBaseConstructor {\n  new (view: IView): IGrammarBase;\n}\n\nexport interface ProgressiveContext {\n  currentIndex: number;\n  totalStep: number;\n  step: number;\n  data: any[];\n  groupKeys?: string[];\n  groupedData?: Map<string, any[]>;\n}\n"]}

package/cjs/types/hooks.d.ts

@@ -0,0 +1,45 @@
+import type { HOOK_EVENT } from '../graph/enums';
+export interface Hooks {
+    [HOOK_EVENT.BEFORE_PARSE_VIEW]?: () => void;
+    [HOOK_EVENT.AFTER_PARSE_VIEW]?: () => void;
+    [HOOK_EVENT.BEFORE_TRANSFORM]?: (type: string) => void;
+    [HOOK_EVENT.AFTER_TRANSFORM]?: (type: string) => void;
+    [HOOK_EVENT.BEFORE_MARK_JOIN]?: () => void;
+    [HOOK_EVENT.AFTER_MARK_JOIN]?: () => void;
+    [HOOK_EVENT.BEFORE_MARK_UPDATE]?: () => void;
+    [HOOK_EVENT.AFTER_MARK_UPDATE]?: () => void;
+    [HOOK_EVENT.BEFORE_MARK_STATE]?: () => void;
+    [HOOK_EVENT.AFTER_MARK_STATE]?: () => void;
+    [HOOK_EVENT.BEFORE_MARK_ENCODE]?: () => void;
+    [HOOK_EVENT.AFTER_MARK_ENCODE]?: () => void;
+    [HOOK_EVENT.BEFORE_ELEMENT_UPDATE_DATA]?: () => void;
+    [HOOK_EVENT.AFTER_ELEMENT_UPDATE_DATA]?: () => void;
+    [HOOK_EVENT.BEFORE_ELEMENT_STATE]?: () => void;
+    [HOOK_EVENT.AFTER_ELEMENT_STATE]?: () => void;
+    [HOOK_EVENT.BEFORE_ELEMENT_ENCODE]?: () => void;
+    [HOOK_EVENT.AFTER_ELEMENT_ENCODE]?: () => void;
+    [HOOK_EVENT.BEFORE_EVALUATE_DATA]?: () => void;
+    [HOOK_EVENT.AFTER_EVALUATE_DATA]?: () => void;
+    [HOOK_EVENT.BEFORE_EVALUATE_SCALE]?: () => void;
+    [HOOK_EVENT.AFTER_EVALUATE_SCALE]?: () => void;
+    [HOOK_EVENT.BEFORE_STAGE_RESIZE]?: () => void;
+    [HOOK_EVENT.AFTER_STAGE_RESIZE]?: () => void;
+    [HOOK_EVENT.BEFORE_DO_LAYOUT]?: () => void;
+    [HOOK_EVENT.AFTER_DO_LAYOUT]?: () => void;
+    [HOOK_EVENT.BEFORE_MARK_LAYOUT_END]?: () => void;
+    [HOOK_EVENT.AFTER_MARK_LAYOUT_END]?: () => void;
+    [HOOK_EVENT.BEFORE_MARK_RENDER_END]?: () => void;
+    [HOOK_EVENT.AFTER_MARK_RENDER_END]?: () => void;
+    [HOOK_EVENT.BEFORE_DO_RENDER]?: () => void;
+    [HOOK_EVENT.AFTER_DO_RENDER]?: () => void;
+    [HOOK_EVENT.BEFORE_CREATE_VRENDER_STAGE]?: () => void;
+    [HOOK_EVENT.AFTER_CREATE_VRENDER_STAGE]?: () => void;
+    [HOOK_EVENT.BEFORE_CREATE_VRENDER_LAYER]?: () => void;
+    [HOOK_EVENT.AFTER_CREATE_VRENDER_LAYER]?: () => void;
+    [HOOK_EVENT.BEFORE_VRENDER_DRAW]?: () => void;
+    [HOOK_EVENT.AFTER_VRENDER_DRAW]?: () => void;
+    [HOOK_EVENT.BEFORE_CREATE_VRENDER_MARK]?: () => void;
+    [HOOK_EVENT.AFTER_CREATE_VRENDER_MARK]?: () => void;
+    [HOOK_EVENT.BEFORE_ADD_VRENDER_MARK]?: () => void;
+    [HOOK_EVENT.AFTER_ADD_VRENDER_MARK]?: () => void;
+}

package/cjs/types/hooks.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+});
+//# sourceMappingURL=hooks.js.map

package/cjs/types/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/hooks.ts"],"names":[],"mappings":"","file":"hooks.js","sourcesContent":["import type { HOOK_EVENT } from '../graph/enums';\n\nexport interface Hooks {\n  [HOOK_EVENT.BEFORE_PARSE_VIEW]?: () => void;\n  [HOOK_EVENT.AFTER_PARSE_VIEW]?: () => void;\n\n  // View\n  [HOOK_EVENT.BEFORE_TRANSFORM]?: (type: string) => void;\n  [HOOK_EVENT.AFTER_TRANSFORM]?: (type: string) => void;\n  [HOOK_EVENT.BEFORE_MARK_JOIN]?: () => void;\n  [HOOK_EVENT.AFTER_MARK_JOIN]?: () => void;\n  [HOOK_EVENT.BEFORE_MARK_UPDATE]?: () => void;\n  [HOOK_EVENT.AFTER_MARK_UPDATE]?: () => void;\n  [HOOK_EVENT.BEFORE_MARK_STATE]?: () => void;\n  [HOOK_EVENT.AFTER_MARK_STATE]?: () => void;\n  [HOOK_EVENT.BEFORE_MARK_ENCODE]?: () => void;\n  [HOOK_EVENT.AFTER_MARK_ENCODE]?: () => void;\n  [HOOK_EVENT.BEFORE_ELEMENT_UPDATE_DATA]?: () => void;\n  [HOOK_EVENT.AFTER_ELEMENT_UPDATE_DATA]?: () => void;\n  [HOOK_EVENT.BEFORE_ELEMENT_STATE]?: () => void;\n  [HOOK_EVENT.AFTER_ELEMENT_STATE]?: () => void;\n  [HOOK_EVENT.BEFORE_ELEMENT_ENCODE]?: () => void;\n  [HOOK_EVENT.AFTER_ELEMENT_ENCODE]?: () => void;\n\n  [HOOK_EVENT.BEFORE_EVALUATE_DATA]?: () => void;\n  [HOOK_EVENT.AFTER_EVALUATE_DATA]?: () => void;\n  [HOOK_EVENT.BEFORE_EVALUATE_SCALE]?: () => void;\n  [HOOK_EVENT.AFTER_EVALUATE_SCALE]?: () => void;\n\n  [HOOK_EVENT.BEFORE_STAGE_RESIZE]?: () => void;\n  [HOOK_EVENT.AFTER_STAGE_RESIZE]?: () => void;\n\n  [HOOK_EVENT.BEFORE_DO_LAYOUT]?: () => void;\n  [HOOK_EVENT.AFTER_DO_LAYOUT]?: () => void;\n\n  [HOOK_EVENT.BEFORE_MARK_LAYOUT_END]?: () => void;\n  [HOOK_EVENT.AFTER_MARK_LAYOUT_END]?: () => void;\n\n  [HOOK_EVENT.BEFORE_MARK_RENDER_END]?: () => void;\n  [HOOK_EVENT.AFTER_MARK_RENDER_END]?: () => void;\n\n  [HOOK_EVENT.BEFORE_DO_RENDER]?: () => void;\n  [HOOK_EVENT.AFTER_DO_RENDER]?: () => void;\n\n  // Scenegraph\n  [HOOK_EVENT.BEFORE_CREATE_VRENDER_STAGE]?: () => void;\n  [HOOK_EVENT.AFTER_CREATE_VRENDER_STAGE]?: () => void;\n  [HOOK_EVENT.BEFORE_CREATE_VRENDER_LAYER]?: () => void;\n  [HOOK_EVENT.AFTER_CREATE_VRENDER_LAYER]?: () => void;\n  [HOOK_EVENT.BEFORE_VRENDER_DRAW]?: () => void;\n  [HOOK_EVENT.AFTER_VRENDER_DRAW]?: () => void;\n  [HOOK_EVENT.BEFORE_CREATE_VRENDER_MARK]?: () => void;\n  [HOOK_EVENT.AFTER_CREATE_VRENDER_MARK]?: () => void;\n  [HOOK_EVENT.BEFORE_ADD_VRENDER_MARK]?: () => void;\n  [HOOK_EVENT.AFTER_ADD_VRENDER_MARK]?: () => void;\n}\n"]}

package/cjs/types/index.d.ts

@@ -0,0 +1,22 @@
+export * from './animate';
+export * from './base';
+export * from './component';
+export * from './coordinate';
+export * from './data';
+export * from './dataflow';
+export * from './element';
+export * from './event';
+export * from './glyph';
+export * from './grammar';
+export * from './hooks';
+export * from './layout';
+export * from './mark';
+export * from './morph';
+export * from './projection';
+export * from './renderer';
+export * from './scale';
+export * from './signal';
+export * from './theme';
+export * from './transform';
+export * from './view';
+export * from './plot';

package/cjs/types/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var __createBinding = this && this.__createBinding || (Object.create ? function(o, m, k, k2) {
+    void 0 === k2 && (k2 = k);
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    desc && !("get" in desc ? !m.__esModule : desc.writable || desc.configurable) || (desc = {
+        enumerable: !0,
+        get: function() {
+            return m[k];
+        }
+    }), Object.defineProperty(o, k2, desc);
+} : function(o, m, k, k2) {
+    void 0 === k2 && (k2 = k), o[k2] = m[k];
+}), __exportStar = this && this.__exportStar || function(m, exports) {
+    for (var p in m) "default" === p || Object.prototype.hasOwnProperty.call(exports, p) || __createBinding(exports, m, p);
+};
+
+Object.defineProperty(exports, "__esModule", {
+    value: !0
+}), __exportStar(require("./animate"), exports), __exportStar(require("./base"), exports), 
+__exportStar(require("./component"), exports), __exportStar(require("./coordinate"), exports), 
+__exportStar(require("./data"), exports), __exportStar(require("./dataflow"), exports), 
+__exportStar(require("./element"), exports), __exportStar(require("./event"), exports), 
+__exportStar(require("./glyph"), exports), __exportStar(require("./grammar"), exports), 
+__exportStar(require("./hooks"), exports), __exportStar(require("./layout"), exports), 
+__exportStar(require("./mark"), exports), __exportStar(require("./morph"), exports), 
+__exportStar(require("./projection"), exports), __exportStar(require("./renderer"), exports), 
+__exportStar(require("./scale"), exports), __exportStar(require("./signal"), exports), 
+__exportStar(require("./theme"), exports), __exportStar(require("./transform"), exports), 
+__exportStar(require("./view"), exports), __exportStar(require("./plot"), exports);
+//# sourceMappingURL=index.js.map

package/cjs/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B;AAC1B,yCAAuB;AACvB,8CAA4B;AAC5B,+CAA6B;AAC7B,yCAAuB;AACvB,6CAA2B;AAC3B,4CAA0B;AAC1B,0CAAwB;AACxB,0CAAwB;AACxB,4CAA0B;AAC1B,0CAAwB;AACxB,2CAAyB;AACzB,yCAAuB;AACvB,0CAAwB;AACxB,+CAA6B;AAC7B,6CAA2B;AAC3B,0CAAwB;AACxB,2CAAyB;AACzB,0CAAwB;AACxB,8CAA4B;AAC5B,yCAAuB;AACvB,yCAAuB","file":"index.js","sourcesContent":["export * from './animate';\nexport * from './base';\nexport * from './component';\nexport * from './coordinate';\nexport * from './data';\nexport * from './dataflow';\nexport * from './element';\nexport * from './event';\nexport * from './glyph';\nexport * from './grammar';\nexport * from './hooks';\nexport * from './layout';\nexport * from './mark';\nexport * from './morph';\nexport * from './projection';\nexport * from './renderer';\nexport * from './scale';\nexport * from './signal';\nexport * from './theme';\nexport * from './transform';\nexport * from './view';\nexport * from './plot';\n"]}