@visactor/vgrammar-core 0.7.0

package/cjs/types/plot.d.ts

@@ -0,0 +1,326 @@
+/// <reference types="node" />
+import type { AxisBaseAttributes, BaseCrosshairAttrs, BaseLabelAttrs, ColorLegendAttributes, DataZoomAttributes, DiscreteLegendAttrs, GridBaseAttributes, PlayerAttributes, SizeLegendAttributes, SliderAttributes, TitleAttrs } from '@visactor/vrender-components';
+import type { CoordinateType } from '@visactor/vgrammar-coordinate';
+import type { IColor } from '@visactor/vrender';
+import type { IEnvironmentOptions, IRendererOptions, IRunningConfig, ViewSpec, srIOption3DType, IView } from './view';
+import type { CommonPaddingSpec, ValueOf } from './base';
+import type { BasicEncoderSpecMap, LinkPathEncoderSpec, MarkRelativeItemSpec } from './mark';
+import type { BaseEventHandler } from './event';
+import type { TransformSpec } from './transform';
+import type { IAnimationConfig } from './animate';
+import type { ScaleSpec } from './scale';
+import type { DataSpec } from './data';
+import type { GridShape } from './component';
+export interface IPlotOptions extends IEnvironmentOptions, IRendererOptions {
+    width?: number;
+    height?: number;
+    padding?: CommonPaddingSpec;
+    autoFit?: boolean;
+    options3d?: srIOption3DType;
+    theme?: string;
+    logLevel?: number;
+}
+export interface CartesianCoordinateOption {
+    id?: string;
+    type: 'cartesian';
+    transpose?: boolean;
+}
+export interface PolarCoordinateOption {
+    id?: string;
+    type: 'polar';
+    origin?: [string | number, string | number];
+    transpose?: boolean;
+}
+export type PlotIntervalEncoderSpec = Omit<BasicEncoderSpecMap['interval'], 'y'> & {
+    y?: number | number[];
+    y1?: number;
+    x1?: number;
+};
+export type PlotRectEncoderSpec = Omit<BasicEncoderSpecMap['rect'], 'y' | 'x'> & {
+    y?: number | number[];
+    x?: number | number[];
+    y1?: number;
+    x1?: number;
+};
+export type PlotRectXEncoderSpec = Omit<BasicEncoderSpecMap['rect'], 'x'> & {
+    x?: number | number[];
+    y1?: number;
+    x1?: number;
+};
+export type PlotRectYEncoderSpec = Omit<BasicEncoderSpecMap['rect'], 'y'> & {
+    y?: number | number[];
+    y1?: number;
+    x1?: number;
+};
+export type PlotAreaEncoderSpec = Omit<BasicEncoderSpecMap['area'], 'x' | 'y'> & {
+    x?: number | number[];
+    y?: number | number[];
+};
+export type PlotRuleEncoderSpec = Omit<BasicEncoderSpecMap['rule'], 'x' | 'y'> & {
+    x?: number | number[];
+    y?: number | number[];
+};
+export type PlotImageEncoderSpec = Omit<BasicEncoderSpecMap['image'], 'x' | 'y'> & {
+    x?: number | number[];
+    y?: number | number[];
+};
+export type PlotPolygonEncoderSpec = Omit<BasicEncoderSpecMap['polygon'], 'x' | 'y'> & {
+    x?: number[];
+    y?: number[];
+};
+export type PlotSankeyEncoderSpec = Partial<LinkPathEncoderSpec>;
+export type PlotSunburstEncodeSpec = BasicEncoderSpecMap['arc'];
+export type PlotTreeEncodeSpec = BasicEncoderSpecMap['symbol'];
+export type PlotTreemapEncodeSpec = BasicEncoderSpecMap['rect'];
+export type PlotCirclePackingEncodeSpec = BasicEncoderSpecMap['circle'];
+export type PlotWordcloudEncodeSpec = BasicEncoderSpecMap['text'];
+export type PlotWordcloudShapeEncodeSpec = BasicEncoderSpecMap['text'];
+export type CoordinateOption = CartesianCoordinateOption | PolarCoordinateOption;
+export type PlotIntervalSpec = Partial<ISemanticMarkSpec<PlotIntervalEncoderSpec, IntervalEncodeChannels>> & {
+    type: 'interval';
+};
+export type PlotLineSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['line'], LineEncodeChannels>> & {
+    type: 'line';
+};
+export type PlotCellSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['cell'], CellEncodeChannels>> & {
+    type: 'cell';
+};
+export type PlotRuleXSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['rule'], RuleXEncodeChannels>> & {
+    type: 'ruleX';
+};
+export type PlotRuleYSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['rule'], RuleYEncodeChannels>> & {
+    type: 'ruleY';
+};
+export type PlotAreaSpec = Partial<ISemanticMarkSpec<PlotAreaEncoderSpec, AreaEncodeChannels>> & {
+    type: 'area';
+};
+export type PlotSymbolSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['symbol'], SymbolEncodeChannels>> & {
+    type: 'symbol';
+};
+export type PlotTextSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['text'], TextEncodeChannels>> & {
+    type: 'text';
+};
+export type PlotRectSpec = Partial<ISemanticMarkSpec<PlotRectEncoderSpec, RectEncodeChannels>> & {
+    type: 'rect';
+};
+export type PlotRectXSpec = Partial<ISemanticMarkSpec<PlotRectXEncoderSpec, RectXEncodeChannels>> & {
+    type: 'rectX';
+};
+export type PlotRectYSpec = Partial<ISemanticMarkSpec<PlotRectYEncoderSpec, RectYEncodeChannels>> & {
+    type: 'rectY';
+};
+export type PlotPolygonSpec = Partial<ISemanticMarkSpec<PlotPolygonEncoderSpec, PolygonEncodeChannels>> & {
+    type: 'polygon';
+};
+export type PlotRuleSpec = Partial<ISemanticMarkSpec<PlotRuleEncoderSpec, RuleEncodeChannels>> & {
+    type: 'rule';
+};
+export type PlotImageSpec = Partial<ISemanticMarkSpec<PlotImageEncoderSpec, ImageEncodeChannels>> & {
+    type: 'image';
+};
+export type PlotPathSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['path'], PathEncodeChannels>> & {
+    type: 'path';
+};
+export interface PlotSpec {
+    background?: IColor;
+    width?: number;
+    height?: number;
+    padding?: number;
+    coordinate?: CoordinateOption;
+    marks?: Array<PlotIntervalSpec | PlotLineSpec | PlotCellSpec | PlotRuleXSpec | PlotRuleYSpec | PlotAreaSpec | PlotSymbolSpec | PlotTextSpec | PlotRectSpec | PlotRectXSpec | PlotRectYSpec | PlotPolygonSpec | PlotRuleSpec | PlotImageSpec | PlotPathSpec>;
+}
+export interface IPlot {
+    readonly view: IView;
+    theme: (theme: string) => this;
+    coordinate: (type: CoordinateType, option?: Omit<CoordinateOption, 'type'>) => this;
+    run: (runningConfig?: IRunningConfig) => this;
+    runAsync: (runningConfig?: IRunningConfig) => Promise<this>;
+    release: () => this;
+    parseSpec: (spec: PlotSpec) => this;
+    updateSpec: (spec: PlotSpec) => this;
+    getImageBuffer: () => Buffer;
+    on: (type: string, handler: BaseEventHandler) => this;
+    off: (type: string, handler?: BaseEventHandler) => this;
+    interval: () => IInterval;
+    cell: () => ICell;
+    area: () => IArea;
+    image: () => IImage;
+    line: () => ILine;
+    ruleX: () => IRuleX;
+    ruleY: () => IRectY;
+    symbol: () => ISymbol;
+    polygon: () => IPolygon;
+    text: () => IText;
+    rect: () => IRect;
+    rectX: () => IRectX;
+    rectY: () => IRectY;
+    rule: () => IRule;
+    wordcloud: () => IWordcloud;
+    wordcloudShape: () => IWordcloudShape;
+    circlePacking: () => ICirclePacking;
+    treemap: () => ITreemap;
+    tree: () => ITree;
+    sunburst: () => ISunburst;
+    sankey: () => ISankey;
+}
+export interface IPlotConstructor {
+    new (options?: IPlotOptions): IPlot;
+}
+export type WithDefaultEncode<T, K extends string> = {
+    [Key in K]?: Key extends keyof T ? ISemanticEncodeValue<T[Key]> : ISemanticEncodeValue<string | number>;
+};
+export type ISemanticEncodeValue<T> = T extends any[] ? string[] | ((datum: any) => any)[] : string | ((datum: any) => T);
+export type ISemanticEncodeSpec<T> = {
+    [Key in keyof T]?: ISemanticEncodeValue<T[Key]>;
+};
+export type ISemanticStyle<T, K extends string> = Omit<T, K>;
+export interface SemanticTooltipContentItem {
+    key?: ISemanticEncodeValue<string | number>;
+    value?: ISemanticEncodeValue<string | number>;
+    symbol?: ISemanticEncodeValue<string>;
+}
+export type SemanticTooltipOption = {
+    disableGraphicTooltip?: boolean;
+    disableDimensionTooltip?: boolean;
+    staticTitle?: string;
+    staticContentKey?: string | string[];
+    title?: ISemanticEncodeValue<string | number>;
+    dimensionTooltipChannel?: 'x' | 'y';
+    content?: SemanticTooltipContentItem[];
+};
+export interface SemanticAxisOption extends Partial<AxisBaseAttributes> {
+    tickCount?: number;
+}
+export interface SemanticGridOption extends Partial<GridBaseAttributes> {
+    type?: GridShape;
+    tickCount?: number;
+    inside?: boolean;
+    baseValue?: number;
+    sides?: number;
+}
+export type SemanticDataZoomOption = Partial<DataZoomAttributes>;
+export type SemanticSliderOption = Partial<SliderAttributes>;
+export type SemanticLegendOption = Partial<ColorLegendAttributes | DiscreteLegendAttrs | SizeLegendAttributes>;
+export type SemanticCrosshairOption = Partial<BaseCrosshairAttrs>;
+export type SemanticLabelOption = Partial<BaseLabelAttrs>;
+export type SemanticPlayerOption = Partial<PlayerAttributes>;
+export type SemanticTitleOption = Partial<TitleAttrs>;
+export interface ISemanticMark<EncodeSpec, K extends string> {
+    readonly uid: number;
+    readonly type: string;
+    data: (values: any, transform?: TransformSpec[], id?: string) => this;
+    style: (style: Partial<EncodeSpec & any>) => this;
+    encode: (channel: K, option: ValueOf<WithDefaultEncode<EncodeSpec, K>, K>) => this;
+    scale: (channel: K, option: Partial<ScaleSpec>) => this;
+    transform: (option: TransformSpec[]) => this;
+    animate: (state: string, option: IAnimationConfig | IAnimationConfig[]) => this;
+    state: (state: string, option: Partial<EncodeSpec>) => this;
+    axis: (channel: string, option?: SemanticAxisOption | boolean, layout?: MarkRelativeItemSpec) => this;
+    legend: (channel: string, option?: SemanticLegendOption | boolean, layout?: MarkRelativeItemSpec) => this;
+    crosshair: (channel: string, option?: SemanticCrosshairOption | boolean) => this;
+    tooltip: (option: SemanticTooltipOption | boolean) => this;
+    coordinate: (option: CoordinateOption) => this;
+    grid: (channel: string, option?: SemanticGridOption | boolean) => this;
+    title: (option: SemanticTitleOption, layout?: MarkRelativeItemSpec) => this;
+    slider: (channel: string, option?: SemanticSliderOption | boolean, layout?: MarkRelativeItemSpec) => this;
+    datazoom: (channel: string, option?: SemanticDataZoomOption | boolean, layout?: MarkRelativeItemSpec) => this;
+    label: (channel: string, option?: SemanticLabelOption | boolean) => this;
+    player: (data?: any[], option?: SemanticPlayerOption | boolean, layout?: MarkRelativeItemSpec) => this;
+    toViewSpec: () => ViewSpec;
+    parseSpec: (spec: Partial<ISemanticMarkSpec<EncodeSpec, K>>) => this;
+}
+export interface ISemanticMarkSpec<EncodeSpec, K extends string> {
+    id: string | number;
+    data?: DataSpec;
+    encode?: WithDefaultEncode<EncodeSpec, K>;
+    scale?: Partial<Record<K, ScaleSpec>>;
+    style?: Partial<EncodeSpec & any>;
+    axis?: Partial<Record<K, {
+        option?: SemanticAxisOption | boolean;
+        layout?: MarkRelativeItemSpec;
+    } | SemanticAxisOption | boolean>>;
+    grid?: Partial<Record<K, SemanticGridOption | boolean>>;
+    transform?: TransformSpec[];
+    state?: Record<string, Partial<EncodeSpec>>;
+    animation?: Record<string, IAnimationConfig | IAnimationConfig[]>;
+    legend?: Record<string, {
+        option: SemanticLegendOption | boolean;
+        layout?: MarkRelativeItemSpec;
+    } | SemanticLegendOption | boolean>;
+    crosshair?: Record<string, SemanticCrosshairOption | boolean>;
+    tooltip?: SemanticTooltipOption | boolean;
+    slider?: Record<string, {
+        option: SemanticSliderOption | boolean;
+        layout?: MarkRelativeItemSpec;
+    } | SemanticSliderOption | boolean>;
+    datazoom?: Record<string, {
+        option: SemanticDataZoomOption | boolean;
+        layout?: MarkRelativeItemSpec;
+    } | SemanticDataZoomOption | boolean>;
+    label?: Record<string, SemanticLabelOption | boolean>;
+    player?: {
+        data?: any[];
+        option?: SemanticPlayerOption | boolean;
+        layout?: MarkRelativeItemSpec;
+    };
+    title?: {
+        option?: SemanticTitleOption;
+        layout?: MarkRelativeItemSpec;
+    } | SemanticTitleOption;
+}
+export type ParsedSimpleEncode<T, K extends string> = {
+    [Key in K]?: {
+        field: Key extends keyof T ? ISemanticEncodeValue<T[Key]> : ISemanticEncodeValue<string>;
+        scale: string;
+    };
+};
+export type SemanticEncodeChannels = 'x' | 'y' | 'group' | 'color';
+export type IntervalEncodeChannels = 'x' | 'y' | 'group' | 'color' | 'stroke';
+export type CellEncodeChannels = 'x' | 'y' | 'group' | 'color' | 'stroke';
+export type LineEncodeChannels = 'x' | 'y' | 'group' | 'color';
+export type AreaEncodeChannels = 'x' | 'y' | 'group' | 'color' | 'stroke';
+export type RuleXEncodeChannels = 'x' | 'x' | 'color' | 'group';
+export type RuleYEncodeChannels = 'x' | 'y' | 'color' | 'group';
+export type SymbolEncodeChannels = 'x' | 'y' | 'color' | 'group' | 'size' | 'shape' | 'stroke';
+export type TextEncodeChannels = 'x' | 'y' | 'color' | 'group' | 'text' | 'stroke';
+export type RectEncodeChannels = 'x' | 'y' | 'color' | 'group' | 'stroke';
+export type RectXEncodeChannels = 'x' | 'color' | 'group' | 'stroke';
+export type RectYEncodeChannels = 'y' | 'color' | 'group' | 'stroke';
+export type PolygonEncodeChannels = 'x' | 'y' | 'color' | 'group' | 'stroke';
+export type RuleEncodeChannels = 'x' | 'y' | 'color' | 'group';
+export type ImageEncodeChannels = 'x' | 'y' | 'color' | 'group' | 'src' | 'stroke';
+export type PathEncodeChannels = 'color' | 'stroke';
+export type SankeyEncodeChannels = 'node' | 'value' | 'color' | 'stroke';
+export type SunburstEncodeChannels = 'node' | 'value' | 'color' | 'stroke';
+export type TreeEncodeChannels = 'node' | 'value' | 'color' | 'stroke';
+export type TreemapEncodeChannels = 'node' | 'value' | 'color' | 'stroke';
+export type CirclepackingEncodeChannels = 'node' | 'value' | 'color' | 'stroke';
+export type WordcloudEncodeChannels = 'text' | 'color' | 'stroke';
+export type WordcloudShapeEncodeChannels = 'text' | 'color' | 'stroke';
+export type IInterval = ISemanticMark<PlotIntervalEncoderSpec, IntervalEncodeChannels>;
+export type ILine = ISemanticMark<BasicEncoderSpecMap['line'], LineEncodeChannels>;
+export type ICell = ISemanticMark<BasicEncoderSpecMap['cell'], CellEncodeChannels>;
+export type IRuleX = ISemanticMark<BasicEncoderSpecMap['rule'], RuleXEncodeChannels>;
+export type IRuleY = ISemanticMark<BasicEncoderSpecMap['rule'], RuleYEncodeChannels>;
+export type IArea = ISemanticMark<PlotAreaEncoderSpec, AreaEncodeChannels>;
+export type ISymbol = ISemanticMark<BasicEncoderSpecMap['symbol'], SymbolEncodeChannels>;
+export type IText = ISemanticMark<BasicEncoderSpecMap['text'], TextEncodeChannels>;
+export type IRect = ISemanticMark<PlotRectEncoderSpec, RectEncodeChannels>;
+export type IRectX = ISemanticMark<BasicEncoderSpecMap['rect'], RectXEncodeChannels>;
+export type IRectY = ISemanticMark<BasicEncoderSpecMap['rect'], RectYEncodeChannels>;
+export type IPolygon = ISemanticMark<PlotPolygonEncoderSpec, PolygonEncodeChannels>;
+export type IRule = ISemanticMark<BasicEncoderSpecMap['rule'], RuleEncodeChannels>;
+export type IImage = ISemanticMark<PlotImageEncoderSpec, ImageEncodeChannels>;
+export type IPath = ISemanticMark<BasicEncoderSpecMap['path'], PathEncodeChannels>;
+export type ISankey = ISemanticMark<PlotSankeyEncoderSpec, SankeyEncodeChannels>;
+export type ISunburst = ISemanticMark<PlotSunburstEncodeSpec, SunburstEncodeChannels>;
+export type IWordcloud = ISemanticMark<PlotWordcloudEncodeSpec, WordcloudEncodeChannels>;
+export type IWordcloudShape = ISemanticMark<PlotWordcloudShapeEncodeSpec, WordcloudShapeEncodeChannels>;
+export type ITree = ISemanticMark<PlotTreeEncodeSpec, TreeEncodeChannels>;
+export type ITreemap = ISemanticMark<PlotTreemapEncodeSpec, TreemapEncodeChannels>;
+export type ICirclePacking = ISemanticMark<PlotCirclePackingEncodeSpec, CirclepackingEncodeChannels>;
+export type PlotMark = IInterval | IRuleX | IRuleY | ICell | ILine | IArea | ISymbol | IText | IRect | IRectX | IRectY | IPolygon | IRule | IImage | IPath | ISankey | ISunburst | ICirclePacking | ITreemap | ITree | IWordcloud | IWordcloudShape;
+export interface IPlotMarkConstructor {
+    readonly type: string;
+    new (id?: string): PlotMark;
+}

package/cjs/types/plot.js

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

package/cjs/types/plot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/plot.ts"],"names":[],"mappings":"","file":"plot.js","sourcesContent":["import type {\n  AxisBaseAttributes,\n  BaseCrosshairAttrs,\n  BaseLabelAttrs,\n  ColorLegendAttributes,\n  DataZoomAttributes,\n  DiscreteLegendAttrs,\n  GridBaseAttributes,\n  PlayerAttributes,\n  SizeLegendAttributes,\n  SliderAttributes,\n  TitleAttrs\n} from '@visactor/vrender-components';\nimport type { CoordinateType } from '@visactor/vgrammar-coordinate';\nimport type { IColor } from '@visactor/vrender';\nimport type { IEnvironmentOptions, IRendererOptions, IRunningConfig, ViewSpec, srIOption3DType, IView } from './view';\nimport type { CommonPaddingSpec, ValueOf } from './base';\nimport type { BasicEncoderSpecMap, LinkPathEncoderSpec, MarkRelativeItemSpec } from './mark';\nimport type { BaseEventHandler } from './event';\nimport type { TransformSpec } from './transform';\nimport type { IAnimationConfig } from './animate';\nimport type { ScaleSpec } from './scale';\nimport type { DataSpec } from './data';\nimport type { GridShape } from './component';\n\nexport interface IPlotOptions extends IEnvironmentOptions, IRendererOptions {\n  width?: number;\n  height?: number;\n  padding?: CommonPaddingSpec;\n  autoFit?: boolean;\n  options3d?: srIOption3DType;\n  theme?: string;\n  logLevel?: number;\n}\n\nexport interface CartesianCoordinateOption {\n  id?: string;\n  type: 'cartesian';\n  transpose?: boolean;\n}\n\nexport interface PolarCoordinateOption {\n  id?: string;\n  type: 'polar';\n  origin?: [string | number, string | number];\n  transpose?: boolean;\n}\n\nexport type PlotIntervalEncoderSpec = Omit<BasicEncoderSpecMap['interval'], 'y'> & {\n  y?: number | number[];\n  y1?: number;\n  x1?: number;\n};\n\nexport type PlotRectEncoderSpec = Omit<BasicEncoderSpecMap['rect'], 'y' | 'x'> & {\n  y?: number | number[];\n  x?: number | number[];\n  y1?: number;\n  x1?: number;\n};\n\nexport type PlotRectXEncoderSpec = Omit<BasicEncoderSpecMap['rect'], 'x'> & {\n  x?: number | number[];\n  y1?: number;\n  x1?: number;\n};\n\nexport type PlotRectYEncoderSpec = Omit<BasicEncoderSpecMap['rect'], 'y'> & {\n  y?: number | number[];\n  y1?: number;\n  x1?: number;\n};\n\nexport type PlotAreaEncoderSpec = Omit<BasicEncoderSpecMap['area'], 'x' | 'y'> & {\n  x?: number | number[];\n  y?: number | number[];\n};\n\nexport type PlotRuleEncoderSpec = Omit<BasicEncoderSpecMap['rule'], 'x' | 'y'> & {\n  x?: number | number[];\n  y?: number | number[];\n};\n\nexport type PlotImageEncoderSpec = Omit<BasicEncoderSpecMap['image'], 'x' | 'y'> & {\n  x?: number | number[];\n  y?: number | number[];\n};\nexport type PlotPolygonEncoderSpec = Omit<BasicEncoderSpecMap['polygon'], 'x' | 'y'> & {\n  x?: number[];\n  y?: number[];\n};\n\nexport type PlotSankeyEncoderSpec = Partial<LinkPathEncoderSpec>;\nexport type PlotSunburstEncodeSpec = BasicEncoderSpecMap['arc'];\nexport type PlotTreeEncodeSpec = BasicEncoderSpecMap['symbol'];\nexport type PlotTreemapEncodeSpec = BasicEncoderSpecMap['rect'];\nexport type PlotCirclePackingEncodeSpec = BasicEncoderSpecMap['circle'];\nexport type PlotWordcloudEncodeSpec = BasicEncoderSpecMap['text'];\nexport type PlotWordcloudShapeEncodeSpec = BasicEncoderSpecMap['text'];\n\nexport type CoordinateOption = CartesianCoordinateOption | PolarCoordinateOption;\nexport type PlotIntervalSpec = Partial<ISemanticMarkSpec<PlotIntervalEncoderSpec, IntervalEncodeChannels>> & {\n  type: 'interval';\n};\nexport type PlotLineSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['line'], LineEncodeChannels>> & {\n  type: 'line';\n};\nexport type PlotCellSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['cell'], CellEncodeChannels>> & {\n  type: 'cell';\n};\nexport type PlotRuleXSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['rule'], RuleXEncodeChannels>> & {\n  type: 'ruleX';\n};\nexport type PlotRuleYSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['rule'], RuleYEncodeChannels>> & {\n  type: 'ruleY';\n};\nexport type PlotAreaSpec = Partial<ISemanticMarkSpec<PlotAreaEncoderSpec, AreaEncodeChannels>> & {\n  type: 'area';\n};\nexport type PlotSymbolSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['symbol'], SymbolEncodeChannels>> & {\n  type: 'symbol';\n};\nexport type PlotTextSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['text'], TextEncodeChannels>> & {\n  type: 'text';\n};\nexport type PlotRectSpec = Partial<ISemanticMarkSpec<PlotRectEncoderSpec, RectEncodeChannels>> & {\n  type: 'rect';\n};\nexport type PlotRectXSpec = Partial<ISemanticMarkSpec<PlotRectXEncoderSpec, RectXEncodeChannels>> & {\n  type: 'rectX';\n};\nexport type PlotRectYSpec = Partial<ISemanticMarkSpec<PlotRectYEncoderSpec, RectYEncodeChannels>> & {\n  type: 'rectY';\n};\nexport type PlotPolygonSpec = Partial<ISemanticMarkSpec<PlotPolygonEncoderSpec, PolygonEncodeChannels>> & {\n  type: 'polygon';\n};\nexport type PlotRuleSpec = Partial<ISemanticMarkSpec<PlotRuleEncoderSpec, RuleEncodeChannels>> & {\n  type: 'rule';\n};\nexport type PlotImageSpec = Partial<ISemanticMarkSpec<PlotImageEncoderSpec, ImageEncodeChannels>> & {\n  type: 'image';\n};\nexport type PlotPathSpec = Partial<ISemanticMarkSpec<BasicEncoderSpecMap['path'], PathEncodeChannels>> & {\n  type: 'path';\n};\n\nexport interface PlotSpec {\n  background?: IColor;\n  width?: number;\n  height?: number;\n  padding?: number;\n  coordinate?: CoordinateOption;\n  marks?: Array<\n    | PlotIntervalSpec\n    | PlotLineSpec\n    | PlotCellSpec\n    | PlotRuleXSpec\n    | PlotRuleYSpec\n    | PlotAreaSpec\n    | PlotSymbolSpec\n    | PlotTextSpec\n    | PlotRectSpec\n    | PlotRectXSpec\n    | PlotRectYSpec\n    | PlotPolygonSpec\n    | PlotRuleSpec\n    | PlotImageSpec\n    | PlotPathSpec\n  >;\n}\n\nexport interface IPlot {\n  readonly view: IView;\n\n  theme: (theme: string) => this;\n  /**\n   * todo: 直接接text图元还是title组件\n   */\n  // title: (text: ITextAttribute['text'], style: Omit<ITextAttribute, 'text'>) => this;\n  coordinate: (type: CoordinateType, option?: Omit<CoordinateOption, 'type'>) => this;\n  // interaction: (type: string, options: boolean | any) => this;\n\n  // facet: (type: string, options: any) => this;\n\n  ///--------- life cycle ---------///\n\n  run: (runningConfig?: IRunningConfig) => this;\n  runAsync: (runningConfig?: IRunningConfig) => Promise<this>;\n  release: () => this;\n  parseSpec: (spec: PlotSpec) => this;\n  updateSpec: (spec: PlotSpec) => this;\n  getImageBuffer: () => Buffer;\n\n  ///--------- events api ---------///\n  on: (type: string, handler: BaseEventHandler) => this;\n  off: (type: string, handler?: BaseEventHandler) => this;\n\n  ///--------- marks ---------///\n\n  interval: () => IInterval;\n  cell: () => ICell;\n  area: () => IArea;\n  image: () => IImage;\n  line: () => ILine;\n  ruleX: () => IRuleX;\n  ruleY: () => IRectY;\n  symbol: () => ISymbol;\n  polygon: () => IPolygon;\n  text: () => IText;\n  rect: () => IRect;\n  rectX: () => IRectX;\n  rectY: () => IRectY;\n  rule: () => IRule;\n\n  // wordcloud 包如果没注册，会存在问题\n  wordcloud: () => IWordcloud;\n  wordcloudShape: () => IWordcloudShape;\n  circlePacking: () => ICirclePacking;\n  treemap: () => ITreemap;\n  tree: () => ITree;\n  sunburst: () => ISunburst;\n  sankey: () => ISankey;\n\n  // P2\n  // forceGraph: () => ISemanticMark;\n  // geoPath: () => ISemanticMark;\n  // vector: () => ISemanticMark;\n  // shape: () => ISemanticMark;\n  // gauge: () => ISemanticMark;\n  // heatmap: () => ISemanticMark;\n  // density: () => ISemanticMark;\n  // boxplot: () => ISemanticMark;\n  // box: () => ISemanticMark;\n  // contour: () => ISemanticMark;\n\n  // observable auto define type by data\n  // auto: () => ISemanticMark;\n}\n\nexport interface IPlotConstructor {\n  new (options?: IPlotOptions): IPlot;\n}\n\nexport type WithDefaultEncode<T, K extends string> = {\n  [Key in K]?: Key extends keyof T ? ISemanticEncodeValue<T[Key]> : ISemanticEncodeValue<string | number>;\n};\nexport type ISemanticEncodeValue<T> = T extends any[]\n  ? string[] | ((datum: any) => any)[]\n  : string | ((datum: any) => T);\nexport type ISemanticEncodeSpec<T> = {\n  [Key in keyof T]?: ISemanticEncodeValue<T[Key]>;\n};\nexport type ISemanticStyle<T, K extends string> = Omit<T, K>;\n\nexport interface SemanticTooltipContentItem {\n  key?: ISemanticEncodeValue<string | number>;\n  value?: ISemanticEncodeValue<string | number>;\n  symbol?: ISemanticEncodeValue<string>;\n}\nexport type SemanticTooltipOption = {\n  disableGraphicTooltip?: boolean;\n  disableDimensionTooltip?: boolean;\n  staticTitle?: string;\n  staticContentKey?: string | string[];\n  title?: ISemanticEncodeValue<string | number>;\n  dimensionTooltipChannel?: 'x' | 'y';\n  content?: SemanticTooltipContentItem[];\n};\n\nexport interface SemanticAxisOption extends Partial<AxisBaseAttributes> {\n  tickCount?: number;\n}\n\nexport interface SemanticGridOption extends Partial<GridBaseAttributes> {\n  type?: GridShape;\n  tickCount?: number;\n  inside?: boolean;\n  baseValue?: number;\n  sides?: number;\n}\nexport type SemanticDataZoomOption = Partial<DataZoomAttributes>;\nexport type SemanticSliderOption = Partial<SliderAttributes>;\nexport type SemanticLegendOption = Partial<ColorLegendAttributes | DiscreteLegendAttrs | SizeLegendAttributes>;\nexport type SemanticCrosshairOption = Partial<BaseCrosshairAttrs>;\nexport type SemanticLabelOption = Partial<BaseLabelAttrs>;\nexport type SemanticPlayerOption = Partial<PlayerAttributes>;\nexport type SemanticTitleOption = Partial<TitleAttrs>;\n\nexport interface ISemanticMark<EncodeSpec, K extends string> {\n  readonly uid: number;\n  readonly type: string;\n  data: (values: any, transform?: TransformSpec[], id?: string) => this;\n  style: (style: Partial<EncodeSpec & any>) => this;\n  encode: (channel: K, option: ValueOf<WithDefaultEncode<EncodeSpec, K>, K>) => this;\n  scale: (channel: K, option: Partial<ScaleSpec>) => this;\n  transform: (option: TransformSpec[]) => this;\n  animate: (state: string, option: IAnimationConfig | IAnimationConfig[]) => this;\n  state: (state: string, option: Partial<EncodeSpec>) => this;\n\n  axis: (channel: string, option?: SemanticAxisOption | boolean, layout?: MarkRelativeItemSpec) => this;\n  legend: (channel: string, option?: SemanticLegendOption | boolean, layout?: MarkRelativeItemSpec) => this;\n  crosshair: (channel: string, option?: SemanticCrosshairOption | boolean) => this;\n  tooltip: (option: SemanticTooltipOption | boolean) => this;\n  coordinate: (option: CoordinateOption) => this;\n  grid: (channel: string, option?: SemanticGridOption | boolean) => this;\n  title: (option: SemanticTitleOption, layout?: MarkRelativeItemSpec) => this;\n\n  slider: (channel: string, option?: SemanticSliderOption | boolean, layout?: MarkRelativeItemSpec) => this;\n  datazoom: (channel: string, option?: SemanticDataZoomOption | boolean, layout?: MarkRelativeItemSpec) => this;\n  label: (channel: string, option?: SemanticLabelOption | boolean) => this;\n  player: (data?: any[], option?: SemanticPlayerOption | boolean, layout?: MarkRelativeItemSpec) => this;\n\n  toViewSpec: () => ViewSpec;\n  parseSpec: (spec: Partial<ISemanticMarkSpec<EncodeSpec, K>>) => this;\n}\n\nexport interface ISemanticMarkSpec<EncodeSpec, K extends string> {\n  id: string | number;\n  data?: DataSpec;\n  encode?: WithDefaultEncode<EncodeSpec, K>;\n  scale?: Partial<Record<K, ScaleSpec>>;\n  style?: Partial<EncodeSpec & any>;\n  axis?: Partial<\n    Record<K, { option?: SemanticAxisOption | boolean; layout?: MarkRelativeItemSpec } | SemanticAxisOption | boolean>\n  >;\n  grid?: Partial<Record<K, SemanticGridOption | boolean>>;\n  transform?: TransformSpec[];\n  state?: Record<string, Partial<EncodeSpec>>;\n  animation?: Record<string, IAnimationConfig | IAnimationConfig[]>;\n  legend?: Record<\n    string,\n    { option: SemanticLegendOption | boolean; layout?: MarkRelativeItemSpec } | SemanticLegendOption | boolean\n  >;\n  crosshair?: Record<string, SemanticCrosshairOption | boolean>;\n  tooltip?: SemanticTooltipOption | boolean;\n  slider?: Record<\n    string,\n    { option: SemanticSliderOption | boolean; layout?: MarkRelativeItemSpec } | SemanticSliderOption | boolean\n  >;\n  datazoom?: Record<\n    string,\n    { option: SemanticDataZoomOption | boolean; layout?: MarkRelativeItemSpec } | SemanticDataZoomOption | boolean\n  >;\n  label?: Record<string, SemanticLabelOption | boolean>;\n  player?: { data?: any[]; option?: SemanticPlayerOption | boolean; layout?: MarkRelativeItemSpec };\n  title?: { option?: SemanticTitleOption; layout?: MarkRelativeItemSpec } | SemanticTitleOption;\n}\n\nexport type ParsedSimpleEncode<T, K extends string> = {\n  [Key in K]?: {\n    field: Key extends keyof T ? ISemanticEncodeValue<T[Key]> : ISemanticEncodeValue<string>;\n    scale: string;\n  };\n};\n\nexport type SemanticEncodeChannels = 'x' | 'y' | 'group' | 'color';\nexport type IntervalEncodeChannels = 'x' | 'y' | 'group' | 'color' | 'stroke';\nexport type CellEncodeChannels = 'x' | 'y' | 'group' | 'color' | 'stroke';\nexport type LineEncodeChannels = 'x' | 'y' | 'group' | 'color';\nexport type AreaEncodeChannels = 'x' | 'y' | 'group' | 'color' | 'stroke';\nexport type RuleXEncodeChannels = 'x' | 'x' | 'color' | 'group';\nexport type RuleYEncodeChannels = 'x' | 'y' | 'color' | 'group';\nexport type SymbolEncodeChannels = 'x' | 'y' | 'color' | 'group' | 'size' | 'shape' | 'stroke';\nexport type TextEncodeChannels = 'x' | 'y' | 'color' | 'group' | 'text' | 'stroke';\nexport type RectEncodeChannels = 'x' | 'y' | 'color' | 'group' | 'stroke';\nexport type RectXEncodeChannels = 'x' | 'color' | 'group' | 'stroke';\nexport type RectYEncodeChannels = 'y' | 'color' | 'group' | 'stroke';\nexport type PolygonEncodeChannels = 'x' | 'y' | 'color' | 'group' | 'stroke';\nexport type RuleEncodeChannels = 'x' | 'y' | 'color' | 'group';\nexport type ImageEncodeChannels = 'x' | 'y' | 'color' | 'group' | 'src' | 'stroke';\nexport type PathEncodeChannels = 'color' | 'stroke';\nexport type SankeyEncodeChannels = 'node' | 'value' | 'color' | 'stroke';\nexport type SunburstEncodeChannels = 'node' | 'value' | 'color' | 'stroke';\nexport type TreeEncodeChannels = 'node' | 'value' | 'color' | 'stroke';\nexport type TreemapEncodeChannels = 'node' | 'value' | 'color' | 'stroke';\nexport type CirclepackingEncodeChannels = 'node' | 'value' | 'color' | 'stroke';\nexport type WordcloudEncodeChannels = 'text' | 'color' | 'stroke';\nexport type WordcloudShapeEncodeChannels = 'text' | 'color' | 'stroke';\n\nexport type IInterval = ISemanticMark<PlotIntervalEncoderSpec, IntervalEncodeChannels>;\nexport type ILine = ISemanticMark<BasicEncoderSpecMap['line'], LineEncodeChannels>;\nexport type ICell = ISemanticMark<BasicEncoderSpecMap['cell'], CellEncodeChannels>;\nexport type IRuleX = ISemanticMark<BasicEncoderSpecMap['rule'], RuleXEncodeChannels>;\nexport type IRuleY = ISemanticMark<BasicEncoderSpecMap['rule'], RuleYEncodeChannels>;\nexport type IArea = ISemanticMark<PlotAreaEncoderSpec, AreaEncodeChannels>;\nexport type ISymbol = ISemanticMark<BasicEncoderSpecMap['symbol'], SymbolEncodeChannels>;\nexport type IText = ISemanticMark<BasicEncoderSpecMap['text'], TextEncodeChannels>;\nexport type IRect = ISemanticMark<PlotRectEncoderSpec, RectEncodeChannels>;\nexport type IRectX = ISemanticMark<BasicEncoderSpecMap['rect'], RectXEncodeChannels>;\nexport type IRectY = ISemanticMark<BasicEncoderSpecMap['rect'], RectYEncodeChannels>;\nexport type IPolygon = ISemanticMark<PlotPolygonEncoderSpec, PolygonEncodeChannels>;\nexport type IRule = ISemanticMark<BasicEncoderSpecMap['rule'], RuleEncodeChannels>;\nexport type IImage = ISemanticMark<PlotImageEncoderSpec, ImageEncodeChannels>;\nexport type IPath = ISemanticMark<BasicEncoderSpecMap['path'], PathEncodeChannels>;\nexport type ISankey = ISemanticMark<PlotSankeyEncoderSpec, SankeyEncodeChannels>;\nexport type ISunburst = ISemanticMark<PlotSunburstEncodeSpec, SunburstEncodeChannels>;\nexport type IWordcloud = ISemanticMark<PlotWordcloudEncodeSpec, WordcloudEncodeChannels>;\nexport type IWordcloudShape = ISemanticMark<PlotWordcloudShapeEncodeSpec, WordcloudShapeEncodeChannels>;\nexport type ITree = ISemanticMark<PlotTreeEncodeSpec, TreeEncodeChannels>;\nexport type ITreemap = ISemanticMark<PlotTreemapEncodeSpec, TreemapEncodeChannels>;\nexport type ICirclePacking = ISemanticMark<PlotCirclePackingEncodeSpec, CirclepackingEncodeChannels>;\n\nexport type PlotMark =\n  | IInterval\n  | IRuleX\n  | IRuleY\n  | ICell\n  | ILine\n  | IArea\n  | ISymbol\n  | IText\n  | IRect\n  | IRectX\n  | IRectY\n  | IPolygon\n  | IRule\n  | IImage\n  | IPath\n  | ISankey\n  | ISunburst\n  | ICirclePacking\n  | ITreemap\n  | ITree\n  | IWordcloud\n  | IWordcloudShape;\n\nexport interface IPlotMarkConstructor {\n  readonly type: string;\n\n  new (id?: string): PlotMark;\n}\n"]}

package/cjs/types/projection.d.ts

@@ -0,0 +1,61 @@
+import type { GrammarSpec, IGrammarBase } from './grammar';
+import type { GenericFunctionType } from './signal';
+import type { Nil } from './base';
+export type GeoJsonFeatureSpec = any;
+export type GeoJsonFeatureCollectionSpec = any;
+export type FitSpec = GeoJsonFeatureSpec | GeoJsonFeatureCollectionSpec | GeoJsonFeatureSpec[];
+export type ProjectionType = 'albers' | 'albersUsa' | 'azimuthalEqualArea' | 'azimuthalEquidistant' | 'conicConformal' | 'conicEqualArea' | 'conicEquidistant' | 'equalEarth' | 'equirectangular' | 'gnomonic' | 'identity' | 'mercator' | 'naturalEarth1' | 'orthographic' | 'stereographic' | 'transverseMercator';
+export interface BaseProjectionSpec extends GrammarSpec {
+    type: string;
+    pointRadius?: ProjectionFunctionType<number>;
+    extent?: ProjectionFunctionType<[[number, number], [number, number]]>;
+    fit?: ProjectionFunctionType<FeatureCollectionData | FeatureCollectionData[] | FeatureData | FeatureData[] | GeometryData | GeometryData[]>;
+    size?: ProjectionFunctionType<[number, number]>;
+    clipAngle?: ProjectionFunctionType<number>;
+    clipExtent?: ProjectionFunctionType<[number, number]>;
+    scale?: ProjectionFunctionType<number>;
+    translate?: ProjectionFunctionType<[number, number]>;
+    center?: ProjectionFunctionType<[number, number]>;
+    rotate?: ProjectionFunctionType<[number, number] | [number, number, number]>;
+    parallels?: ProjectionFunctionType<[number, number]>;
+    precision?: ProjectionFunctionType<number>;
+    reflectX?: ProjectionFunctionType<boolean>;
+    reflectY?: ProjectionFunctionType<number>;
+    coefficient?: ProjectionFunctionType<number>;
+    distance?: ProjectionFunctionType<number>;
+    fraction?: ProjectionFunctionType<number>;
+    lobes?: ProjectionFunctionType<number>;
+    parallel?: ProjectionFunctionType<number>;
+    radius?: ProjectionFunctionType<number>;
+    ratio?: ProjectionFunctionType<number>;
+    spacing?: ProjectionFunctionType<number>;
+    tilt?: ProjectionFunctionType<number>;
+}
+export interface ProjectionSpec extends BaseProjectionSpec {
+    name?: string;
+}
+export interface IProjection extends IGrammarBase {
+    grammarType: 'projection';
+    parse: (spec: ProjectionSpec) => this;
+    pointRadius: (spec: ProjectionSpec['pointRadius']) => this;
+    size: (spec: ProjectionSpec['size']) => this;
+    fit: (spec: ProjectionSpec['fit']) => this;
+    extent: (spec: ProjectionSpec['extent']) => this;
+    configure: (spec: Omit<ProjectionSpec, 'fit' | 'extent' | 'size' | 'pointRadius'> | Nil) => this;
+}
+export interface GeometryData {
+    type: 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon' | 'GeometryCollection';
+    coordinates?: [number, number] | [number, number][] | [number, number][][] | [number, number][][][];
+    arcs?: number[][];
+}
+export interface FeatureData {
+    type: 'Feature';
+    geometry: GeometryData;
+    properties?: Record<string, any>;
+}
+export interface FeatureCollectionData {
+    type: 'FeatureCollection';
+    features: FeatureData[];
+}
+export type ProjectionFunctionCallback<T> = (projection: any, parameters: any) => T;
+export type ProjectionFunctionType<T> = GenericFunctionType<ProjectionFunctionCallback<T>, T>;

package/cjs/types/projection.js

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

package/cjs/types/projection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/projection.ts"],"names":[],"mappings":"","file":"projection.js","sourcesContent":["import type { GrammarSpec, IGrammarBase } from './grammar';\nimport type { GenericFunctionType } from './signal';\nimport type { Nil } from './base';\n\nexport type GeoJsonFeatureSpec = any; // TODO\nexport type GeoJsonFeatureCollectionSpec = any; // TODO\nexport type FitSpec = GeoJsonFeatureSpec | GeoJsonFeatureCollectionSpec | GeoJsonFeatureSpec[];\nexport type ProjectionType =\n  | 'albers'\n  | 'albersUsa'\n  | 'azimuthalEqualArea'\n  | 'azimuthalEquidistant'\n  | 'conicConformal'\n  | 'conicEqualArea'\n  | 'conicEquidistant'\n  | 'equalEarth'\n  | 'equirectangular'\n  | 'gnomonic'\n  | 'identity'\n  | 'mercator'\n  | 'naturalEarth1'\n  | 'orthographic'\n  | 'stereographic'\n  | 'transverseMercator';\n\nexport interface BaseProjectionSpec extends GrammarSpec {\n  type: string;\n  pointRadius?: ProjectionFunctionType<number>;\n  extent?: ProjectionFunctionType<[[number, number], [number, number]]>;\n  fit?: ProjectionFunctionType<\n    FeatureCollectionData | FeatureCollectionData[] | FeatureData | FeatureData[] | GeometryData | GeometryData[]\n  >;\n  size?: ProjectionFunctionType<[number, number]>;\n\n  // standard properties in d3-geo\n\n  clipAngle?: ProjectionFunctionType<number>;\n  clipExtent?: ProjectionFunctionType<[number, number]>;\n  scale?: ProjectionFunctionType<number>;\n  translate?: ProjectionFunctionType<[number, number]>;\n  center?: ProjectionFunctionType<[number, number]>;\n  rotate?: ProjectionFunctionType<[number, number] | [number, number, number]>;\n  parallels?: ProjectionFunctionType<[number, number]>;\n  precision?: ProjectionFunctionType<number>;\n  reflectX?: ProjectionFunctionType<boolean>;\n  reflectY?: ProjectionFunctionType<number>;\n\n  // extended properties in d3-geo-projections\n\n  coefficient?: ProjectionFunctionType<number>;\n  distance?: ProjectionFunctionType<number>;\n  fraction?: ProjectionFunctionType<number>;\n  lobes?: ProjectionFunctionType<number>;\n  parallel?: ProjectionFunctionType<number>;\n  radius?: ProjectionFunctionType<number>;\n  ratio?: ProjectionFunctionType<number>;\n  spacing?: ProjectionFunctionType<number>;\n  tilt?: ProjectionFunctionType<number>;\n}\nexport interface ProjectionSpec extends BaseProjectionSpec {\n  /*\n   * The name of the projection.\n   */\n  name?: string;\n}\n\nexport interface IProjection extends IGrammarBase {\n  grammarType: 'projection';\n  parse: (spec: ProjectionSpec) => this;\n  pointRadius: (spec: ProjectionSpec['pointRadius']) => this;\n  size: (spec: ProjectionSpec['size']) => this;\n  fit: (spec: ProjectionSpec['fit']) => this;\n  extent: (spec: ProjectionSpec['extent']) => this;\n  configure: (spec: Omit<ProjectionSpec, 'fit' | 'extent' | 'size' | 'pointRadius'> | Nil) => this;\n}\n\nexport interface GeometryData {\n  type: 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon' | 'GeometryCollection';\n  coordinates?: [number, number] | [number, number][] | [number, number][][] | [number, number][][][];\n  arcs?: number[][];\n}\n\nexport interface FeatureData {\n  type: 'Feature';\n  geometry: GeometryData;\n  properties?: Record<string, any>;\n}\n\nexport interface FeatureCollectionData {\n  type: 'FeatureCollection';\n  features: FeatureData[];\n}\n\nexport type ProjectionFunctionCallback<T> = (projection: any, parameters: any) => T;\n\nexport type ProjectionFunctionType<T> = GenericFunctionType<ProjectionFunctionCallback<T>, T>;\n"]}

package/cjs/types/renderer.d.ts

@@ -0,0 +1,19 @@
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IColor, Stage } from '@visactor/vrender';
+import type { IViewEventConfig, IViewOptions } from './view';
+export interface IRenderer {
+    initialize: (width: number, height: number, options: IViewOptions, eventConfig: IViewEventConfig) => this;
+    render: (immediately?: boolean) => this;
+    renderNextFrame: () => this;
+    resize: (width: number, height: number) => this;
+    shouldResize: (width: number, height: number) => boolean;
+    combineIncrementalLayers: () => this;
+    setDpr: (resolution: number, redraw: boolean) => this;
+    background: (color: IColor) => this;
+    setViewBox: (viewBox: IBoundsLike, rerender: boolean) => this;
+    stage: () => Stage;
+    canvas: () => HTMLCanvasElement;
+    context: () => CanvasRenderingContext2D;
+    toCanvas: () => HTMLCanvasElement;
+    release: () => void;
+}

package/cjs/types/renderer.js

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

package/cjs/types/renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/renderer.ts"],"names":[],"mappings":"","file":"renderer.js","sourcesContent":["import type { IBoundsLike } from '@visactor/vutils';\nimport type { IColor, Stage } from '@visactor/vrender';\nimport type { IViewEventConfig, IViewOptions } from './view';\n\nexport interface IRenderer {\n  initialize: (width: number, height: number, options: IViewOptions, eventConfig: IViewEventConfig) => this;\n\n  render: (immediately?: boolean) => this;\n  renderNextFrame: () => this;\n  resize: (width: number, height: number) => this;\n  shouldResize: (width: number, height: number) => boolean;\n  combineIncrementalLayers: () => this;\n\n  setDpr: (resolution: number, redraw: boolean) => this;\n  background: (color: IColor) => this;\n  setViewBox: (viewBox: IBoundsLike, rerender: boolean) => this;\n\n  stage: () => Stage;\n  canvas: () => HTMLCanvasElement;\n  context: () => CanvasRenderingContext2D;\n\n  toCanvas: () => HTMLCanvasElement;\n  // toImageData: () => Promise<ImageData | undefined>;\n\n  release: () => void;\n}\n"]}

package/cjs/types/scale.d.ts

@@ -0,0 +1,111 @@
+import type { IBaseScale, ScaleType } from '@visactor/vscale';
+import type { DistributiveOmit } from './base';
+import type { GrammarSpec, IData } from './grammar';
+import type { GenericFunctionType } from './signal';
+import type { IDimensionType } from '@visactor/vgrammar-coordinate';
+export type ScaleFunctionCallback<T> = (scale: IBaseScale, parameters: any) => T;
+export type ScaleFunctionType<T> = GenericFunctionType<ScaleFunctionCallback<T>, T>;
+export type ScaleData = {
+    data: string | IData;
+    field: string | string[];
+    sort?: (datumA: any, datumB: any) => number;
+};
+export type MultiScaleData = {
+    datas: {
+        data: string | IData;
+        field: string | string[];
+    }[];
+    sort?: (datumA: any, datumB: any) => number;
+};
+export type ScaleCoordinate = {
+    coordinate: string;
+    dimension: IDimensionType;
+    isSubshaft?: boolean;
+    reversed?: boolean;
+};
+export type GrammarScaleType = ScaleType | 'utc';
+export interface BaseScaleSpec extends GrammarSpec {
+    name?: string;
+    type: GrammarScaleType;
+    domain?: ScaleData | MultiScaleData | ScaleFunctionType<any[]>;
+    unknown?: ScaleFunctionType<any>;
+}
+export interface ScaleTicksSpec {
+    nice?: ScaleFunctionType<boolean | number>;
+    niceMax?: ScaleFunctionType<boolean | number>;
+    niceMin?: ScaleFunctionType<boolean | number>;
+}
+export interface ScaleDomainSpec {
+    min?: ScaleFunctionType<number>;
+    max?: ScaleFunctionType<number>;
+    zero?: ScaleFunctionType<boolean>;
+}
+export interface DiscreteScaleSpec extends BaseScaleSpec {
+    range?: ScaleFunctionType<any[]> | ScaleData | MultiScaleData | ScaleCoordinate;
+}
+export interface OrdinalScaleSpec extends DiscreteScaleSpec {
+    type: 'ordinal';
+}
+export interface BaseBandScaleSpec extends DiscreteScaleSpec {
+    round?: ScaleFunctionType<boolean>;
+    padding?: ScaleFunctionType<number>;
+    paddingInner?: ScaleFunctionType<number>;
+    paddingOuter?: ScaleFunctionType<number>;
+    align?: ScaleFunctionType<number>;
+}
+export interface BandScaleSpec extends BaseBandScaleSpec {
+    type: 'band';
+}
+export interface PointScaleSpec extends BaseBandScaleSpec {
+    type: 'point';
+}
+export interface ContinuousScaleSpec extends BaseScaleSpec, ScaleDomainSpec {
+    range?: ScaleFunctionType<number[]> | ScaleData | MultiScaleData | ScaleCoordinate;
+    roundRange?: ScaleFunctionType<boolean>;
+    config?: {
+        clamp?: boolean | ((x: number) => any);
+        interpolate?: (t: number) => any;
+    };
+}
+export interface LinearScaleSpec extends ContinuousScaleSpec, ScaleTicksSpec {
+    type: 'linear';
+}
+export interface PowScaleSpec extends ContinuousScaleSpec, ScaleTicksSpec {
+    type: 'pow';
+    exponent?: ScaleFunctionType<number>;
+}
+export interface LogScaleSpec extends ContinuousScaleSpec, Pick<ScaleTicksSpec, 'nice'> {
+    type: 'log';
+    base?: ScaleFunctionType<number>;
+}
+export interface SqrtScaleSpec extends ContinuousScaleSpec, ScaleTicksSpec {
+    type: 'sqrt';
+}
+export interface SymlogScaleSpec extends ContinuousScaleSpec, ScaleTicksSpec {
+    type: 'symlog';
+    constant?: ScaleFunctionType<number>;
+}
+export interface TimeScaleSpec extends ContinuousScaleSpec, Pick<ScaleTicksSpec, 'nice'> {
+    type: 'time';
+}
+export interface UtcTimeScaleSpec extends ContinuousScaleSpec, Pick<ScaleTicksSpec, 'nice'> {
+    type: 'utc';
+}
+export interface QuantizeScaleSpec extends BaseScaleSpec, ScaleTicksSpec, ScaleDomainSpec {
+    type: 'quantize';
+    range?: ScaleFunctionType<any[]> | ScaleData | MultiScaleData;
+}
+export interface QuantileScaleSpec extends BaseScaleSpec {
+    type: 'quantile';
+    range?: ScaleFunctionType<any[]> | ScaleData | MultiScaleData;
+}
+export interface ThresholdScaleSpec extends BaseScaleSpec {
+    type: 'threshold';
+    range?: ScaleFunctionType<any[]> | ScaleData | MultiScaleData;
+}
+export interface IdentityScaleSpec extends BaseScaleSpec {
+    type: 'identity';
+    range?: ScaleFunctionType<any[]> | ScaleData | MultiScaleData;
+}
+export type ScaleSpec = OrdinalScaleSpec | BandScaleSpec | PointScaleSpec | LinearScaleSpec | PowScaleSpec | LogScaleSpec | SqrtScaleSpec | SymlogScaleSpec | TimeScaleSpec | UtcTimeScaleSpec | QuantizeScaleSpec | QuantileScaleSpec | ThresholdScaleSpec | IdentityScaleSpec;
+export type ScaleConfigureSpec = DistributiveOmit<ScaleSpec, 'type'>;

package/cjs/types/scale.js

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

package/cjs/types/scale.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/scale.ts"],"names":[],"mappings":"","file":"scale.js","sourcesContent":["import type { IBaseScale, ScaleType } from '@visactor/vscale';\nimport type { DistributiveOmit } from './base';\nimport type { GrammarSpec, IData } from './grammar';\nimport type { GenericFunctionType } from './signal';\nimport type { IDimensionType } from '@visactor/vgrammar-coordinate';\n\nexport type ScaleFunctionCallback<T> = (scale: IBaseScale, parameters: any) => T;\n\nexport type ScaleFunctionType<T> = GenericFunctionType<ScaleFunctionCallback<T>, T>;\n\nexport type ScaleData = { data: string | IData; field: string | string[]; sort?: (datumA: any, datumB: any) => number };\nexport type MultiScaleData = {\n  datas: {\n    data: string | IData;\n    field: string | string[];\n  }[];\n  sort?: (datumA: any, datumB: any) => number;\n};\n\nexport type ScaleCoordinate = {\n  coordinate: string;\n  dimension: IDimensionType;\n  isSubshaft?: boolean;\n  reversed?: boolean;\n};\n\nexport type GrammarScaleType = ScaleType | 'utc';\n\nexport interface BaseScaleSpec extends GrammarSpec {\n  name?: string;\n  type: GrammarScaleType;\n  domain?: ScaleData | MultiScaleData | ScaleFunctionType<any[]>;\n  unknown?: ScaleFunctionType<any>;\n}\n\nexport interface ScaleTicksSpec {\n  nice?: ScaleFunctionType<boolean | number>;\n  niceMax?: ScaleFunctionType<boolean | number>;\n  niceMin?: ScaleFunctionType<boolean | number>;\n}\n\nexport interface ScaleDomainSpec {\n  min?: ScaleFunctionType<number>;\n  max?: ScaleFunctionType<number>;\n  zero?: ScaleFunctionType<boolean>;\n}\n/** Discrete Scale */\n\nexport interface DiscreteScaleSpec extends BaseScaleSpec {\n  range?: ScaleFunctionType<any[]> | ScaleData | MultiScaleData | ScaleCoordinate;\n}\n\nexport interface OrdinalScaleSpec extends DiscreteScaleSpec {\n  type: 'ordinal';\n}\n\nexport interface BaseBandScaleSpec extends DiscreteScaleSpec {\n  round?: ScaleFunctionType<boolean>;\n  padding?: ScaleFunctionType<number>;\n  paddingInner?: ScaleFunctionType<number>;\n  paddingOuter?: ScaleFunctionType<number>;\n  align?: ScaleFunctionType<number>;\n}\n\nexport interface BandScaleSpec extends BaseBandScaleSpec {\n  type: 'band';\n}\n\nexport interface PointScaleSpec extends BaseBandScaleSpec {\n  type: 'point';\n}\n\n/** Continuous Scale */\n\nexport interface ContinuousScaleSpec extends BaseScaleSpec, ScaleDomainSpec {\n  range?: ScaleFunctionType<number[]> | ScaleData | MultiScaleData | ScaleCoordinate;\n  roundRange?: ScaleFunctionType<boolean>;\n  config?: {\n    clamp?: boolean | ((x: number) => any);\n    interpolate?: (t: number) => any;\n  };\n}\n\nexport interface LinearScaleSpec extends ContinuousScaleSpec, ScaleTicksSpec {\n  type: 'linear';\n}\n\nexport interface PowScaleSpec extends ContinuousScaleSpec, ScaleTicksSpec {\n  type: 'pow';\n  /**\n   * the exponent of the power\n   */\n  exponent?: ScaleFunctionType<number>;\n}\n\nexport interface LogScaleSpec extends ContinuousScaleSpec, Pick<ScaleTicksSpec, 'nice'> {\n  type: 'log';\n  /**\n   * the base of the log, e.g. 10,the number shoudl be greater than 0\n   */\n  base?: ScaleFunctionType<number>;\n}\n\nexport interface SqrtScaleSpec extends ContinuousScaleSpec, ScaleTicksSpec {\n  type: 'sqrt';\n}\n\nexport interface SymlogScaleSpec extends ContinuousScaleSpec, ScaleTicksSpec {\n  type: 'symlog';\n  constant?: ScaleFunctionType<number>;\n}\n\nexport interface TimeScaleSpec extends ContinuousScaleSpec, Pick<ScaleTicksSpec, 'nice'> {\n  type: 'time';\n}\n\nexport interface UtcTimeScaleSpec extends ContinuousScaleSpec, Pick<ScaleTicksSpec, 'nice'> {\n  type: 'utc';\n}\n\nexport interface QuantizeScaleSpec extends BaseScaleSpec, ScaleTicksSpec, ScaleDomainSpec {\n  type: 'quantize';\n  range?: ScaleFunctionType<any[]> | ScaleData | MultiScaleData;\n}\n\n/**\n * quantile scale adopts a different method to evaluate the thresholds,\n * by slicing the domain into intervals of (roughly) equal absolute frequency (i.e. number of individuals)\n */\nexport interface QuantileScaleSpec extends BaseScaleSpec {\n  type: 'quantile';\n  range?: ScaleFunctionType<any[]> | ScaleData | MultiScaleData;\n}\n\n/**\n * the threshold scale\n */\nexport interface ThresholdScaleSpec extends BaseScaleSpec {\n  type: 'threshold';\n  range?: ScaleFunctionType<any[]> | ScaleData | MultiScaleData;\n}\n\n/**\n * the threshold scale\n */\nexport interface IdentityScaleSpec extends BaseScaleSpec {\n  type: 'identity';\n  range?: ScaleFunctionType<any[]> | ScaleData | MultiScaleData;\n}\n\nexport type ScaleSpec =\n  | OrdinalScaleSpec\n  | BandScaleSpec\n  | PointScaleSpec\n  | LinearScaleSpec\n  | PowScaleSpec\n  | LogScaleSpec\n  | SqrtScaleSpec\n  | SymlogScaleSpec\n  | TimeScaleSpec\n  | UtcTimeScaleSpec\n  | QuantizeScaleSpec\n  | QuantileScaleSpec\n  | ThresholdScaleSpec\n  | IdentityScaleSpec;\n\nexport type ScaleConfigureSpec = DistributiveOmit<ScaleSpec, 'type'>;\n"]}

package/cjs/types/signal.d.ts

@@ -0,0 +1,20 @@
+import type { GrammarSpec, IScale, ISignal } from './grammar';
+export type FunctionCallback<T> = (...args: any[]) => T;
+export type SignalDependency = string | ISignal<any> | IScale;
+export interface SignalFunction<Callback extends FunctionCallback<T>, T> {
+    callback: Callback;
+    dependency?: SignalDependency | SignalDependency[];
+}
+export interface SignalReference<T = any> {
+    signal: string | ISignal<T>;
+}
+export type GenericFunctionType<Callback extends FunctionCallback<T>, T> = T | Callback | SignalReference<T> | SignalFunction<Callback, T>;
+export type ParameterCallback<T> = (parameters: any) => T;
+export type ParameterFunctionType<T> = GenericFunctionType<ParameterCallback<T>, T>;
+export type SignalFunctionCallback<T> = (signal: T, parameters: any) => T;
+export type SignalFunctionType<T> = GenericFunctionType<SignalFunctionCallback<T>, T>;
+export interface SignalSpec<T> extends GrammarSpec {
+    name?: string;
+    value?: T;
+    update?: SignalFunctionType<T>;
+}