@visactor/vgrammar-core 0.7.0

package/es/transforms/util/util.js

@@ -0,0 +1,33 @@
+import { isNil, isString } from "@visactor/vutils";
+
+import { accessorName } from "@visactor/vgrammar-util";
+
+export function fieldNames(fields, as) {
+    return fields ? fields.map(((f, i) => {
+        var _a;
+        return null !== (_a = as[i]) && void 0 !== _a ? _a : isString(f) ? f : accessorName(f);
+    })) : null;
+}
+
+export function partition(data, groupBy, field) {
+    if (isNil(groupBy)) return [ data.map(field) ];
+    const groups = [], map = {};
+    return data.forEach((entry => {
+        const groupKey = groupBy.map((groupFunc => groupFunc(entry))).toString();
+        if (map[groupKey]) map[groupKey].push(field(entry)); else {
+            const groupItem = [];
+            groupItem.dims = groupKey, groups.push(groupItem), map[groupKey] = groupItem;
+        }
+    })), groups;
+}
+
+export function normalizeAngle(angle) {
+    for (;angle < 0; ) angle += 2 * Math.PI;
+    for (;angle >= 2 * Math.PI; ) angle -= 2 * Math.PI;
+    return angle;
+}
+
+export function computeQuadrant(angle) {
+    return (angle = normalizeAngle(angle)) > 0 && angle <= Math.PI / 2 ? 2 : angle > Math.PI / 2 && angle <= Math.PI ? 3 : angle > Math.PI && angle <= 3 * Math.PI / 2 ? 4 : 1;
+}
+//# sourceMappingURL=util.js.map

package/es/transforms/util/util.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transforms/util/util.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAGvD,MAAM,UAAU,UAAU,CAAC,MAAwC,EAAE,EAAa;IAChF,IAAI,CAAC,MAAM,EAAE;QACX,OAAO,IAAI,CAAC;KACb;IACD,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;;QACzB,OAAO,MAAA,EAAE,CAAC,CAAC,CAAC,mCAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;IACtD,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,IAAY,EAAE,OAA+B,EAAE,KAA2B;IAElG,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE;QAClB,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;KAC1B;IAED,MAAM,MAAM,GAAU,EAAE,CAAC;IACzB,MAAM,GAAG,GAAwB,EAAE,CAAC;IACpC,IAAI,CAAC,OAAO,CAAC,CAAC,KAAU,EAAE,EAAE;QAC1B,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,SAA4B,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;QAE5F,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;YAClB,MAAM,SAAS,GAAU,EAAE,CAAC;YAC3B,SAAiB,CAAC,IAAI,GAAG,QAAQ,CAAC;YACnC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACvB,GAAG,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;SAC3B;aAAM;YACL,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;SAClC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,KAAa;IAC1C,OAAO,KAAK,GAAG,CAAC,EAAE;QAChB,KAAK,IAAI,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;KACtB;IACD,OAAO,KAAK,IAAI,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE;QAC3B,KAAK,IAAI,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC;KACtB;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,KAAa;IAC3C,KAAK,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IAC9B,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE;QACrC,OAAO,CAAC,CAAC;KACV;SAAM,IAAI,KAAK,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,EAAE,EAAE;QAClD,OAAO,CAAC,CAAC;KACV;SAAM,IAAI,KAAK,GAAG,IAAI,CAAC,EAAE,IAAI,KAAK,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE;QACxD,OAAO,CAAC,CAAC;KACV;IACD,OAAO,CAAC,CAAC;AACX,CAAC","file":"util.js","sourcesContent":["/* Adapted from vega by University of Washington Interactive Data Lab\n * https://vega.github.io/vega/\n * Licensed under the BSD-3-Clause\n\n * url: https://github.com/vega/vega/blob/main/packages/vega-transforms/src/util/util.js\n * License: https://github.com/vega/vega/blob/main/LICENSE\n * @license\n */\n\nimport { isNil, isString } from '@visactor/vutils';\nimport type { FieldGetterFunction } from '@visactor/vgrammar-util';\nimport { accessorName } from '@visactor/vgrammar-util';\n\n// use either provided alias or accessor field name\nexport function fieldNames(fields: string[] | FieldGetterFunction[], as?: string[]) {\n  if (!fields) {\n    return null;\n  }\n  return fields.map((f, i) => {\n    return as[i] ?? (isString(f) ? f : accessorName(f));\n  });\n}\n\nexport function partition(data?: any[], groupBy?: FieldGetterFunction[], field?: FieldGetterFunction) {\n  // partition data points into groups\n  if (isNil(groupBy)) {\n    return [data.map(field)];\n  }\n\n  const groups: any[] = [];\n  const map: Record<string, any> = {};\n  data.forEach((entry: any) => {\n    const groupKey = groupBy.map((groupFunc: (arg: any) => any) => groupFunc(entry)).toString();\n\n    if (!map[groupKey]) {\n      const groupItem: any[] = [];\n      (groupItem as any).dims = groupKey;\n      groups.push(groupItem);\n      map[groupKey] = groupItem;\n    } else {\n      map[groupKey].push(field(entry));\n    }\n  });\n\n  return groups;\n}\n\nexport function normalizeAngle(angle: number): number {\n  while (angle < 0) {\n    angle += Math.PI * 2;\n  }\n  while (angle >= Math.PI * 2) {\n    angle -= Math.PI * 2;\n  }\n  return angle;\n}\n\nexport function computeQuadrant(angle: number): 1 | 2 | 3 | 4 {\n  angle = normalizeAngle(angle);\n  if (angle > 0 && angle <= Math.PI / 2) {\n    return 2;\n  } else if (angle > Math.PI / 2 && angle <= Math.PI) {\n    return 3;\n  } else if (angle > Math.PI && angle <= (3 * Math.PI) / 2) {\n    return 4;\n  }\n  return 1;\n}\n"]}

package/es/transforms/view/identifier.d.ts

@@ -0,0 +1,2 @@
+import type { IView, IdentifierTransformOptions } from './../../types/';
+export declare const transform: (options: IdentifierTransformOptions, upstreamData: any[], params: any, view?: IView) => any;

package/es/transforms/view/identifier.js

@@ -0,0 +1,13 @@
+import { isNil } from "@visactor/vutils";
+
+const COUNTER_NAME = ":vGrammar_identifier:";
+
+export const transform = (options, upstreamData, params, view) => {
+    isNil(view[COUNTER_NAME]) && (view[COUNTER_NAME] = 0);
+    let id = view[COUNTER_NAME];
+    const as = options.as;
+    return upstreamData.forEach((entry => {
+        entry && isNil(entry[as]) && (id += 1, entry[as] = id);
+    })), view[COUNTER_NAME] = id, id;
+};
+//# sourceMappingURL=identifier.js.map

package/es/transforms/view/identifier.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transforms/view/identifier.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAGzC,MAAM,YAAY,GAAG,uBAAuB,CAAC;AAE7C,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,OAAmC,EAAE,YAAmB,EAAE,MAAW,EAAE,IAAY,EAAE,EAAE;IAC/G,IAAI,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE;QAC7B,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;KACxB;IAED,IAAI,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC;IAC5B,MAAM,EAAE,GAAG,OAAO,CAAC,EAAE,CAAC;IAEtB,YAAY,CAAC,OAAO,CAAC,CAAC,KAAU,EAAE,EAAE;QAClC,IAAI,KAAK,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE;YAC7B,EAAE,IAAI,CAAC,CAAC;YACR,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC;SAChB;IACH,CAAC,CAAC,CAAC;IACH,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,CAAC;IAExB,OAAO,EAAE,CAAC;AACZ,CAAC,CAAC","file":"identifier.js","sourcesContent":["/* Adapted from vega by University of Washington Interactive Data Lab\n * https://vega.github.io/vega/\n * Licensed under the BSD-3-Clause\n\n * url: https://github.com/vega/vega/blob/main/packages/vega-view-transforms/src/Identifier.js\n * License: https://github.com/vega/vega/blob/main/LICENSE\n * @license\n */\n\nimport { isNil } from '@visactor/vutils';\nimport type { IView, IdentifierTransformOptions } from './../../types/';\n\nconst COUNTER_NAME = ':vGrammar_identifier:';\n\nexport const transform = (options: IdentifierTransformOptions, upstreamData: any[], params: any, view?: IView) => {\n  if (isNil(view[COUNTER_NAME])) {\n    view[COUNTER_NAME] = 0;\n  }\n\n  let id = view[COUNTER_NAME];\n  const as = options.as;\n\n  upstreamData.forEach((entry: any) => {\n    if (entry && isNil(entry[as])) {\n      id += 1;\n      entry[as] = id;\n    }\n  });\n  view[COUNTER_NAME] = id;\n\n  return id;\n};\n"]}

package/es/types/animate.d.ts

@@ -0,0 +1,224 @@
+import type { IGraphic, ACustomAnimate, EasingType } from '@visactor/vrender';
+import type { IPointLike } from '@visactor/vutils';
+import type { MarkFunctionCallback, MarkFunctionType } from './mark';
+import type { IMark } from './grammar';
+import type { IElement } from './element';
+export type TypeAnimation<T extends IElement> = (element: T, options: any, animationParameters: IAnimationParameters) => {
+    from?: {
+        [channel: string]: any;
+    };
+    to?: {
+        [channel: string]: any;
+    };
+};
+export interface IClipAnimationOptions {
+    clipDimension?: 'x' | 'y' | 'auto' | 'default';
+}
+export interface IGrowCartesianAnimationOptions {
+    orient?: 'positive' | 'negative';
+    overall?: boolean | number;
+    direction?: 'x' | 'y' | 'xy';
+}
+export interface IGrowAngleAnimationOptions {
+    orient?: 'clockwise' | 'anticlockwise';
+    overall?: boolean | number;
+}
+export interface IGrowRadiusAnimationOptions {
+    orient?: 'inside' | 'outside';
+    overall?: boolean | number;
+}
+export interface IGrowPointsAnimationOptions {
+    orient?: 'positive' | 'negative';
+}
+export interface IGrowPointsOverallAnimationOptions extends IGrowPointsAnimationOptions {
+    center?: IPointLike;
+}
+export interface IScaleAnimationOptions {
+    direction?: 'x' | 'y' | 'xy';
+}
+export interface IMoveAnimationOptions {
+    direction?: 'x' | 'y' | 'xy';
+    orient?: 'positive' | 'negative';
+    offset?: number;
+    point?: {
+        x?: number;
+        y?: number;
+    };
+}
+export interface IRotateAnimationOptions {
+    orient?: 'clockwise' | 'anticlockwise';
+    angle?: number;
+}
+export interface TextItemAttributes {
+    fontSize?: number;
+    lineHeight?: number;
+    font?: string;
+    fontStyle?: string;
+    fontVariant?: string;
+    fontWeight?: string | number;
+    lineBreak?: string;
+    text?: string | string[];
+    limit?: number;
+    align?: string;
+    baseline?: string;
+    ellipsis?: string | boolean;
+    dir?: string;
+}
+export type MarkFunctionValueType<T> = MarkFunctionCallback<T> | T;
+export type IAnimationConfig = IAnimationTimeline | IAnimationTypeConfig;
+export interface IStateAnimationConfig {
+    duration?: number;
+    easing?: EasingType;
+}
+export interface IAnimationTypeConfig {
+    type?: string;
+    channel?: IAnimationChannelAttrs | IAnimationChannelAttributes;
+    custom?: IAnimationChannelInterpolator | IAnimationCustomConstructor;
+    customParameters?: MarkFunctionValueType<any>;
+    easing?: EasingType;
+    delay?: MarkFunctionValueType<number>;
+    duration?: MarkFunctionValueType<number>;
+    oneByOne?: MarkFunctionValueType<boolean | number>;
+    startTime?: MarkFunctionValueType<number>;
+    totalTime?: MarkFunctionValueType<number>;
+    loop?: boolean | number;
+    options?: MarkFunctionValueType<any>;
+    controlOptions?: IAnimationControlOptions;
+}
+export interface IAnimationTimeline {
+    id?: string;
+    timeSlices: IAnimationTimeSlice | IAnimationTimeSlice[];
+    startTime?: MarkFunctionValueType<number>;
+    totalTime?: MarkFunctionValueType<number>;
+    oneByOne?: MarkFunctionValueType<number | boolean>;
+    loop?: MarkFunctionValueType<number | boolean>;
+    partitioner?: MarkFunctionCallback<boolean>;
+    sort?: (datumA: any, datumB: any, elementA: IElement, elementB: IElement, parameters: any) => number;
+    controlOptions?: IAnimationControlOptions;
+}
+export interface IAnimationTimeSlice {
+    effects: IAnimationEffect | IAnimationEffect[];
+    duration?: MarkFunctionValueType<number>;
+    delay?: MarkFunctionValueType<number>;
+}
+export type IAnimationChannelFunction = (datum: any, element: IElement, parameters: IAnimationParameters) => any;
+export type IAnimationChannelAttrs = Record<string, {
+    from?: any | IAnimationChannelFunction;
+    to?: any | IAnimationChannelFunction;
+}>;
+export type IAnimationChannelAttributes = string[];
+export type IAnimationChannelInterpolator = (ratio: number, from: any, to: any, nextAttributes: any, datum: any, element: IElement, parameters: IAnimationParameters) => boolean | void;
+export interface IAnimationCustomConstructor {
+    new (from: any, to: any, duration: number, ease: EasingType, parameters?: any): ACustomAnimate<any>;
+}
+export interface IAnimationEffect {
+    type?: string;
+    channel?: IAnimationChannelAttrs | IAnimationChannelAttributes;
+    custom?: IAnimationChannelInterpolator | IAnimationCustomConstructor;
+    customParameters?: MarkFunctionValueType<any>;
+    easing?: EasingType;
+    options?: MarkFunctionValueType<any>;
+}
+export interface IAnimationControlOptions {
+    stopWhenStateChange?: boolean;
+    immediatelyApply?: boolean;
+}
+export interface IAnimationUnit {
+    initialDelay: number;
+    loopDuration: number;
+    loopDelay: number;
+    loopDelayAfter: number;
+    loopAnimateDuration: number;
+    loopCount: number;
+    totalTime: number;
+    timeSlices: IAnimationTimeSlice[];
+}
+export interface IAnimationRecord {
+    start: IGraphic;
+    end: IGraphic;
+    changes: any[];
+}
+export interface IAnimationParameters {
+    width: number;
+    height: number;
+    mark: IMark;
+    group: IMark | null;
+    elementIndex: number;
+    elementCount: number;
+    view: any;
+}
+export interface IParsedAnimationConfig {
+    state: string;
+    timeline: IAnimationTimeline;
+    originConfig: IAnimationConfig;
+    id: string;
+}
+export interface IParsedAnimationAttrs {
+    from?: any;
+    to?: any;
+    custom?: IAnimationChannelInterpolator | IAnimationCustomConstructor;
+    customParameters?: any;
+}
+export interface IAnimatorOptions {
+    state: string;
+    timeline: IAnimationTimeline;
+    id: string;
+}
+export interface IAnimator {
+    id: number;
+    element: IElement;
+    animationOptions: IAnimatorOptions;
+    isAnimating: boolean;
+    animate: (animationParameters: IAnimationParameters, parameters: any) => this;
+    callback: (callbackFunction: (...args: any[]) => void) => this;
+    stop: (stopState?: 'start' | 'end', invokeCallback?: boolean) => this;
+    pause: () => this;
+    resume: () => this;
+    startAt: (startTime: number) => this;
+    getTotalAnimationTime: () => number;
+    getEndAttributes: () => Record<string, any>;
+}
+export interface IAnimateArranger {
+    parallel: (arranger: IAnimateArranger) => this;
+    after: (arranger: IAnimateArranger) => this;
+    afterArranger: IAnimateArranger;
+    parallelArrangers: IAnimateArranger[];
+    animators: IAnimator[];
+    totalTime: number;
+    startTime: number;
+    endTime: number;
+    arrangeTime: () => void;
+}
+export interface IBaseAnimate {
+    stop: () => this;
+    pause: () => this;
+    resume: () => this;
+    animate: () => this;
+    enable: () => this;
+    disable: () => this;
+    enableAnimationState: (state: string | string[]) => this;
+    disableAnimationState: (state: string | string[]) => this;
+    isAnimating: () => boolean;
+    release: () => void;
+}
+export interface IViewAnimate extends IBaseAnimate {
+    animateAddition: (mark: IMark) => this;
+}
+export interface IAnimate extends IBaseAnimate {
+    mark: IMark;
+    run: (config: IAnimationConfig | IAnimationConfig[]) => IAnimateArranger;
+    runAnimationByState: (animationState: string) => IAnimateArranger;
+    stopAnimationByState: (animationState: string) => this;
+    pauseAnimationByState: (animationState: string) => this;
+    resumeAnimationByState: (animationState: string) => this;
+    reverse: () => this;
+    restart: () => this;
+    record: () => this;
+    recordEnd: () => this;
+    updateConfig: (config: Record<string, IAnimationConfig | IAnimationConfig[]>) => void;
+    updateState: (state: MarkFunctionType<string> | null) => void;
+    isElementAnimating: (element: IElement) => boolean;
+    getAnimatorCount: () => number;
+    getElementAnimators: (element: IElement | IElement[], animationState?: string) => IAnimator[];
+    release: () => void;
+}

package/es/types/animate.js

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

package/es/types/animate.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/animate.ts"],"names":[],"mappings":"","file":"animate.js","sourcesContent":["import type { IGraphic, ACustomAnimate, EasingType } from '@visactor/vrender';\nimport type { IPointLike } from '@visactor/vutils';\nimport type { MarkFunctionCallback, MarkFunctionType } from './mark';\nimport type { IMark } from './grammar';\nimport type { IElement } from './element';\n\nexport type TypeAnimation<T extends IElement> = (\n  element: T,\n  options: any,\n  animationParameters: IAnimationParameters\n) => { from?: { [channel: string]: any }; to?: { [channel: string]: any } };\n\nexport interface IClipAnimationOptions {\n  clipDimension?: 'x' | 'y' | 'auto' | 'default';\n}\n\nexport interface IGrowCartesianAnimationOptions {\n  orient?: 'positive' | 'negative';\n  overall?: boolean | number;\n  direction?: 'x' | 'y' | 'xy';\n}\n\nexport interface IGrowAngleAnimationOptions {\n  orient?: 'clockwise' | 'anticlockwise';\n  overall?: boolean | number;\n}\n\nexport interface IGrowRadiusAnimationOptions {\n  orient?: 'inside' | 'outside';\n  overall?: boolean | number;\n}\n\nexport interface IGrowPointsAnimationOptions {\n  orient?: 'positive' | 'negative';\n}\n\nexport interface IGrowPointsOverallAnimationOptions extends IGrowPointsAnimationOptions {\n  center?: IPointLike;\n}\n\nexport interface IScaleAnimationOptions {\n  direction?: 'x' | 'y' | 'xy';\n}\n\nexport interface IMoveAnimationOptions {\n  direction?: 'x' | 'y' | 'xy';\n  orient?: 'positive' | 'negative';\n  offset?: number;\n  point?: { x?: number; y?: number };\n}\n\nexport interface IRotateAnimationOptions {\n  orient?: 'clockwise' | 'anticlockwise';\n  angle?: number;\n}\n\n/** VGrammar 层提供的图元text上的图形属性，现在暂时会和VRender不一致 */\nexport interface TextItemAttributes {\n  fontSize?: number;\n  lineHeight?: number;\n  font?: string;\n  fontStyle?: string;\n  fontVariant?: string;\n  fontWeight?: string | number;\n  lineBreak?: string;\n  text?: string | string[];\n  limit?: number;\n  align?: string;\n  baseline?: string;\n  ellipsis?: string | boolean;\n  dir?: string;\n}\n\n/** animation */\nexport type MarkFunctionValueType<T> = MarkFunctionCallback<T> | T;\n\nexport type IAnimationConfig = IAnimationTimeline | IAnimationTypeConfig;\n\n/**\n * state动画，暂时只支持简单配置\n */\nexport interface IStateAnimationConfig {\n  duration?: number;\n  easing?: EasingType;\n}\n\n/**\n * 动画 config 简化配置\n */\nexport interface IAnimationTypeConfig {\n  type?: string;\n  channel?: IAnimationChannelAttrs | IAnimationChannelAttributes;\n  custom?: IAnimationChannelInterpolator | IAnimationCustomConstructor;\n  customParameters?: MarkFunctionValueType<any>;\n  easing?: EasingType;\n  delay?: MarkFunctionValueType<number>;\n  duration?: MarkFunctionValueType<number>;\n  oneByOne?: MarkFunctionValueType<boolean | number>;\n  startTime?: MarkFunctionValueType<number>;\n  totalTime?: MarkFunctionValueType<number>;\n  /** loop: true 无限循环; loop: 正整数，表示循环的次数 */\n  loop?: boolean | number;\n  /** 动画 effect 配置项 */\n  options?: MarkFunctionValueType<any>;\n  /** 动画执行相关控制配置项 */\n  controlOptions?: IAnimationControlOptions;\n}\n\n/**\n * 动画 timeline 完整配置，一条时间线内的动画单元只能串行\n * 多个timeline是可以并行的\n * 考虑到同一图元不能在多个timeline上，所以timeline不应该提供数组配置的能力\n */\nexport interface IAnimationTimeline {\n  /** 为了方便动画编排，用户可以设置 id 用于识别时间线 */\n  id?: string;\n  /** 时间切片 */\n  timeSlices: IAnimationTimeSlice | IAnimationTimeSlice[];\n  /** 动画开始的相对时间，可以为负数 */\n  startTime?: MarkFunctionValueType<number>;\n  /** 动画时长 */\n  totalTime?: MarkFunctionValueType<number>;\n  /** 动画依次执行的延迟 */\n  oneByOne?: MarkFunctionValueType<number | boolean>;\n  /** loop: true 无限循环; loop: 正整数，表示循环的次数 */\n  loop?: MarkFunctionValueType<number | boolean>;\n  /** 对图元元素进行划分，和过滤类似，但是不同时间线不能同时作用在相同的元素上 */\n  partitioner?: MarkFunctionCallback<boolean>;\n  /** 对同一时间线上的元素进行排序 */\n  sort?: (datumA: any, datumB: any, elementA: IElement, elementB: IElement, parameters: any) => number;\n  /** 动画执行相关控制配置项 */\n  controlOptions?: IAnimationControlOptions;\n}\n\nexport interface IAnimationTimeSlice {\n  effects: IAnimationEffect | IAnimationEffect[];\n  duration?: MarkFunctionValueType<number>;\n  delay?: MarkFunctionValueType<number>;\n}\n\nexport type IAnimationChannelFunction = (datum: any, element: IElement, parameters: IAnimationParameters) => any;\nexport type IAnimationChannelAttrs = Record<\n  string,\n  {\n    from?: any | IAnimationChannelFunction;\n    to?: any | IAnimationChannelFunction;\n  }\n>;\nexport type IAnimationChannelAttributes = string[];\nexport type IAnimationChannelInterpolator = (\n  ratio: number,\n  from: any,\n  to: any,\n  nextAttributes: any,\n  datum: any,\n  element: IElement,\n  parameters: IAnimationParameters\n) => boolean | void;\n\n// TODO: fix ACustomAnimate<any>\nexport interface IAnimationCustomConstructor {\n  new (from: any, to: any, duration: number, ease: EasingType, parameters?: any): ACustomAnimate<any>;\n}\n\nexport interface IAnimationEffect {\n  type?: string;\n  channel?: IAnimationChannelAttrs | IAnimationChannelAttributes;\n  custom?: IAnimationChannelInterpolator | IAnimationCustomConstructor;\n  customParameters?: MarkFunctionValueType<any>;\n  easing?: EasingType;\n  /** options暂时没有处理 */\n  options?: MarkFunctionValueType<any>;\n}\n\nexport interface IAnimationControlOptions {\n  /** 当动画状态变更时清空动画 */\n  stopWhenStateChange?: boolean;\n  /** 是否立即应用动画初始状态 */\n  immediatelyApply?: boolean;\n}\n\n/**\n * Animation timeline should be parsed into animation units,\n * which record all necessary configs for animator to execute animation.\n *\n * animation unit time:\n * |<--initialDelay-->| |<--loopDelay--><--Slices--><--looDelayAfter-->| |<--loopDuration-->|\n *                      |<-----------------loopDuration--------------->|\n */\nexport interface IAnimationUnit {\n  /**\n   * initial delay time before any animation loop\n   */\n  initialDelay: number;\n  /**\n   * total time for one animation loop\n   */\n  loopDuration: number;\n  /**\n   * delay time before time slices\n   */\n  loopDelay: number;\n  /**\n   * delay time after time slices\n   */\n  loopDelayAfter: number;\n  /**\n   * animating time in one animation loop\n   */\n  loopAnimateDuration: number;\n  loopCount: number;\n  totalTime: number;\n  timeSlices: IAnimationTimeSlice[];\n}\n\nexport interface IAnimationRecord {\n  start: IGraphic;\n  end: IGraphic;\n  changes: any[];\n}\n\nexport interface IAnimationParameters {\n  width: number;\n  height: number;\n  mark: IMark;\n  group: IMark | null;\n  elementIndex: number;\n  elementCount: number;\n  view: any;\n}\n\nexport interface IParsedAnimationConfig {\n  state: string;\n  timeline: IAnimationTimeline;\n  originConfig: IAnimationConfig;\n  id: string;\n}\n\nexport interface IParsedAnimationAttrs {\n  from?: any;\n  to?: any;\n  custom?: IAnimationChannelInterpolator | IAnimationCustomConstructor;\n  customParameters?: any;\n}\n\n// animate structure\n\nexport interface IAnimatorOptions {\n  state: string;\n  timeline: IAnimationTimeline;\n  id: string;\n}\n\nexport interface IAnimator {\n  id: number;\n  element: IElement;\n  animationOptions: IAnimatorOptions;\n  isAnimating: boolean;\n\n  /** execute animation */\n  animate: (animationParameters: IAnimationParameters, parameters: any) => this;\n  /** set animation callback */\n  callback: (callbackFunction: (...args: any[]) => void) => this;\n\n  // animation control\n  stop: (stopState?: 'start' | 'end', invokeCallback?: boolean) => this;\n  pause: () => this;\n  resume: () => this;\n\n  /** set additional initial animation delay */\n  startAt: (startTime: number) => this;\n  /** get total animation execution time */\n  getTotalAnimationTime: () => number;\n\n  getEndAttributes: () => Record<string, any>;\n}\n\nexport interface IAnimateArranger {\n  // animation control api\n  parallel: (arranger: IAnimateArranger) => this;\n  after: (arranger: IAnimateArranger) => this;\n\n  // internal properties\n  afterArranger: IAnimateArranger;\n  parallelArrangers: IAnimateArranger[];\n  animators: IAnimator[];\n  totalTime: number;\n  startTime: number;\n  endTime: number;\n  arrangeTime: () => void;\n}\n\nexport interface IBaseAnimate {\n  // animation control\n  stop: () => this;\n  pause: () => this;\n  resume: () => this;\n\n  // internal animation process api\n  animate: () => this;\n  enable: () => this;\n  disable: () => this;\n  enableAnimationState: (state: string | string[]) => this;\n  disableAnimationState: (state: string | string[]) => this;\n  isAnimating: () => boolean;\n\n  release: () => void;\n}\n\nexport interface IViewAnimate extends IBaseAnimate {\n  animateAddition: (mark: IMark) => this;\n}\n\nexport interface IAnimate extends IBaseAnimate {\n  mark: IMark;\n\n  // additional animation control\n  run: (config: IAnimationConfig | IAnimationConfig[]) => IAnimateArranger;\n  runAnimationByState: (animationState: string) => IAnimateArranger;\n  stopAnimationByState: (animationState: string) => this;\n  pauseAnimationByState: (animationState: string) => this;\n  resumeAnimationByState: (animationState: string) => this;\n  reverse: () => this;\n  restart: () => this;\n  record: () => this;\n  recordEnd: () => this;\n\n  // internal animation process api\n  updateConfig: (config: Record<string, IAnimationConfig | IAnimationConfig[]>) => void;\n  updateState: (state: MarkFunctionType<string> | null) => void;\n  isElementAnimating: (element: IElement) => boolean;\n  getAnimatorCount: () => number;\n  getElementAnimators: (element: IElement | IElement[], animationState?: string) => IAnimator[];\n  release: () => void;\n}\n"]}

package/es/types/base.d.ts

@@ -0,0 +1,36 @@
+export type Nil = null | undefined;
+export type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+export type DistributivePick<T, K extends keyof T> = T extends unknown ? Pick<T, K> : never;
+export type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends Array<infer U> ? Array<Value<U>> : Value<T[P]>;
+};
+type AllowedPrimitives = boolean | string | number | Date;
+type Value<T> = T extends AllowedPrimitives ? T : RecursivePartial<T>;
+export type Vector2<T> = [T, T];
+export type Vector3<T> = [T, T, T];
+export type Vector4<T> = [T, T, T, T];
+export type Vector5<T> = [T, T, T, T, T];
+export type Vector6<T> = [T, T, T, T, T, T];
+export type Vector7<T> = [T, T, T, T, T, T, T];
+export type Vector10<T> = [T, T, T, T, T, T, T, T, T, T];
+export type Vector12<T> = [T, T, T, T, T, T, T, T, T, T, T, T];
+export type CommonPaddingSpec = number | {
+    top?: number;
+    bottom?: number;
+    left?: number;
+    right?: number;
+};
+export type DiffResult<Prev, Next> = {
+    enter: {
+        next: Next;
+    }[];
+    update: {
+        prev: Prev;
+        next: Next;
+    }[];
+    exit: {
+        prev: Prev;
+    }[];
+};
+export type ValueOf<T, K extends keyof T = keyof T> = T[K];
+export {};

package/es/types/base.js

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

package/es/types/base.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/base.ts"],"names":[],"mappings":"","file":"base.js","sourcesContent":["export type Nil = null | undefined;\n\nexport type DistributiveOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;\nexport type DistributivePick<T, K extends keyof T> = T extends unknown ? Pick<T, K> : never;\nexport type RecursivePartial<T> = {\n  [P in keyof T]?: T[P] extends Array<infer U> ? Array<Value<U>> : Value<T[P]>;\n};\ntype AllowedPrimitives =\n  | boolean\n  | string\n  | number\n  | Date /* add any types than should be considered as a value, say, DateTimeOffset */;\ntype Value<T> = T extends AllowedPrimitives ? T : RecursivePartial<T>;\n\nexport type Vector2<T> = [T, T];\nexport type Vector3<T> = [T, T, T];\nexport type Vector4<T> = [T, T, T, T];\nexport type Vector5<T> = [T, T, T, T, T];\nexport type Vector6<T> = [T, T, T, T, T, T];\nexport type Vector7<T> = [T, T, T, T, T, T, T];\nexport type Vector10<T> = [T, T, T, T, T, T, T, T, T, T];\nexport type Vector12<T> = [T, T, T, T, T, T, T, T, T, T, T, T];\n\nexport type CommonPaddingSpec =\n  | number\n  | {\n      top?: number;\n      bottom?: number;\n      left?: number;\n      right?: number;\n    };\n\nexport type DiffResult<Prev, Next> = {\n  enter: { next: Next }[];\n  update: { prev: Prev; next: Next }[];\n  exit: { prev: Prev }[];\n};\n\nexport type ValueOf<T, K extends keyof T = keyof T> = T[K];\n"]}

package/es/types/component.d.ts

@@ -0,0 +1,240 @@
+import type { IGraphicAttribute, ISymbolGraphicAttribute, ITextAttribute, ITextGraphicAttribute } from '@visactor/vrender';
+import type { AxisBaseAttributes, BaseCrosshairAttrs, BaseLabelAttrs, DataLabelAttrs, DataZoomAttributes, Direction, GridBaseAttributes, LegendBaseAttributes, OrientType, PlayerAttributes, ScrollBarAttributes, SliderAttributes, TitleAttrs, TooltipAttributes, TooltipRowAttrs } from '@visactor/vrender-components';
+import type { AxisEnum, ComponentEnum } from '../graph';
+import type { Nil } from './base';
+import type { IComponent, IData, IGroupMark, IMark, IScale } from './grammar';
+import type { ChannelEncodeType, ComponentSpec, FieldEncodeType, GenerateBasicEncoderSpec, MarkFunctionType, ScaleEncodeType } from './mark';
+import type { IPointLike } from '@visactor/vutils';
+import type { IElement } from './element';
+import type { IView } from './view';
+export interface IScaleComponent extends IComponent {
+    scale: (scale?: IScale | string | Nil) => this;
+}
+export interface ScaleComponentSpec<BasicEncoderSpec extends GenerateBasicEncoderSpec<IGraphicAttribute> = GenerateBasicEncoderSpec<IGraphicAttribute>> extends ComponentSpec<BasicEncoderSpec> {
+    scale?: IScale | string;
+}
+export type AxisType = 'line' | 'circle';
+export interface IAxis extends IScaleComponent {
+    axisType: (axisType: AxisType | Nil) => this;
+    tickCount: (tickCount: MarkFunctionType<number> | Nil) => this;
+    inside: (inside: MarkFunctionType<boolean> | Nil) => this;
+    baseValue: (baseValue: MarkFunctionType<number> | Nil) => this;
+    getAxisComponentType: () => keyof typeof AxisEnum;
+}
+export interface AxisSpec extends ScaleComponentSpec<Partial<AxisBaseAttributes>> {
+    componentType: ComponentEnum.axis;
+    axisType?: AxisType;
+    tickCount?: MarkFunctionType<number>;
+    inside?: MarkFunctionType<boolean>;
+    baseValue?: MarkFunctionType<number>;
+}
+export type GridShape = 'line' | 'circle' | 'polygon';
+export interface IGrid extends IScaleComponent {
+    gridType: (gridType: AxisType | Nil) => this;
+    gridShape: (gridShape: GridShape | Nil) => this;
+    target: (axis: IAxis | string | Nil) => this;
+    tickCount: (tickCount: MarkFunctionType<number> | Nil) => this;
+    inside: (inside: MarkFunctionType<boolean> | Nil) => this;
+    baseValue: (baseValue: MarkFunctionType<number> | Nil) => this;
+}
+export interface GridSpec extends ScaleComponentSpec<Partial<GridBaseAttributes>> {
+    componentType: ComponentEnum.grid;
+    gridType?: AxisType;
+    gridShape?: GridShape;
+    target?: IAxis | string;
+    tickCount?: MarkFunctionType<number>;
+    inside?: MarkFunctionType<boolean>;
+    baseValue?: MarkFunctionType<number>;
+}
+export type LegendType = 'auto' | 'discrete' | 'color' | 'size';
+export interface ILegend extends IScaleComponent {
+    legendType: (legendType: LegendType | Nil) => this;
+    target: (data: IData | string | Nil, filter: string | ((datum: any, legendValues: any) => boolean) | Nil) => this;
+    setSelected: (selectedValues: any[]) => this;
+}
+export interface LegendSpec extends ScaleComponentSpec<LegendBaseAttributes> {
+    componentType: ComponentEnum.legend;
+    legendType?: LegendType;
+    shapeScale?: IScale | string;
+    target?: {
+        data: IData | string;
+        filter: string | ((datum: any, legendValues: any[]) => boolean);
+    };
+}
+export type CrosshairType = 'x' | 'y' | 'angle' | 'radius' | 'radius-polygon';
+export type CrosshairShape = 'line' | 'rect';
+export interface ICrosshair extends IScaleComponent {
+    crosshairType: (crosshairType: CrosshairType | Nil) => this;
+    crosshairShape: (crosshairShape: CrosshairShape | Nil) => this;
+}
+export interface CrosshairSpec extends ScaleComponentSpec<BaseCrosshairAttrs> {
+    componentType: ComponentEnum.crosshair;
+    crosshairType?: CrosshairType;
+    crosshairShape?: CrosshairShape;
+    componentConfig?: {
+        radius?: number;
+        center?: IPointLike;
+    };
+}
+export type SliderFilterValue = {
+    start: number;
+    end: number;
+};
+export interface ISlider extends IComponent {
+    min: (min: MarkFunctionType<number> | Nil) => this;
+    max: (max: MarkFunctionType<number> | Nil) => this;
+    target: (data: IData | string | Nil, filter: string | ((datum: any, value: SliderFilterValue) => boolean) | Nil) => this;
+    setStartEndValue: (start?: number, end?: number) => this;
+}
+export interface SliderSpec extends ComponentSpec<Partial<SliderAttributes>> {
+    componentType: ComponentEnum.slider;
+    min?: MarkFunctionType<number>;
+    max?: MarkFunctionType<number>;
+    target?: {
+        data: IData | string;
+        filter: string | ((datum: any, value: SliderFilterValue) => boolean);
+    };
+}
+export type DatazoomFilterValue = {
+    start: number;
+    end: number;
+    startRatio: number;
+    endRatio: number;
+};
+export interface IDatazoom extends IComponent {
+    preview: (data: IData | string | Nil, x: ScaleEncodeType | Nil, y: ScaleEncodeType | Nil, x1?: ChannelEncodeType | Nil, y1?: ChannelEncodeType | Nil) => this;
+    target: (data: IData | string | Nil, filter: string | ((datum: any, value: DatazoomFilterValue) => boolean) | Nil) => this;
+    setStartEndValue: (start?: number, end?: number) => this;
+}
+export type DataZoomEncoderSpec = GenerateBasicEncoderSpec<Partial<DataZoomAttributes> & {
+    x1?: number;
+    y1?: number;
+}>;
+export interface DatazoomSpec extends ComponentSpec<DataZoomEncoderSpec> {
+    componentType: ComponentEnum.datazoom;
+    preview?: {
+        data: IData | string;
+        x?: ScaleEncodeType;
+        y?: ScaleEncodeType;
+        x1?: ChannelEncodeType;
+        y1?: ChannelEncodeType;
+    };
+    target?: {
+        data: IData | string;
+        filter: string | ((datum: any, value: DatazoomFilterValue) => boolean);
+    };
+}
+export interface ILabel extends IComponent {
+    labelStyle: (attributes: MarkFunctionType<Partial<BaseLabelAttrs>>) => this;
+    size: (attributes: MarkFunctionType<DataLabelAttrs['size']>) => this;
+    target: (mark: IMark | IMark[] | string | string[] | Nil) => this;
+}
+export type LabelEncoderSpec = GenerateBasicEncoderSpec<Partial<BaseLabelAttrs> & {
+    text?: ITextAttribute['text'];
+}>;
+export interface LabelSpec extends ComponentSpec<LabelEncoderSpec> {
+    componentType: ComponentEnum.label;
+    labelStyle?: MarkFunctionType<Partial<BaseLabelAttrs>>;
+    size?: MarkFunctionType<DataLabelAttrs['size']>;
+    target?: IMark | IMark[] | string | string[];
+}
+export type PlayerType = 'auto' | 'discrete' | 'continuous';
+export type PlayerFilterValue = {
+    index: number;
+    value: any;
+};
+export interface IPlayer extends IComponent {
+    playerType: (playerType: PlayerType) => this;
+    target: (data: IData | string | Nil, source: IData | string | any[] | Nil) => this;
+    play: () => this;
+    pause: () => this;
+    backward: () => this;
+    forward: () => this;
+}
+export interface PlayerSpec extends ComponentSpec<Partial<PlayerAttributes>> {
+    componentType: ComponentEnum.player;
+    playerType?: PlayerType;
+    target?: {
+        data: IData | string;
+        source: IData | string | any[];
+    };
+}
+export type CustomTooltipCallback = (datum: any, element: IElement, parameters: any) => TooltipRowAttrs | TooltipRowAttrs[];
+export interface ITooltipRow {
+    visible?: boolean;
+    key?: MarkFunctionType<string | Partial<ITextGraphicAttribute>> | FieldEncodeType;
+    value?: MarkFunctionType<string | Partial<ITextGraphicAttribute>> | FieldEncodeType;
+    symbol?: MarkFunctionType<string | Partial<ISymbolGraphicAttribute>> | FieldEncodeType;
+}
+export interface IBaseTooltip extends IComponent {
+    title: (title: ITooltipRow | string | CustomTooltipCallback | Nil) => this;
+    content: (content: ITooltipRow | ITooltipRow[] | CustomTooltipCallback | Nil) => this;
+}
+export interface ITooltip extends IBaseTooltip {
+    target: (mark: IMark | IMark[] | string | string[] | Nil) => this;
+}
+export interface BaseTooltipSpec extends ComponentSpec<TooltipAttributes> {
+    title?: ITooltipRow | string | CustomTooltipCallback;
+    content?: ITooltipRow | ITooltipRow[] | CustomTooltipCallback;
+}
+export interface TooltipSpec extends BaseTooltipSpec {
+    componentType: ComponentEnum.tooltip;
+    target?: IMark | IMark[] | string | string[];
+}
+export type TooltipType = 'x' | 'y' | 'angle' | 'radius';
+export interface IDimensionTooltip extends IBaseTooltip {
+    scale: (scale?: IScale | string | Nil) => this;
+    tooltipType: (tooltipType: TooltipType | Nil) => this;
+    target: (data: IData | string | Nil, filter: string | ((datum: any, tooltipValue: any) => boolean) | Nil) => this;
+    avoidMark: (mark: IMark | IMark[] | string | string[] | Nil) => this;
+}
+export interface DimensionTooltipSpec extends BaseTooltipSpec {
+    componentType: ComponentEnum.dimensionTooltip;
+    scale?: IScale | string;
+    tooltipType?: TooltipType;
+    target?: {
+        data: IData | string;
+        filter: string | ((datum: any, tooltipValue: any) => boolean);
+    };
+    avoidMark?: IMark | IMark[] | string | string[];
+    componentConfig?: {
+        center?: IPointLike;
+    };
+}
+export interface ITitle extends IComponent {
+    title: (text: MarkFunctionType<string | number | number[] | string[]> | Nil) => this;
+    subTitle: (text: MarkFunctionType<string | number | number[] | string[]> | Nil) => this;
+}
+export interface TitleSpec extends ComponentSpec<Partial<TitleAttrs>> {
+    componentType: ComponentEnum.title;
+    title?: MarkFunctionType<string | number | number[] | string[]>;
+    subTitle?: MarkFunctionType<string | number | number[] | string[]>;
+}
+export type ScrollbarFilterValue = {
+    start?: number;
+    end?: number;
+    startRatio: number;
+    endRatio: number;
+};
+export interface IScrollbar extends IScaleComponent {
+    target: (data: IData | string | Nil, filter: string | ((datum: any, value: ScrollbarFilterValue) => boolean) | Nil) => this;
+    container: (container: IGroupMark | string | Nil) => this;
+    direction: (direction: MarkFunctionType<Direction> | Nil) => this;
+    position: (position: MarkFunctionType<OrientType> | Nil) => this;
+    setScrollStart: (start: number) => this;
+}
+export interface ScrollbarSpec extends ScaleComponentSpec<Partial<ScrollBarAttributes>> {
+    componentType: ComponentEnum.scrollbar;
+    target?: {
+        data: IData | string;
+        filter: string | ((datum: any, value: ScrollbarFilterValue) => boolean);
+    };
+    container?: IGroupMark | string;
+    direction?: MarkFunctionType<Direction>;
+    position?: MarkFunctionType<OrientType>;
+}
+export type BuiltInComponentSpec = AxisSpec | LegendSpec | CrosshairSpec | SliderSpec | DatazoomSpec | LabelSpec | PlayerSpec | TooltipSpec | DimensionTooltipSpec | TitleSpec | ScrollbarSpec;
+export interface IComponentConstructor {
+    readonly componentType: string;
+    new (view: IView, group?: IGroupMark, mode?: '2d' | '3d'): IComponent;
+}

package/es/types/component.js

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

package/es/types/component.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types/component.ts"],"names":[],"mappings":"","file":"component.js","sourcesContent":["import type {\n  IGraphicAttribute,\n  ISymbolGraphicAttribute,\n  ITextAttribute,\n  ITextGraphicAttribute\n} from '@visactor/vrender';\nimport type {\n  AxisBaseAttributes,\n  BaseCrosshairAttrs,\n  BaseLabelAttrs,\n  DataLabelAttrs,\n  DataZoomAttributes,\n  Direction,\n  GridBaseAttributes,\n  LegendBaseAttributes,\n  OrientType,\n  PlayerAttributes,\n  ScrollBarAttributes,\n  SliderAttributes,\n  TitleAttrs,\n  TooltipAttributes,\n  TooltipRowAttrs\n} from '@visactor/vrender-components';\nimport type { AxisEnum, ComponentEnum } from '../graph';\nimport type { Nil } from './base';\nimport type { IComponent, IData, IGroupMark, IMark, IScale } from './grammar';\nimport type {\n  ChannelEncodeType,\n  ComponentSpec,\n  FieldEncodeType,\n  GenerateBasicEncoderSpec,\n  MarkFunctionType,\n  ScaleEncodeType\n} from './mark';\nimport type { IPointLike } from '@visactor/vutils';\nimport type { IElement } from './element';\nimport type { IView } from './view';\n\n// scale component\n\nexport interface IScaleComponent extends IComponent {\n  scale: (scale?: IScale | string | Nil) => this;\n}\n\nexport interface ScaleComponentSpec<\n  BasicEncoderSpec extends GenerateBasicEncoderSpec<IGraphicAttribute> = GenerateBasicEncoderSpec<IGraphicAttribute>\n> extends ComponentSpec<BasicEncoderSpec> {\n  scale?: IScale | string;\n}\n\n// axis component\n\nexport type AxisType = 'line' | 'circle';\n\nexport interface IAxis extends IScaleComponent {\n  axisType: (axisType: AxisType | Nil) => this;\n  tickCount: (tickCount: MarkFunctionType<number> | Nil) => this;\n  inside: (inside: MarkFunctionType<boolean> | Nil) => this;\n  baseValue: (baseValue: MarkFunctionType<number> | Nil) => this;\n\n  // internal interface\n  getAxisComponentType: () => keyof typeof AxisEnum;\n}\n\nexport interface AxisSpec extends ScaleComponentSpec<Partial<AxisBaseAttributes>> {\n  componentType: ComponentEnum.axis;\n  axisType?: AxisType;\n  tickCount?: MarkFunctionType<number>;\n  inside?: MarkFunctionType<boolean>;\n  baseValue?: MarkFunctionType<number>;\n}\n\n// grid component\n\nexport type GridShape = 'line' | 'circle' | 'polygon';\n\nexport interface IGrid extends IScaleComponent {\n  gridType: (gridType: AxisType | Nil) => this;\n  gridShape: (gridShape: GridShape | Nil) => this;\n  target: (axis: IAxis | string | Nil) => this;\n  tickCount: (tickCount: MarkFunctionType<number> | Nil) => this;\n  inside: (inside: MarkFunctionType<boolean> | Nil) => this;\n  baseValue: (baseValue: MarkFunctionType<number> | Nil) => this;\n}\n\nexport interface GridSpec extends ScaleComponentSpec<Partial<GridBaseAttributes>> {\n  componentType: ComponentEnum.grid;\n  gridType?: AxisType;\n  gridShape?: GridShape;\n  target?: IAxis | string;\n  tickCount?: MarkFunctionType<number>;\n  inside?: MarkFunctionType<boolean>;\n  baseValue?: MarkFunctionType<number>;\n}\n\n// legend component\n\nexport type LegendType = 'auto' | 'discrete' | 'color' | 'size';\n\nexport interface ILegend extends IScaleComponent {\n  legendType: (legendType: LegendType | Nil) => this;\n  target: (data: IData | string | Nil, filter: string | ((datum: any, legendValues: any) => boolean) | Nil) => this;\n\n  // immediate functions\n  setSelected: (selectedValues: any[]) => this;\n}\n\nexport interface LegendSpec extends ScaleComponentSpec<LegendBaseAttributes> {\n  componentType: ComponentEnum.legend;\n  legendType?: LegendType;\n  shapeScale?: IScale | string;\n  target?: {\n    data: IData | string;\n    filter: string | ((datum: any, legendValues: any[]) => boolean);\n  };\n}\n\n// crosshair component\n\nexport type CrosshairType = 'x' | 'y' | 'angle' | 'radius' | 'radius-polygon';\n\nexport type CrosshairShape = 'line' | 'rect';\n\nexport interface ICrosshair extends IScaleComponent {\n  crosshairType: (crosshairType: CrosshairType | Nil) => this;\n  crosshairShape: (crosshairShape: CrosshairShape | Nil) => this;\n}\n\nexport interface CrosshairSpec extends ScaleComponentSpec<BaseCrosshairAttrs> {\n  componentType: ComponentEnum.crosshair;\n  crosshairType?: CrosshairType;\n  crosshairShape?: CrosshairShape;\n  componentConfig?: { radius?: number; center?: IPointLike };\n}\n\n// slider component\n\nexport type SliderFilterValue = { start: number; end: number };\n\nexport interface ISlider extends IComponent {\n  min: (min: MarkFunctionType<number> | Nil) => this;\n  max: (max: MarkFunctionType<number> | Nil) => this;\n  target: (\n    data: IData | string | Nil,\n    filter: string | ((datum: any, value: SliderFilterValue) => boolean) | Nil\n  ) => this;\n\n  // immediate functions\n  setStartEndValue: (start?: number, end?: number) => this;\n}\n\nexport interface SliderSpec extends ComponentSpec<Partial<SliderAttributes>> {\n  componentType: ComponentEnum.slider;\n  min?: MarkFunctionType<number>;\n  max?: MarkFunctionType<number>;\n  target?: {\n    data: IData | string;\n    filter: string | ((datum: any, value: SliderFilterValue) => boolean);\n  };\n}\n\n// datazoom component\n\nexport type DatazoomFilterValue = { start: number; end: number; startRatio: number; endRatio: number };\n\nexport interface IDatazoom extends IComponent {\n  preview: (\n    data: IData | string | Nil,\n    x: ScaleEncodeType | Nil,\n    y: ScaleEncodeType | Nil,\n    x1?: ChannelEncodeType | Nil,\n    y1?: ChannelEncodeType | Nil\n  ) => this;\n  target: (\n    data: IData | string | Nil,\n    filter: string | ((datum: any, value: DatazoomFilterValue) => boolean) | Nil\n  ) => this;\n\n  // immediate functions\n  setStartEndValue: (start?: number, end?: number) => this;\n}\n\nexport type DataZoomEncoderSpec = GenerateBasicEncoderSpec<Partial<DataZoomAttributes> & { x1?: number; y1?: number }>;\nexport interface DatazoomSpec extends ComponentSpec<DataZoomEncoderSpec> {\n  componentType: ComponentEnum.datazoom;\n  preview?: {\n    data: IData | string;\n    x?: ScaleEncodeType;\n    y?: ScaleEncodeType;\n    x1?: ChannelEncodeType;\n    y1?: ChannelEncodeType;\n  };\n  target?: {\n    data: IData | string;\n    filter: string | ((datum: any, value: DatazoomFilterValue) => boolean);\n  };\n}\n\n// label component\n\nexport interface ILabel extends IComponent {\n  labelStyle: (attributes: MarkFunctionType<Partial<BaseLabelAttrs>>) => this;\n  size: (attributes: MarkFunctionType<DataLabelAttrs['size']>) => this;\n  target: (mark: IMark | IMark[] | string | string[] | Nil) => this;\n}\n\nexport type LabelEncoderSpec = GenerateBasicEncoderSpec<Partial<BaseLabelAttrs> & { text?: ITextAttribute['text'] }>;\nexport interface LabelSpec extends ComponentSpec<LabelEncoderSpec> {\n  componentType: ComponentEnum.label;\n  labelStyle?: MarkFunctionType<Partial<BaseLabelAttrs>>;\n  size?: MarkFunctionType<DataLabelAttrs['size']>;\n  target?: IMark | IMark[] | string | string[];\n}\n\n// player component\n\nexport type PlayerType = 'auto' | 'discrete' | 'continuous';\n\nexport type PlayerFilterValue = { index: number; value: any };\n\nexport interface IPlayer extends IComponent {\n  playerType: (playerType: PlayerType) => this;\n  target: (data: IData | string | Nil, source: IData | string | any[] | Nil) => this;\n\n  // immediate functions\n  play: () => this;\n  pause: () => this;\n  backward: () => this;\n  forward: () => this;\n}\n\nexport interface PlayerSpec extends ComponentSpec<Partial<PlayerAttributes>> {\n  componentType: ComponentEnum.player;\n  playerType?: PlayerType;\n  target?: {\n    data: IData | string;\n    source: IData | string | any[];\n  };\n}\n\n// tooltip component\n\nexport type CustomTooltipCallback = (\n  datum: any,\n  element: IElement,\n  parameters: any\n) => TooltipRowAttrs | TooltipRowAttrs[];\n\nexport interface ITooltipRow {\n  visible?: boolean;\n  key?: MarkFunctionType<string | Partial<ITextGraphicAttribute>> | FieldEncodeType;\n  value?: MarkFunctionType<string | Partial<ITextGraphicAttribute>> | FieldEncodeType;\n  symbol?: MarkFunctionType<string | Partial<ISymbolGraphicAttribute>> | FieldEncodeType;\n}\n\nexport interface IBaseTooltip extends IComponent {\n  title: (title: ITooltipRow | string | CustomTooltipCallback | Nil) => this;\n  content: (content: ITooltipRow | ITooltipRow[] | CustomTooltipCallback | Nil) => this;\n}\n\nexport interface ITooltip extends IBaseTooltip {\n  target: (mark: IMark | IMark[] | string | string[] | Nil) => this;\n}\n\nexport interface BaseTooltipSpec extends ComponentSpec<TooltipAttributes> {\n  title?: ITooltipRow | string | CustomTooltipCallback;\n  content?: ITooltipRow | ITooltipRow[] | CustomTooltipCallback;\n}\n\nexport interface TooltipSpec extends BaseTooltipSpec {\n  componentType: ComponentEnum.tooltip;\n  target?: IMark | IMark[] | string | string[];\n}\n\nexport type TooltipType = 'x' | 'y' | 'angle' | 'radius';\n\nexport interface IDimensionTooltip extends IBaseTooltip {\n  scale: (scale?: IScale | string | Nil) => this;\n  tooltipType: (tooltipType: TooltipType | Nil) => this;\n  target: (data: IData | string | Nil, filter: string | ((datum: any, tooltipValue: any) => boolean) | Nil) => this;\n  avoidMark: (mark: IMark | IMark[] | string | string[] | Nil) => this;\n}\n\nexport interface DimensionTooltipSpec extends BaseTooltipSpec {\n  componentType: ComponentEnum.dimensionTooltip;\n  scale?: IScale | string;\n  tooltipType?: TooltipType;\n  target?: {\n    data: IData | string;\n    filter: string | ((datum: any, tooltipValue: any) => boolean);\n  };\n  avoidMark?: IMark | IMark[] | string | string[];\n  componentConfig?: { center?: IPointLike };\n}\n\n// title component\n\nexport interface ITitle extends IComponent {\n  title: (text: MarkFunctionType<string | number | number[] | string[]> | Nil) => this;\n  subTitle: (text: MarkFunctionType<string | number | number[] | string[]> | Nil) => this;\n}\n\nexport interface TitleSpec extends ComponentSpec<Partial<TitleAttrs>> {\n  componentType: ComponentEnum.title;\n  title?: MarkFunctionType<string | number | number[] | string[]>;\n  subTitle?: MarkFunctionType<string | number | number[] | string[]>;\n}\n\n// scrollbar component\n\nexport type ScrollbarFilterValue = { start?: number; end?: number; startRatio: number; endRatio: number };\n\nexport interface IScrollbar extends IScaleComponent {\n  target: (\n    data: IData | string | Nil,\n    filter: string | ((datum: any, value: ScrollbarFilterValue) => boolean) | Nil\n  ) => this;\n  container: (container: IGroupMark | string | Nil) => this;\n  direction: (direction: MarkFunctionType<Direction> | Nil) => this;\n  position: (position: MarkFunctionType<OrientType> | Nil) => this;\n\n  // immediate functions\n  setScrollStart: (start: number) => this;\n}\n\nexport interface ScrollbarSpec extends ScaleComponentSpec<Partial<ScrollBarAttributes>> {\n  componentType: ComponentEnum.scrollbar;\n  target?: {\n    data: IData | string;\n    filter: string | ((datum: any, value: ScrollbarFilterValue) => boolean);\n  };\n  container?: IGroupMark | string;\n  direction?: MarkFunctionType<Direction>;\n  position?: MarkFunctionType<OrientType>;\n}\n\n// built-in components\n\nexport type BuiltInComponentSpec =\n  | AxisSpec\n  | LegendSpec\n  | CrosshairSpec\n  | SliderSpec\n  | DatazoomSpec\n  | LabelSpec\n  | PlayerSpec\n  | TooltipSpec\n  | DimensionTooltipSpec\n  | TitleSpec\n  | ScrollbarSpec;\n\nexport interface IComponentConstructor {\n  readonly componentType: string;\n\n  new (view: IView, group?: IGroupMark, mode?: '2d' | '3d'): IComponent;\n}\n"]}

package/es/types/coordinate.d.ts

@@ -0,0 +1,15 @@
+import type { IBaseCoordinate, CoordinateType } from '@visactor/vgrammar-coordinate';
+import type { GrammarSpec } from './grammar';
+import type { GenericFunctionType } from './signal';
+export type CoordinateFunctionCallback<T> = (scale: IBaseCoordinate, parameters: any) => T;
+export type CoordinateFunctionType<T> = GenericFunctionType<CoordinateFunctionCallback<T>, T>;
+export interface CoordinateSpec extends GrammarSpec {
+    type: CoordinateType;
+    start?: CoordinateFunctionType<[number, number]>;
+    end?: CoordinateFunctionType<[number, number]>;
+    origin?: CoordinateFunctionType<[number, number]>;
+    translate?: CoordinateFunctionType<[number, number]>;
+    rotate?: CoordinateFunctionType<number>;
+    scale?: CoordinateFunctionType<[number, number]>;
+    transpose?: CoordinateFunctionType<boolean>;
+}