@visactor/vgrammar-core 0.7.0

package/es/types/theme.d.ts

@@ -0,0 +1,41 @@
+import type { IColor } from '@visactor/vrender';
+import type { ArcLabelAttrs, BaseLabelAttrs, CircleAxisAttributes, CircleAxisGridAttributes, CircleCrosshairAttrs, ColorLegendAttributes, ContinuousPlayerAttributes, DataLabelAttrs, DataZoomAttributes, DiscreteLegendAttrs, DiscretePlayerAttributes, LineAxisAttributes, LineAxisGridAttributes, LineCrosshairAttrs, LineLabelAttrs, PolygonCrosshairAttrs, RectCrosshairAttrs, RectLabelAttrs, ScrollBarAttributes, SectorCrosshairAttrs, SizeLegendAttributes, SliderAttributes, SymbolLabelAttrs, TitleAttrs, TooltipAttributes } from '@visactor/vrender-components';
+import type { IPadding } from '@visactor/vutils';
+import type { RecursivePartial } from './base';
+import type { BasicEncoderSpecMap } from './mark';
+export type IMarkTheme = Partial<Omit<BasicEncoderSpecMap, 'glyph'>>;
+export interface IComponentTheme {
+    axis?: RecursivePartial<LineAxisAttributes>;
+    circleAxis?: RecursivePartial<CircleAxisAttributes>;
+    grid?: RecursivePartial<LineAxisGridAttributes>;
+    circleGrid?: RecursivePartial<CircleAxisGridAttributes>;
+    discreteLegend?: RecursivePartial<DiscreteLegendAttrs>;
+    colorLegend?: RecursivePartial<ColorLegendAttributes>;
+    sizeLegend?: RecursivePartial<SizeLegendAttributes>;
+    lineCrosshair?: RecursivePartial<LineCrosshairAttrs>;
+    rectCrosshair?: RecursivePartial<RectCrosshairAttrs>;
+    sectorCrosshair?: RecursivePartial<SectorCrosshairAttrs>;
+    circleCrosshair?: RecursivePartial<CircleCrosshairAttrs>;
+    polygonCrosshair?: RecursivePartial<PolygonCrosshairAttrs>;
+    slider?: RecursivePartial<SliderAttributes>;
+    dataLabel?: RecursivePartial<DataLabelAttrs>;
+    lineLabel?: RecursivePartial<LineLabelAttrs>;
+    rectLabel?: RecursivePartial<RectLabelAttrs>;
+    arcLabel?: RecursivePartial<ArcLabelAttrs>;
+    symbolLabel?: RecursivePartial<SymbolLabelAttrs>;
+    pointLabel?: RecursivePartial<BaseLabelAttrs>;
+    datazoom?: RecursivePartial<DataZoomAttributes>;
+    continuousPlayer?: RecursivePartial<ContinuousPlayerAttributes>;
+    discretePlayer?: RecursivePartial<DiscretePlayerAttributes>;
+    tooltip?: RecursivePartial<TooltipAttributes>;
+    title?: RecursivePartial<TitleAttrs>;
+    scrollbar?: RecursivePartial<ScrollBarAttributes>;
+}
+export interface ITheme {
+    name?: string;
+    background?: IColor;
+    padding?: IPadding | number;
+    palette?: Record<string, IColor[]>;
+    marks?: IMarkTheme;
+    components?: IComponentTheme;
+}

package/es/types/theme.js

@@ -0,0 +1,2 @@
+export { };
+//# sourceMappingURL=theme.js.map

package/es/types/theme.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/theme.ts"],"names":[],"mappings":"","file":"theme.js","sourcesContent":["import type { IColor } from '@visactor/vrender';\nimport type {\n  ArcLabelAttrs,\n  BaseLabelAttrs,\n  CircleAxisAttributes,\n  CircleAxisGridAttributes,\n  CircleCrosshairAttrs,\n  ColorLegendAttributes,\n  ContinuousPlayerAttributes,\n  DataLabelAttrs,\n  DataZoomAttributes,\n  DiscreteLegendAttrs,\n  DiscretePlayerAttributes,\n  LineAxisAttributes,\n  LineAxisGridAttributes,\n  LineCrosshairAttrs,\n  LineLabelAttrs,\n  PolygonCrosshairAttrs,\n  RectCrosshairAttrs,\n  RectLabelAttrs,\n  ScrollBarAttributes,\n  SectorCrosshairAttrs,\n  SizeLegendAttributes,\n  SliderAttributes,\n  SymbolLabelAttrs,\n  TitleAttrs,\n  TooltipAttributes\n} from '@visactor/vrender-components';\nimport type { IPadding } from '@visactor/vutils';\nimport type { RecursivePartial } from './base';\nimport type { BasicEncoderSpecMap } from './mark';\n\n// glyph mark includes multiple types, not support theme for glyph for now\nexport type IMarkTheme = Partial<Omit<BasicEncoderSpecMap, 'glyph'>>;\n\nexport interface IComponentTheme {\n  axis?: RecursivePartial<LineAxisAttributes>;\n  circleAxis?: RecursivePartial<CircleAxisAttributes>;\n\n  grid?: RecursivePartial<LineAxisGridAttributes>;\n  circleGrid?: RecursivePartial<CircleAxisGridAttributes>;\n\n  discreteLegend?: RecursivePartial<DiscreteLegendAttrs>;\n  colorLegend?: RecursivePartial<ColorLegendAttributes>;\n  sizeLegend?: RecursivePartial<SizeLegendAttributes>;\n\n  lineCrosshair?: RecursivePartial<LineCrosshairAttrs>;\n  rectCrosshair?: RecursivePartial<RectCrosshairAttrs>;\n  sectorCrosshair?: RecursivePartial<SectorCrosshairAttrs>;\n  circleCrosshair?: RecursivePartial<CircleCrosshairAttrs>;\n  polygonCrosshair?: RecursivePartial<PolygonCrosshairAttrs>;\n\n  slider?: RecursivePartial<SliderAttributes>;\n\n  dataLabel?: RecursivePartial<DataLabelAttrs>;\n  lineLabel?: RecursivePartial<LineLabelAttrs>;\n  rectLabel?: RecursivePartial<RectLabelAttrs>;\n  arcLabel?: RecursivePartial<ArcLabelAttrs>;\n  symbolLabel?: RecursivePartial<SymbolLabelAttrs>;\n  pointLabel?: RecursivePartial<BaseLabelAttrs>;\n\n  datazoom?: RecursivePartial<DataZoomAttributes>;\n\n  continuousPlayer?: RecursivePartial<ContinuousPlayerAttributes>;\n  discretePlayer?: RecursivePartial<DiscretePlayerAttributes>;\n\n  tooltip?: RecursivePartial<TooltipAttributes>;\n\n  title?: RecursivePartial<TitleAttrs>;\n\n  scrollbar?: RecursivePartial<ScrollBarAttributes>;\n}\n\nexport interface ITheme {\n  name?: string;\n  background?: IColor;\n  padding?: IPadding | number;\n  palette?: Record<string, IColor[]>;\n  marks?: IMarkTheme;\n  components?: IComponentTheme;\n}\n"]}

package/es/types/transform.d.ts

@@ -0,0 +1,291 @@
+import type { FieldGetterFunction, LayoutViewBox } from '@visactor/vgrammar-util';
+import type { SignalFunction, SignalReference } from './signal';
+import type { IView } from './view';
+import type { IData } from './grammar';
+import type { SortConfigSpec } from './data';
+export type TransformSpecValue = {
+    signal?: string;
+    scale?: string;
+    data?: string;
+    customized?: string;
+} | any;
+export type TransformFunctionCallback<T> = (parameters: any) => T;
+export type TransformFunctionType<T> = T | SignalReference<T> | SignalFunction<TransformFunctionCallback<T>, T>;
+export type ConvertTransformOptionToSpec<TransformOptionType> = {
+    [Key in keyof TransformOptionType]?: TransformFunctionType<TransformOptionType[Key]>;
+};
+export interface BinTransformOption {
+    field: string;
+    extent: [number, number];
+    step?: number;
+    bins?: number;
+    as?: [string, string];
+}
+export interface ContourTransformOption {
+    field: string;
+    row: number;
+    column: number;
+    thresholds?: number[];
+    levels?: number;
+    asThreshold?: string;
+    asPoints?: string;
+}
+export interface FilterTransformOption {
+    callback: (entry: any, params: any) => boolean;
+}
+export interface FunnelTransformOption {
+    field: string;
+    asTransformRatio?: string;
+    asReachRatio?: string;
+    asHeightRatio?: string;
+    asValueRatio?: string;
+    asLastValueRatio?: string;
+    asNextValueRatio?: string;
+    asCurrentValue?: string;
+    asLastValue?: string;
+    asNextValue?: string;
+    isCone?: boolean;
+    heightVisual?: boolean;
+    range?: {
+        min: number;
+        max: number;
+    };
+}
+export interface JoinTransformOption {
+    from?: any[];
+    key: string;
+    fields: string[];
+    values?: string[];
+    as?: string[];
+    default?: any;
+}
+export interface KDETransformOption {
+    dimension?: '1d' | '2d';
+    field: string | string[];
+    bandwidth?: number;
+    extent?: [number, number] | [{
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    }];
+    bins?: number | number[];
+    as?: string[];
+}
+export interface MapTransformOption {
+    callback: (entry: any, params?: any) => any;
+    as?: string;
+    all?: boolean;
+}
+export interface PickTransformOption {
+    as?: string[];
+    fields: string[] | FieldGetterFunction[];
+}
+export interface PieTransformOption {
+    field: string;
+    startAngle?: number;
+    endAngle?: number;
+    asStartAngle?: string;
+    asEndAngle?: string;
+    asMiddleAngle?: string;
+    asRadian?: string;
+    asRatio?: string;
+    asQuadrant?: string;
+    asK?: string;
+}
+export interface RangeTransformOptions {
+    start: number;
+    stop: number;
+    step?: number;
+    as?: string;
+}
+export interface SortTransformOptions {
+    sort: SortConfigSpec | ((a: any, b: any) => number);
+}
+export interface FoldTransformOptions {
+    fields: string[];
+    asKey?: string;
+    asValue?: string;
+    retains?: string[];
+}
+export interface UnfoldTransformOptions {
+    groupBy?: string[] | string;
+    keyField: string;
+    valueField: string;
+    aggregateType?: 'sum' | 'min' | 'max' | 'count' | 'mean';
+}
+export interface StackTransformOptions {
+    order?: 'positive' | 'negative';
+    offset?: 'none' | 'diverging' | 'silhouette' | 'wiggle';
+    stackField: string;
+    dimensionField: string;
+    asStack?: string;
+    asPrevStack?: string;
+    asPercent?: string;
+    asPercentStack?: string;
+    asPrevPercentStack?: string;
+    asSum?: string;
+}
+export interface DodgeTransformOptions {
+    innerGap?: number | string;
+    maxWidth?: number;
+    minWidth?: number;
+    categoryGap?: number | string;
+    dodgeBy?: string | string[];
+    dodgeChannel?: 'x' | 'y';
+}
+export interface JitterTransformOptions {
+    bandWidth?: number;
+    bandHeight?: number;
+    widthRatio?: number;
+    heightRatio?: number;
+    random?: (index?: number, total?: number) => number;
+}
+export interface JitterXTransformOptions {
+    bandWidth?: number;
+    widthRatio?: number;
+    random?: (index?: number, total?: number) => number;
+}
+export interface JitterYTransformOptions {
+    bandHeight?: number;
+    heightRatio?: number;
+    random?: (index?: number, total?: number) => number;
+}
+export type CircularRelationTransformOptions = LayoutViewBox & {
+    field: string;
+    radiusField?: string;
+    radiusRange?: [number, number];
+    center?: [string | number, string | number];
+    startAngle?: number;
+    endAngle?: number;
+    innerRadius?: string | number;
+    outerRadius?: string | number;
+};
+export interface CircularRelationItem {
+    x: number;
+    y: number;
+    radius: number;
+    datum: any;
+}
+export interface IdentifierTransformOptions {
+    as: string;
+}
+export interface MarkOverlapTransformOptions {
+    direction: number;
+    delta?: number;
+    deltaMul?: number;
+    radius?: boolean;
+    hideMode?: number;
+    forceUpdate?: boolean;
+    forceUpdateStamp?: number;
+    groupBy?: string;
+}
+export interface LttbSampleTransformOptions {
+    size: number;
+    factor?: number;
+    skipfirst?: boolean;
+    xfield?: string;
+    yfield?: string;
+    groupBy?: string;
+}
+export interface SymmetryTransformOptions {
+    channel?: 'x' | 'y';
+    align?: 'min' | 'max';
+}
+export interface BinTransformSpec extends BinTransformOption {
+    type: 'bin';
+}
+export interface ContourTransformSpec extends ContourTransformOption {
+    type: 'contour';
+}
+export interface FilterTransformSpec extends ConvertTransformOptionToSpec<FilterTransformOption> {
+    type: 'filter';
+}
+export interface FunnelTransformSpec extends FunnelTransformOption {
+    type: 'funnel';
+}
+export interface PieTransformSpec extends PieTransformOption {
+    type: 'pie';
+}
+export interface JoinTransformSpec extends ConvertTransformOptionToSpec<Omit<JoinTransformOption, 'from'>> {
+    type: 'join';
+    from?: TransformFunctionType<JoinTransformOption['from']> | {
+        data: string | IData;
+    };
+}
+export interface KDETransformSpec extends KDETransformOption {
+    type: 'kde';
+}
+export interface MapTransformSpec extends ConvertTransformOptionToSpec<Omit<MapTransformOption, 'callback'>> {
+    type: 'map';
+    callback: MapTransformOption['callback'];
+}
+export interface PickTransformSpec extends ConvertTransformOptionToSpec<PickTransformOption> {
+    type: 'pick';
+}
+export interface RangeTransformSpec extends ConvertTransformOptionToSpec<RangeTransformOptions> {
+    type: 'range';
+}
+export interface SortTransformSpec extends ConvertTransformOptionToSpec<SortTransformOptions> {
+    type: 'sort';
+}
+export interface StackTransformSpec extends ConvertTransformOptionToSpec<StackTransformOptions> {
+    type: 'stack';
+}
+export interface DodgeTransformSpec extends ConvertTransformOptionToSpec<DodgeTransformOptions> {
+    type: 'dodge';
+}
+export interface IdentifierTransformSpec extends ConvertTransformOptionToSpec<IdentifierTransformOptions> {
+    type: 'identifier';
+}
+export interface MarkOverlapTransformSpec extends ConvertTransformOptionToSpec<MarkOverlapTransformOptions> {
+    type: 'markoverlap';
+}
+export interface LttbSampleTransformSpec extends ConvertTransformOptionToSpec<LttbSampleTransformOptions> {
+    type: 'lttbsample';
+}
+export interface JitterTransformSpec extends ConvertTransformOptionToSpec<JitterTransformOptions> {
+    type: 'jitter';
+}
+export interface JitterXTransformSpec extends ConvertTransformOptionToSpec<JitterXTransformOptions> {
+    type: 'jitterX';
+}
+export interface JitterYTransformSpec extends ConvertTransformOptionToSpec<JitterYTransformOptions> {
+    type: 'jitterY';
+}
+export type CircularRelationTransformSpec = ConvertTransformOptionToSpec<CircularRelationTransformOptions> & {
+    type: 'circularRelation';
+};
+export interface FoldTransformSpec extends ConvertTransformOptionToSpec<FoldTransformOptions> {
+    type: 'fold';
+}
+export interface UnfoldTransformSpec extends ConvertTransformOptionToSpec<UnfoldTransformOptions> {
+    type: 'unfold';
+}
+export interface SymmetryTransformSpec extends ConvertTransformOptionToSpec<SymmetryTransformOptions> {
+    type: 'symmetry';
+}
+export interface BaseTransformSpec {
+    type: string;
+    [key: string]: TransformSpecValue | TransformSpecValue[];
+}
+export type TransformSpec = FilterTransformSpec | FunnelTransformSpec | PieTransformSpec | JoinTransformSpec | MapTransformSpec | PickTransformSpec | RangeTransformSpec | SortTransformSpec | StackTransformSpec | DodgeTransformSpec | IdentifierTransformSpec | BaseTransformSpec | MarkOverlapTransformSpec | LttbSampleTransformSpec | JitterTransformSpec | JitterXTransformSpec | JitterYTransformSpec | CircularRelationTransformSpec | FoldTransformSpec | UnfoldTransformSpec;
+export interface IProgressiveTransformResult<Output = any> {
+    unfinished: () => boolean;
+    output: () => Output;
+    progressiveOutput: () => Output;
+    progressiveRun: () => void;
+    release: () => void;
+}
+export interface IProgressiveTransform<Output = any> {
+    progressive: IProgressiveTransformResult<Output>;
+}
+export type IFunctionTransform<Options = any, Input = any, Output = any> = (options?: Options, data?: Input, params?: Record<string, any>, view?: IView) => Output | Promise<Output> | IProgressiveTransformResult<Output>;
+export interface ITransform<Options = any, Input = any, Output = any> {
+    type: string;
+    markPhase?: 'beforeJoin' | 'afterEncode' | 'afterEncodeItems';
+    canProgressive?: boolean;
+    transform: IFunctionTransform<Options, Input, Output>;
+    isBuiltIn?: boolean;
+}

package/es/types/transform.js

@@ -0,0 +1,2 @@
+export { };
+//# sourceMappingURL=transform.js.map

package/es/types/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/transform.ts"],"names":[],"mappings":"","file":"transform.js","sourcesContent":["import type { FieldGetterFunction, LayoutViewBox } from '@visactor/vgrammar-util';\nimport type { SignalFunction, SignalReference } from './signal';\nimport type { IView } from './view';\nimport type { IData } from './grammar';\nimport type { SortConfigSpec } from './data';\n\nexport type TransformSpecValue =\n  | {\n      /** transform will depend a signal grammar instance as params */\n      signal?: string;\n      /** transform will depend a scale grammar instance as params, this should only be used in the transform of mark */\n      scale?: string;\n      /** transform will depend a data grammar instance as params, this should only be used in the transform of mark */\n      data?: string;\n      /** transform will depend a customized grammar instance as params, this should only be used in the transform of mark */\n      customized?: string;\n    }\n  | any;\n\nexport type TransformFunctionCallback<T> = (parameters: any) => T;\n\nexport type TransformFunctionType<T> = T | SignalReference<T> | SignalFunction<TransformFunctionCallback<T>, T>;\n\nexport type ConvertTransformOptionToSpec<TransformOptionType> = {\n  [Key in keyof TransformOptionType]?: TransformFunctionType<TransformOptionType[Key]>;\n};\n\nexport interface BinTransformOption {\n  field: string;\n  extent: [number, number];\n  step?: number;\n  bins?: number;\n  as?: [string, string];\n}\n\nexport interface ContourTransformOption {\n  field: string;\n  row: number;\n  column: number;\n  thresholds?: number[];\n  levels?: number;\n  asThreshold?: string;\n  asPoints?: string;\n}\n\nexport interface FilterTransformOption {\n  callback: (entry: any, params: any) => boolean;\n}\n\nexport interface FunnelTransformOption {\n  /** the field to of measure */\n  field: string;\n  /** the filed of transform ration(the value of next level/ the value of current level)**/\n  asTransformRatio?: string;\n  /**  the filed of reach ration(the value of current level/ the value of prev level)）*/\n  asReachRatio?: string;\n  /** the field of height ratio **/\n  asHeightRatio?: string;\n  /** the field of value ration(this value of current level / this value of first level ) */\n  asValueRatio?: string;\n  /** the field of last value ratio(the value of last level / this value of first level) */\n  asLastValueRatio?: string;\n  /** the field of next value ratio(the value of next level / this value of first level) */\n  asNextValueRatio?: string;\n  /** the field of current value */\n  asCurrentValue?: string;\n  /** the field of last value **/\n  asLastValue?: string;\n  /** the field of next value **/\n  asNextValue?: string;\n  /** whether or not the last level of the funnel is  a cone */\n  isCone?: boolean;\n  /** whether or not the height will be encode to value**/\n  heightVisual?: boolean;\n\n  /** the range of value */\n  range?: { min: number; max: number };\n}\n\nexport interface JoinTransformOption {\n  from?: any[];\n  key: string;\n  fields: string[];\n  values?: string[];\n  as?: string[];\n  default?: any;\n}\n\nexport interface KDETransformOption {\n  dimension?: '1d' | '2d';\n  field: string | string[];\n  bandwidth?: number;\n  extent?: [number, number] | [{ x: number; y: number }, { x: number; y: number }];\n  bins?: number | number[];\n  as?: string[];\n}\n\nexport interface MapTransformOption {\n  callback: (entry: any, params?: any) => any;\n  as?: string;\n  all?: boolean;\n}\n\nexport interface PickTransformOption {\n  as?: string[];\n  fields: string[] | FieldGetterFunction[];\n}\n\nexport interface PieTransformOption {\n  field: string;\n  startAngle?: number;\n  endAngle?: number;\n  asStartAngle?: string;\n  asEndAngle?: string;\n  asMiddleAngle?: string;\n  asRadian?: string;\n  asRatio?: string;\n  asQuadrant?: string;\n  asK?: string;\n}\n\nexport interface RangeTransformOptions {\n  start: number;\n  stop: number;\n  step?: number;\n  as?: string;\n}\n\nexport interface SortTransformOptions {\n  sort: SortConfigSpec | ((a: any, b: any) => number);\n}\n\nexport interface FoldTransformOptions {\n  fields: string[];\n  asKey?: string;\n  asValue?: string;\n  retains?: string[];\n}\n\nexport interface UnfoldTransformOptions {\n  groupBy?: string[] | string;\n  keyField: string;\n  valueField: string;\n  aggregateType?: 'sum' | 'min' | 'max' | 'count' | 'mean';\n}\n\nexport interface StackTransformOptions {\n  // TODO: provide more order option referring to d3-shape\n  order?: 'positive' | 'negative';\n  offset?: 'none' | 'diverging' | 'silhouette' | 'wiggle';\n  stackField: string;\n  dimensionField: string;\n  asStack?: string;\n  asPrevStack?: string;\n  asPercent?: string;\n  asPercentStack?: string;\n  asPrevPercentStack?: string;\n  asSum?: string;\n}\n\nexport interface DodgeTransformOptions {\n  /**\n   * the gap for two graphic elements\n   */\n  innerGap?: number | string;\n  /**\n   * only used for rect / interval mark\n   */\n  maxWidth?: number;\n  minWidth?: number;\n  /** the gap between two category */\n  categoryGap?: number | string;\n  /**\n   * specify the field to dodge, if this field is not specified, we'll use the `groupKey` of Element to dodge\n   */\n  dodgeBy?: string | string[];\n  /**\n   * specify the channel to dodge, if this field is not specified, we'll use the channel which is associated to a band scale\n   */\n  dodgeChannel?: 'x' | 'y';\n}\n\nexport interface JitterTransformOptions {\n  bandWidth?: number;\n  bandHeight?: number;\n  widthRatio?: number;\n  heightRatio?: number;\n  random?: (index?: number, total?: number) => number;\n}\n\nexport interface JitterXTransformOptions {\n  bandWidth?: number;\n  widthRatio?: number;\n  random?: (index?: number, total?: number) => number;\n}\nexport interface JitterYTransformOptions {\n  bandHeight?: number;\n  heightRatio?: number;\n  random?: (index?: number, total?: number) => number;\n}\n\nexport type CircularRelationTransformOptions = LayoutViewBox & {\n  field: string;\n  radiusField?: string;\n  radiusRange?: [number, number];\n  center?: [string | number, string | number];\n  startAngle?: number;\n  endAngle?: number;\n  innerRadius?: string | number;\n  outerRadius?: string | number;\n};\n\nexport interface CircularRelationItem {\n  x: number;\n  y: number;\n  radius: number;\n  datum: any;\n}\n\nexport interface IdentifierTransformOptions {\n  as: string;\n}\n\nexport interface MarkOverlapTransformOptions {\n  direction: number;\n  delta?: number;\n  deltaMul?: number;\n  radius?: boolean;\n  hideMode?: number;\n  forceUpdate?: boolean;\n  forceUpdateStamp?: number;\n  groupBy?: string;\n}\n\nexport interface LttbSampleTransformOptions {\n  size: number;\n  factor?: number;\n  skipfirst?: boolean;\n  xfield?: string;\n  yfield?: string;\n  groupBy?: string;\n}\n\nexport interface SymmetryTransformOptions {\n  channel?: 'x' | 'y';\n  align?: 'min' | 'max';\n}\n\nexport interface BinTransformSpec extends BinTransformOption {\n  type: 'bin';\n}\n\nexport interface ContourTransformSpec extends ContourTransformOption {\n  type: 'contour';\n}\n\nexport interface FilterTransformSpec extends ConvertTransformOptionToSpec<FilterTransformOption> {\n  type: 'filter';\n}\n\nexport interface FunnelTransformSpec extends FunnelTransformOption {\n  type: 'funnel';\n}\n\nexport interface PieTransformSpec extends PieTransformOption {\n  type: 'pie';\n}\n\nexport interface JoinTransformSpec extends ConvertTransformOptionToSpec<Omit<JoinTransformOption, 'from'>> {\n  type: 'join';\n  from?: TransformFunctionType<JoinTransformOption['from']> | { data: string | IData };\n}\n\nexport interface KDETransformSpec extends KDETransformOption {\n  type: 'kde';\n}\n\nexport interface MapTransformSpec extends ConvertTransformOptionToSpec<Omit<MapTransformOption, 'callback'>> {\n  type: 'map';\n  callback: MapTransformOption['callback'];\n}\n\nexport interface PickTransformSpec extends ConvertTransformOptionToSpec<PickTransformOption> {\n  type: 'pick';\n}\nexport interface RangeTransformSpec extends ConvertTransformOptionToSpec<RangeTransformOptions> {\n  type: 'range';\n}\n\nexport interface SortTransformSpec extends ConvertTransformOptionToSpec<SortTransformOptions> {\n  type: 'sort';\n}\nexport interface StackTransformSpec extends ConvertTransformOptionToSpec<StackTransformOptions> {\n  type: 'stack';\n}\nexport interface DodgeTransformSpec extends ConvertTransformOptionToSpec<DodgeTransformOptions> {\n  type: 'dodge';\n}\n\nexport interface IdentifierTransformSpec extends ConvertTransformOptionToSpec<IdentifierTransformOptions> {\n  type: 'identifier';\n}\n\nexport interface MarkOverlapTransformSpec extends ConvertTransformOptionToSpec<MarkOverlapTransformOptions> {\n  type: 'markoverlap';\n}\nexport interface LttbSampleTransformSpec extends ConvertTransformOptionToSpec<LttbSampleTransformOptions> {\n  type: 'lttbsample';\n}\n\nexport interface JitterTransformSpec extends ConvertTransformOptionToSpec<JitterTransformOptions> {\n  type: 'jitter';\n}\n\nexport interface JitterXTransformSpec extends ConvertTransformOptionToSpec<JitterXTransformOptions> {\n  type: 'jitterX';\n}\n\nexport interface JitterYTransformSpec extends ConvertTransformOptionToSpec<JitterYTransformOptions> {\n  type: 'jitterY';\n}\n\nexport type CircularRelationTransformSpec = ConvertTransformOptionToSpec<CircularRelationTransformOptions> & {\n  type: 'circularRelation';\n};\n\nexport interface FoldTransformSpec extends ConvertTransformOptionToSpec<FoldTransformOptions> {\n  type: 'fold';\n}\n\nexport interface UnfoldTransformSpec extends ConvertTransformOptionToSpec<UnfoldTransformOptions> {\n  type: 'unfold';\n}\n\nexport interface SymmetryTransformSpec extends ConvertTransformOptionToSpec<SymmetryTransformOptions> {\n  type: 'symmetry';\n}\n\nexport interface BaseTransformSpec {\n  /** the type of transform */\n  type: string;\n  [key: string]: TransformSpecValue | TransformSpecValue[];\n}\n\nexport type TransformSpec =\n  | FilterTransformSpec\n  | FunnelTransformSpec\n  | PieTransformSpec\n  | JoinTransformSpec\n  | MapTransformSpec\n  | PickTransformSpec\n  | RangeTransformSpec\n  | SortTransformSpec\n  | StackTransformSpec\n  | DodgeTransformSpec\n  | IdentifierTransformSpec\n  | BaseTransformSpec\n  | MarkOverlapTransformSpec\n  | LttbSampleTransformSpec\n  | JitterTransformSpec\n  | JitterXTransformSpec\n  | JitterYTransformSpec\n  | CircularRelationTransformSpec\n  | FoldTransformSpec\n  | UnfoldTransformSpec;\n\nexport interface IProgressiveTransformResult<Output = any> {\n  /** is progressive finished */\n  unfinished: () => boolean;\n  /** return all the result */\n  output: () => Output;\n  /** the output result of current progressive run */\n  progressiveOutput: () => Output;\n  /** run in progressive mode */\n  progressiveRun: () => void;\n  /** release the progressive context */\n  release: () => void;\n}\n\nexport interface IProgressiveTransform<Output = any> {\n  progressive: IProgressiveTransformResult<Output>;\n}\n\nexport type IFunctionTransform<Options = any, Input = any, Output = any> = (\n  options?: Options,\n  data?: Input,\n  params?: Record<string, any>,\n  view?: IView\n) => Output | Promise<Output> | IProgressiveTransformResult<Output>;\nexport interface ITransform<Options = any, Input = any, Output = any> {\n  type: string;\n  markPhase?: 'beforeJoin' | 'afterEncode' | 'afterEncodeItems';\n  /** 是否支持渐进流程 */\n  canProgressive?: boolean;\n  /** transform function */\n  transform: IFunctionTransform<Options, Input, Output>;\n  isBuiltIn?: boolean;\n}\n"]}

package/es/types/view.d.ts

@@ -0,0 +1,217 @@
+/// <reference types="node" />
+import type { EventEmitter, IBounds, ILogger } from '@visactor/vutils';
+import type { EnvType, IStage, IColor, IOption3D, ILayer, IStageParams } from '@visactor/vrender';
+import type { CoordinateType } from '@visactor/vgrammar-coordinate';
+import type { DataSpec } from './data';
+import type { SignalFunctionType, SignalSpec } from './signal';
+import type { IData, ISignal, IScale, IMark, IGrammarBase, ICoordinate, IGlyphMark, IGroupMark, IComponent } from './grammar';
+import type { ScaleSpec, GrammarScaleType } from './scale';
+import type { MarkSpec, MarkType } from './mark';
+import type { Hooks } from './hooks';
+import type { ProjectionSpec } from './projection';
+import type { BaseEventHandler, EventSpec } from './event';
+import type { CommonPaddingSpec } from './base';
+import type { IMorphAnimationConfig } from './morph';
+import type { IBaseAnimate } from './animate';
+import type { IRenderer } from './renderer';
+import type { IAxis, ICrosshair, IDatazoom, IDimensionTooltip, IGrid, ILabel, ILegend, IPlayer, IScrollbar, ISlider, ITitle, ITooltip } from './component';
+import type { CoordinateSpec } from './coordinate';
+import type { ITheme } from './theme';
+export interface IViewThemeConfig {
+    labelMonospace?: boolean;
+}
+export interface IViewStateOptions {
+    signals?: (name?: string, operator?: any) => boolean;
+    data?: (name?: string, object?: any) => boolean;
+    recurse?: boolean;
+}
+export interface IEnvironmentOptions {
+    mode?: EnvType;
+    modeParams?: any;
+}
+export interface IRendererOptions extends Partial<IStageParams> {
+    renderCanvas?: string | HTMLCanvasElement;
+    stage?: IStage;
+    rendererTitle?: string;
+    layer?: ILayer;
+}
+export interface ILayoutOptions {
+    parseMarkBounds?: (bounds: IBounds, mark: IMark) => IBounds;
+    doLayout?: (marks: IMark[], options: ILayoutOptions, view: IView) => void;
+}
+export interface IViewEventConfig {
+    defaults?: {
+        prevent?: boolean | Record<string, boolean> | string[];
+        allow?: boolean | Record<string, boolean> | string[];
+    };
+    view?: boolean | Record<string, boolean> | string[];
+    window?: boolean | Record<string, boolean> | string[];
+    disable?: boolean;
+    gesture?: boolean;
+    drag?: boolean;
+    globalCursor?: boolean;
+}
+export interface srIOption3DType extends IOption3D {
+    enable?: boolean;
+    enableView3dTranform?: boolean;
+}
+export interface IViewOptions extends IEnvironmentOptions, IRendererOptions, ILayoutOptions {
+    width?: number;
+    height?: number;
+    padding?: CommonPaddingSpec;
+    autoFit?: boolean;
+    options3d?: srIOption3DType;
+    hover?: boolean;
+    select?: boolean;
+    cursor?: boolean;
+    logger?: ILogger;
+    logLevel?: number;
+    domBridge?: any;
+    hooks?: Hooks;
+    eventConfig?: IViewEventConfig;
+}
+export interface IRunningConfig {
+    reuse?: boolean;
+    morph?: boolean;
+    morphAll?: boolean;
+    animation?: IMorphAnimationConfig;
+    enableExitAnimation?: boolean;
+}
+export interface IView {
+    readonly renderer: IRenderer;
+    readonly rootMark: IGroupMark;
+    readonly animate: IBaseAnimate;
+    readonly grammars: IRecordedGrammars;
+    readonly logger: ILogger;
+    signal: <T>(value?: T, update?: SignalFunctionType<T>) => ISignal<T>;
+    data: (values?: any[]) => IData;
+    scale: (type: GrammarScaleType) => IScale;
+    coordinate: (type: CoordinateType) => ICoordinate;
+    mark: (type: MarkType, group: IGroupMark | string, markOptions?: {
+        glyphType?: string;
+        componentType?: string;
+        mode?: '2d' | '3d';
+    }) => IMark;
+    group: (group: IGroupMark | string) => IGroupMark;
+    glyph: (glyphType: string, group: IGroupMark | string) => IGlyphMark;
+    component: (componentType: string, group: IGroupMark | string, mode?: '2d' | '3d') => IComponent;
+    axis: (group: IGroupMark | string, mode?: '2d' | '3d') => IAxis;
+    grid: (group: IGroupMark | string, mode?: '2d' | '3d') => IGrid;
+    legend: (group: IGroupMark | string) => ILegend;
+    crosshair: (group: IGroupMark | string) => ICrosshair;
+    slider: (group: IGroupMark | string) => ISlider;
+    label: (group: IGroupMark | string) => ILabel;
+    datazoom: (group: IGroupMark | string) => IDatazoom;
+    player: (group: IGroupMark | string) => IPlayer;
+    tooltip: (group: IGroupMark | string) => ITooltip;
+    dimensionTooltip: (group: IGroupMark | string) => IDimensionTooltip;
+    title: (group: IGroupMark | string) => ITitle;
+    scrollbar: (group: IGroupMark | string) => IScrollbar;
+    addGrammar: (grammar: IGrammarBase) => this;
+    removeGrammar: (grammar: string | IGrammarBase) => this;
+    removeAllGrammars: () => this;
+    getGrammarById: (id: string) => IGrammarBase | null;
+    getCustomizedById: (id: string) => IGrammarBase | null;
+    getSignalById: <T>(id: string) => ISignal<T> | null;
+    getDataById: (id: string) => IData | null;
+    getScaleById: (id: string) => IScale | null;
+    getCoordinateById: (id: string) => ICoordinate | null;
+    getMarkById: (id: string) => IMark | null;
+    getGrammarsByName: (name: string) => IGrammarBase[];
+    getGrammarsByType: (grammarType: string) => IGrammarBase[];
+    getMarksByType: (markType: string) => IMark[];
+    commit: (grammar: IGrammarBase) => this;
+    parseSpec: (spec: ViewSpec) => this;
+    updateSpec: (spec: ViewSpec) => this;
+    run: (runningConfig?: IRunningConfig) => this;
+    runNextTick: (runningConfig?: IRunningConfig) => Promise<this>;
+    runAsync: (runningConfig?: IRunningConfig) => Promise<this>;
+    runSync: (runningConfig?: IRunningConfig) => this;
+    runBefore: (callback: (view: IView) => void) => this;
+    runAfter: (callback: (view: IView) => void) => this;
+    theme: (theme: ITheme | string) => this;
+    getCurrentTheme: () => ITheme;
+    setCurrentTheme: (theme: ITheme | string, render?: boolean) => Promise<this>;
+    background: (value?: IColor) => IColor;
+    width: (value?: number) => number;
+    height: (value?: number) => number;
+    viewWidth: (value?: number) => number;
+    viewHeight: (value?: number) => number;
+    padding: (p?: number | {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    }) => {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    getViewBox: () => IBounds;
+    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;
+    resize: (width: number, height: number, render?: boolean) => Promise<this>;
+    traverseMarkTree: (apply: (mark: IMark) => any, filter?: (mark: IMark) => boolean, leafFirst?: boolean) => this;
+    getLayoutState: () => string;
+    updateLayoutTag: () => this;
+    pauseProgressive: () => boolean;
+    resumeProgressive: () => boolean;
+    restartProgressive: () => boolean;
+    release: () => void;
+    getImageBuffer: () => Buffer;
+}
+export interface IViewConstructor {
+    new (options?: IViewOptions, config?: IViewThemeConfig): IView;
+}
+export interface ViewSpec {
+    theme?: string;
+    background?: IColor;
+    width?: number;
+    height?: number;
+    padding?: number | {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    };
+    signals?: SignalSpec<any>[];
+    projections?: ProjectionSpec[];
+    data?: DataSpec[];
+    scales?: ScaleSpec[];
+    coordinates?: CoordinateSpec[];
+    marks?: MarkSpec[];
+    events?: EventSpec[];
+}
+export interface IRecordedGrammars {
+    record: (grammar: IGrammarBase) => this;
+    unrecord: (grammar: IGrammarBase) => this;
+    size: () => number;
+    getSignal: <T>(key: string) => ISignal<T> | null;
+    getData: (key: string) => IData | null;
+    getScale: (key: string) => IScale | null;
+    getCoordinate: (key: string) => ICoordinate | null;
+    getMark: (key: string) => IMark | null;
+    getCustomized: (key: string) => IGrammarBase | null;
+    getGrammar: (key: string) => IGrammarBase | null;
+    getAllSignals: () => ISignal<any>[];
+    getAllData: () => IData[];
+    getAllScales: () => IScale[];
+    getAllCoordinates: () => ICoordinate[];
+    getAllMarks: () => IMark[];
+    getAllCustomized: () => IGrammarBase[];
+    clear: () => void;
+    traverse: (func: (grammar: IGrammarBase) => boolean | void) => void;
+    find: (func: (grammar: IGrammarBase) => boolean) => IGrammarBase | null;
+    filter: (func: (grammar: IGrammarBase) => boolean) => IGrammarBase[];
+    release: () => void;
+}
+export interface IMarkTreeNode {
+    mark: IMark;
+    parent: IMarkTreeNode;
+    children: IMarkTreeNode[];
+}
+export interface IRecordedTreeGrammars extends IRecordedGrammars {
+    getAllMarkNodes: () => IMarkTreeNode[];
+}

package/es/types/view.js

@@ -0,0 +1,2 @@
+export { };
+//# sourceMappingURL=view.js.map

package/es/types/view.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/view.ts"],"names":[],"mappings":"","file":"view.js","sourcesContent":["import type { EventEmitter, IBounds, IBoundsLike, ILogger } from '@visactor/vutils';\nimport type { EnvType, IStage, IColor, IOption3D, ILayer, IStageParams } from '@visactor/vrender';\nimport type { CoordinateType } from '@visactor/vgrammar-coordinate';\nimport type { DataSpec } from './data';\nimport type { SignalFunctionType, SignalSpec } from './signal';\nimport type {\n  IData,\n  ISignal,\n  IScale,\n  IMark,\n  IGrammarBase,\n  ICoordinate,\n  IGlyphMark,\n  IGroupMark,\n  IComponent\n} from './grammar';\nimport type { ScaleSpec, GrammarScaleType } from './scale';\nimport type { MarkSpec, MarkType } from './mark';\nimport type { Hooks } from './hooks';\nimport type { ProjectionSpec } from './projection';\nimport type { BaseEventHandler, EventSpec } from './event';\nimport type { CommonPaddingSpec } from './base';\nimport type { IMorphAnimationConfig } from './morph';\nimport type { IBaseAnimate } from './animate';\nimport type { IRenderer } from './renderer';\nimport type {\n  IAxis,\n  ICrosshair,\n  IDatazoom,\n  IDimensionTooltip,\n  IGrid,\n  ILabel,\n  ILegend,\n  IPlayer,\n  IScrollbar,\n  ISlider,\n  ITitle,\n  ITooltip\n} from './component';\nimport type { CoordinateSpec } from './coordinate';\nimport type { ITheme } from './theme';\n\nexport interface IViewThemeConfig {\n  labelMonospace?: boolean;\n}\n\n/**\n * 获取state相关配置\n */\nexport interface IViewStateOptions {\n  signals?: (name?: string, operator?: any) => boolean;\n  data?: (name?: string, object?: any) => boolean;\n  recurse?: boolean;\n}\n\nexport interface IEnvironmentOptions {\n  /** 环境参数 */\n  mode?: EnvType;\n  /**\n   * 环境带的配置\n   */\n  modeParams?: any;\n}\n\nexport interface IRendererOptions extends Partial<IStageParams> {\n  /** 非浏览器环境下，如小程序，需要传入经过包装的伪 canvas 实例 */\n  renderCanvas?: string | HTMLCanvasElement;\n  /** vRender stage */\n  stage?: IStage;\n  rendererTitle?: string;\n  /** vRender layer */\n  layer?: ILayer;\n}\n\nexport interface ILayoutOptions {\n  parseMarkBounds?: (bounds: IBounds, mark: IMark) => IBounds;\n  doLayout?: (marks: IMark[], options: ILayoutOptions, view: IView) => void;\n}\n\n/** 事件配置 */\nexport interface IViewEventConfig {\n  /**\n   * preventDefaults相关配置\n   */\n  defaults?: {\n    prevent?: boolean | Record<string, boolean> | string[];\n    allow?: boolean | Record<string, boolean> | string[];\n  };\n  view?: boolean | Record<string, boolean> | string[];\n  window?: boolean | Record<string, boolean> | string[];\n  disable?: boolean;\n  gesture?: boolean;\n  drag?: boolean;\n  globalCursor?: boolean;\n}\n\nexport interface srIOption3DType extends IOption3D {\n  enable?: boolean;\n  /* 是否支持3d视角变换 */\n  enableView3dTranform?: boolean;\n}\nexport interface IViewOptions extends IEnvironmentOptions, IRendererOptions, ILayoutOptions {\n  width?: number;\n  height?: number;\n  padding?: CommonPaddingSpec;\n  autoFit?: boolean;\n\n  options3d?: srIOption3DType;\n\n  /** 是否默认配置hover交互 */\n  hover?: boolean;\n  /** 是否开启选中交互 */\n  select?: boolean;\n\n  /** 是否启用 cursor 设置 */\n  cursor?: boolean;\n\n  /** 外部传入的logger方法 */\n  logger?: ILogger;\n  /**\n   * 0 - None\n   * 1 - Error\n   * 2 - Warn\n   * 3 - Info\n   * 4 - Debug\n   */\n  logLevel?: number;\n\n  /** worker 专用 */\n  domBridge?: any;\n\n  /** 生命周期等事件钩子 */\n  hooks?: Hooks;\n\n  /**\n   * 事件相关配置\n   * {\n   *    defaults: {\n   *      prevent: ['mousemove', 'mouseenter']\n   *    }\n   * }\n   */\n  eventConfig?: IViewEventConfig;\n}\n\nexport interface IRunningConfig {\n  /** whether enable reusing of grammar */\n  reuse?: boolean;\n  /** whether enable morph */\n  morph?: boolean;\n  /** force all marks to participate in morphing */\n  morphAll?: boolean;\n  /** morphing animation config */\n  animation?: IMorphAnimationConfig;\n  /** whether apply exit animations for released marks */\n  enableExitAnimation?: boolean;\n}\n\nexport interface IView {\n  readonly renderer: IRenderer;\n  readonly rootMark: IGroupMark;\n  readonly animate: IBaseAnimate;\n  readonly grammars: IRecordedGrammars;\n  readonly logger: ILogger;\n\n  // --- Grammar API ---\n  signal: <T>(value?: T, update?: SignalFunctionType<T>) => ISignal<T>;\n  data: (values?: any[]) => IData;\n  scale: (type: GrammarScaleType) => IScale;\n  coordinate: (type: CoordinateType) => ICoordinate;\n  mark: (\n    type: MarkType,\n    group: IGroupMark | string,\n    markOptions?: { glyphType?: string; componentType?: string; mode?: '2d' | '3d' }\n  ) => IMark;\n  group: (group: IGroupMark | string) => IGroupMark;\n  glyph: (glyphType: string, group: IGroupMark | string) => IGlyphMark;\n  component: (componentType: string, group: IGroupMark | string, mode?: '2d' | '3d') => IComponent;\n  axis: (group: IGroupMark | string, mode?: '2d' | '3d') => IAxis;\n  grid: (group: IGroupMark | string, mode?: '2d' | '3d') => IGrid;\n  legend: (group: IGroupMark | string) => ILegend;\n  crosshair: (group: IGroupMark | string) => ICrosshair;\n  slider: (group: IGroupMark | string) => ISlider;\n  label: (group: IGroupMark | string) => ILabel;\n  datazoom: (group: IGroupMark | string) => IDatazoom;\n  player: (group: IGroupMark | string) => IPlayer;\n  tooltip: (group: IGroupMark | string) => ITooltip;\n  dimensionTooltip: (group: IGroupMark | string) => IDimensionTooltip;\n  title: (group: IGroupMark | string) => ITitle;\n  scrollbar: (group: IGroupMark | string) => IScrollbar;\n\n  addGrammar: (grammar: IGrammarBase) => this;\n  removeGrammar: (grammar: string | IGrammarBase) => this;\n  removeAllGrammars: () => this;\n\n  getGrammarById: (id: string) => IGrammarBase | null;\n  getCustomizedById: (id: string) => IGrammarBase | null;\n  getSignalById: <T>(id: string) => ISignal<T> | null;\n  getDataById: (id: string) => IData | null;\n  getScaleById: (id: string) => IScale | null;\n  getCoordinateById: (id: string) => ICoordinate | null;\n  getMarkById: (id: string) => IMark | null;\n  getGrammarsByName: (name: string) => IGrammarBase[];\n  getGrammarsByType: (grammarType: string) => IGrammarBase[];\n  getMarksByType: (markType: string) => IMark[];\n\n  commit: (grammar: IGrammarBase) => this;\n\n  // --- Spec API ---\n  parseSpec: (spec: ViewSpec) => this;\n  updateSpec: (spec: ViewSpec) => this;\n\n  // --- Evaluate API ---\n  run: (runningConfig?: IRunningConfig) => this;\n  runNextTick: (runningConfig?: IRunningConfig) => Promise<this>;\n  runAsync: (runningConfig?: IRunningConfig) => Promise<this>;\n  runSync: (runningConfig?: IRunningConfig) => this;\n  runBefore: (callback: (view: IView) => void) => this;\n  runAfter: (callback: (view: IView) => void) => this;\n\n  // --- Theme API ---\n  theme: (theme: ITheme | string) => this;\n  getCurrentTheme: () => ITheme;\n  setCurrentTheme: (theme: ITheme | string, render?: boolean) => Promise<this>;\n\n  // --- Global Config API ---\n  background: (value?: IColor) => IColor;\n  width: (value?: number) => number;\n  height: (value?: number) => number;\n  viewWidth: (value?: number) => number;\n  viewHeight: (value?: number) => number;\n  padding: (p?: number | { left?: number; right?: number; top?: number; bottom?: number }) => {\n    left: number;\n    right: number;\n    top: number;\n    bottom: number;\n  };\n  getViewBox: () => IBounds;\n\n  // --- Event API ---\n  addEventListener: (type: string, handler: BaseEventHandler, options?: any) => this;\n  removeEventListener: (type: string, handler: BaseEventHandler) => this;\n\n  // --- Other API ---\n  emit: <T extends EventEmitter.EventNames<string | symbol>>(\n    event: T,\n    ...args: EventEmitter.EventArgs<string | symbol, T>\n  ) => boolean;\n\n  resize: (width: number, height: number, render?: boolean) => Promise<this>;\n  traverseMarkTree: (apply: (mark: IMark) => any, filter?: (mark: IMark) => boolean, leafFirst?: boolean) => this;\n\n  getLayoutState: () => string;\n  updateLayoutTag: () => this;\n\n  pauseProgressive: () => boolean;\n  resumeProgressive: () => boolean;\n  restartProgressive: () => boolean;\n\n  release: () => void;\n  getImageBuffer: () => Buffer;\n}\n\nexport interface IViewConstructor {\n  new (options?: IViewOptions, config?: IViewThemeConfig): IView;\n}\n\nexport interface ViewSpec {\n  /** 梳理详细配置 */\n  theme?: string;\n  background?: IColor;\n  width?: number;\n  height?: number;\n  padding?: number | { left?: number; right?: number; top?: number; bottom?: number };\n  signals?: SignalSpec<any>[];\n  projections?: ProjectionSpec[];\n  data?: DataSpec[];\n  scales?: ScaleSpec[];\n  coordinates?: CoordinateSpec[];\n  marks?: MarkSpec[];\n  events?: EventSpec[];\n}\n\nexport interface IRecordedGrammars {\n  record: (grammar: IGrammarBase) => this;\n  unrecord: (grammar: IGrammarBase) => this;\n\n  size: () => number;\n\n  getSignal: <T>(key: string) => ISignal<T> | null;\n  getData: (key: string) => IData | null;\n  getScale: (key: string) => IScale | null;\n  getCoordinate: (key: string) => ICoordinate | null;\n  getMark: (key: string) => IMark | null;\n  getCustomized: (key: string) => IGrammarBase | null;\n  getGrammar: (key: string) => IGrammarBase | null;\n\n  getAllSignals: () => ISignal<any>[];\n  getAllData: () => IData[];\n  getAllScales: () => IScale[];\n  getAllCoordinates: () => ICoordinate[];\n  getAllMarks: () => IMark[];\n  getAllCustomized: () => IGrammarBase[];\n\n  clear: () => void;\n\n  traverse: (func: (grammar: IGrammarBase) => boolean | void) => void;\n  find: (func: (grammar: IGrammarBase) => boolean) => IGrammarBase | null;\n  filter: (func: (grammar: IGrammarBase) => boolean) => IGrammarBase[];\n\n  release: () => void;\n}\n\nexport interface IMarkTreeNode {\n  mark: IMark;\n  parent: IMarkTreeNode;\n  children: IMarkTreeNode[];\n}\n\nexport interface IRecordedTreeGrammars extends IRecordedGrammars {\n  getAllMarkNodes: () => IMarkTreeNode[];\n}\n"]}

package/es/util/data.d.ts

@@ -0,0 +1,3 @@
+import type { DataFormatSpec, Datum } from '../types';
+export declare const parseFormat: (data: any, format?: DataFormatSpec) => Datum[];
+export declare const load: (url: string) => Promise<string>;