@visactor/vchart 1.2.0-beta.6 → 1.2.0-beta.7

package/build/es5/component/tooltip/handler/dom/model/title-model.d.ts

@@ -0,0 +1,15 @@
+import type { Maybe } from '@visactor/vutils';
+import { BaseTooltipModel } from './base-tooltip-model';
+import { ShapeModel } from './shape-model';
+import { TextModel } from './text-model';
+export declare class TitleModel extends BaseTooltipModel {
+    shape: Maybe<ShapeModel>;
+    textSpan: Maybe<TextModel>;
+    init(): void;
+    private _initShape;
+    private _releaseShape;
+    private _initTextSpan;
+    setStyle(style?: Partial<CSSStyleDeclaration>): void;
+    setContent(): void;
+    release(): void;
+}

package/build/es5/component/tooltip/handler/dom/model/tooltip-model.d.ts

@@ -0,0 +1,21 @@
+import { BaseTooltipModel } from './base-tooltip-model';
+import { ContentModel } from './content-model';
+import type { ITooltipModelOption } from './interface';
+import { TitleModel } from './title-model';
+export declare class TooltipModel extends BaseTooltipModel {
+    title: TitleModel | null;
+    content: ContentModel | null;
+    private _classList;
+    private _id;
+    constructor(parent: BaseTooltipModel | HTMLElement, option: ITooltipModelOption, classList: string[], id: string);
+    setVisibility(visibility: boolean): void;
+    init(): void;
+    private _initPanel;
+    private _initTitle;
+    private _releaseTitle;
+    private _initContent;
+    private _releaseContent;
+    setStyle(): void;
+    setContent(): void;
+    release(): void;
+}

package/build/es5/component/tooltip/handler/dom/util.d.ts

@@ -0,0 +1,6 @@
+import type { Maybe } from '@visactor/vutils';
+import type { ITooltipStyle } from '../interface';
+import type { IDomTooltipStyle } from './interface';
+import type { TooltipAttributes } from '@visactor/vrender-components';
+export declare const getPixelPropertyStr: (num?: number | number[], defaultStr?: string) => string;
+export declare function getDomStyles(style: ITooltipStyle, attributeCache?: Maybe<TooltipAttributes>): IDomTooltipStyle;

package/build/es5/component/tooltip/handler/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dom';
+export * from './canvas';

package/build/es5/component/tooltip/handler/interface/index.d.ts

@@ -0,0 +1 @@
+export * from './style';

package/build/es5/component/tooltip/handler/interface/style.d.ts

@@ -0,0 +1,27 @@
+import type { ITextAttribute, IFillStyle, IRectGraphicAttribute, RichTextWordBreak } from '@visactor/vrender';
+import type { IPadding } from '../../../../typings';
+export interface ITooltipTextStyle extends Partial<ITextAttribute & IFillStyle> {
+    spacing: number;
+    multiLine: boolean;
+    maxWidth?: number;
+    wordBreak?: RichTextWordBreak;
+}
+export interface ITooltipPanelStyle extends Partial<IRectGraphicAttribute> {
+    shadow: boolean;
+    shadowSpread?: number;
+}
+export interface ITooltipStyle {
+    panel: ITooltipPanelStyle;
+    title: ITooltipTextStyle;
+    shape: {
+        fill: boolean;
+        size: number;
+        spacing: number;
+    };
+    key: ITooltipTextStyle;
+    value: ITooltipTextStyle;
+    padding: IPadding;
+    spaceRow: number;
+    enterable: boolean;
+    transitionDuration: number;
+}

package/build/es5/component/tooltip/handler/utils/attribute.d.ts

@@ -0,0 +1,11 @@
+import type { TooltipAttributes } from '@visactor/vrender-components';
+import type { IToolTipActual, MaybeArray } from '../../../../typings';
+import type { ITooltipStyle, ITooltipTextStyle } from '../interface';
+export declare const getTooltipAttributes: (actualTooltip: IToolTipActual, style: ITooltipStyle) => TooltipAttributes;
+interface ITooltipTextInfo {
+    width: number;
+    height: number;
+    text: MaybeArray<number> | MaybeArray<string>;
+}
+export declare const measureTooltipText: (text: string, style: ITooltipTextStyle) => ITooltipTextInfo;
+export {};

package/build/es5/component/tooltip/handler/utils/common.d.ts

@@ -0,0 +1,10 @@
+import type { Datum } from '@visactor/vgrammar';
+import type { MaybeArray, TooltipContentProperty, TooltipData, TooltipPatternProperty } from '../../../../typings';
+import type { TooltipHandlerParams } from '../../interface';
+export declare function escapeHTML(value: any): string;
+export declare const getTooltipContentValue: <T>(field?: TooltipContentProperty<T>, datum?: any, params?: TooltipHandlerParams) => T;
+export declare const getTooltipPatternValue: <T>(field?: MaybeArray<TooltipPatternProperty<T>>, data?: TooltipData, params?: TooltipHandlerParams) => MaybeArray<TooltipPatternProperty<T>> extends TooltipPatternProperty<T>[] ? MaybeArray<T> : T;
+export declare function getFirstDatumFromTooltipData(data: TooltipData): Datum;
+export declare function pickFirstValidValue<T>(isValid: (element?: T) => any, ...elements: T[]): T | undefined;
+export declare function convertToColorString(color: any, defaultColor?: string): string;
+export declare const getScale: (element: HTMLElement, boundingClientRect?: DOMRect) => number;

package/build/es5/component/tooltip/handler/utils/compose.d.ts

@@ -0,0 +1,5 @@
+import type { TooltipContent } from '../../tooltip';
+import type { IToolTipLinePattern, ITooltipPattern, TooltipData, IToolTipLineActual } from '../../../../typings/tooltip';
+import type { TooltipHandlerParams } from '../../interface';
+export declare const getShowContent: (pattern: ITooltipPattern, data: TooltipData, params: TooltipHandlerParams) => TooltipContent | null;
+export declare const getOneLineData: (datum: any, config: IToolTipLinePattern, params: TooltipHandlerParams) => IToolTipLineActual;

package/build/es5/component/tooltip/handler/utils/get-spec.d.ts

@@ -0,0 +1,5 @@
+import type { ITooltipSpec } from '../../interface';
+import type { TooltipActiveType } from '../../../../typings';
+import type { ISeries } from '../../../../series/interface';
+import type { IDimensionInfo } from '../../../../event/events/dimension/interface';
+export declare const getTooltipSpecForShow: (activeType: TooltipActiveType, globalSpec: ITooltipSpec, series?: ISeries, dimensionInfo?: IDimensionInfo[]) => ITooltipSpec;

package/build/es5/component/tooltip/handler/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './common';
+export * from './compose';
+export * from './pattern';
+export * from './get-spec';
+export * from './position';
+export * from './attribute';
+export * from './style';

package/build/es5/component/tooltip/handler/utils/pattern.d.ts

@@ -0,0 +1,4 @@
+import type { IDimensionInfo } from '../../../../event/events/dimension/interface';
+import type { ISeries } from '../../../../series/interface';
+import type { ITooltipPattern, TooltipActiveType } from '../../../../typings';
+export declare const makeDefaultPattern: (series: ISeries, activeType: TooltipActiveType, dimensionInfo?: IDimensionInfo[]) => ITooltipPattern | null;

package/build/es5/component/tooltip/handler/utils/position.d.ts

@@ -0,0 +1 @@
+export declare const getActualTooltipPositionValue: (position: number | ((event: MouseEvent) => number), event: MouseEvent) => number;

package/build/es5/component/tooltip/handler/utils/style.d.ts

@@ -0,0 +1,4 @@
+import type { ITheme } from '../../../../theme';
+import type { ITooltipTextTheme } from '../../interface';
+import type { ITooltipTextStyle } from '../interface';
+export declare function getTextAttributes(style?: ITooltipTextTheme, globalTheme?: ITheme): ITooltipTextStyle;

package/build/es5/component/tooltip/index.d.ts

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

package/build/es5/component/tooltip/interface/common.d.ts

@@ -0,0 +1,24 @@
+import type { IModel } from './../../../model/interface';
+import type { DimensionEventParams } from '../../../event/events/dimension/interface';
+import type { BaseEventParams } from '../../../event/interface';
+import type { DimensionTooltipInfo, MarkTooltipInfo } from '../processor/interface';
+import type { Datum, IShowTooltipOption } from '../../../typings';
+export type TooltipHandlerParams = (BaseEventParams | DimensionEventParams) & {
+    changePositionOnly?: boolean;
+};
+export interface ITooltipActiveTypeAsKeys<T, K> {
+    mark: T;
+    dimension: K;
+}
+export type TotalMouseEventData = {
+    tooltipInfo: Partial<ITooltipActiveTypeAsKeys<MarkTooltipInfo, DimensionTooltipInfo>>;
+    ignore: Partial<ITooltipActiveTypeAsKeys<boolean, boolean>>;
+};
+export declare enum TooltipResult {
+    success = 0,
+    failed = 1
+}
+export interface ITooltip extends IModel {
+    getVisible: () => boolean;
+    showTooltip: (datum: Datum, options: IShowTooltipOption) => void;
+}

package/build/es5/component/tooltip/interface/event.d.ts

@@ -0,0 +1,8 @@
+import type { TooltipActiveType, TooltipData } from '../../../typings';
+import type { IComponent } from '../../interface/common';
+import type { TooltipHandlerParams } from './common';
+export type TooltipEventParams = TooltipHandlerParams & {
+    activeType?: TooltipActiveType;
+    tooltipData?: TooltipData;
+    tooltip: IComponent;
+};

package/build/es5/component/tooltip/interface/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './spec';
+export * from './theme';

package/build/es5/component/tooltip/interface/spec.d.ts

@@ -0,0 +1,28 @@
+import type { ITooltipPattern, Maybe, TooltipActiveType, TooltipData } from '../../../typings';
+import type { ITooltipActiveTypeAsKeys, TooltipHandlerParams, TooltipResult } from './common';
+import type { ITooltipTheme } from './theme';
+export interface ITooltipSpec extends Partial<ITooltipActiveTypeAsKeys<ITooltipPattern, ITooltipPattern>> {
+    visible?: boolean;
+    activeType?: TooltipActiveType | TooltipActiveType[];
+    trigger?: 'hover' | 'click' | 'none';
+    triggerOff?: 'hover' | 'click' | 'none';
+    style?: Omit<ITooltipTheme, 'offset'>;
+    handler?: Partial<ITooltipHandlerSpec>;
+    renderMode?: 'html' | 'canvas';
+    confine?: boolean;
+    className?: string;
+    parentElement?: Maybe<string | HTMLElement | HTMLCanvasElement>;
+    enterable?: boolean;
+    transitionDuration?: number;
+    throttleInterval?: number;
+    offset?: {
+        x?: number;
+        y?: number;
+    };
+}
+export interface ITooltipHandlerSpec {
+    showTooltip: (activeType: TooltipActiveType, tooltipData: TooltipData, params: TooltipHandlerParams) => Maybe<TooltipResult>;
+    hideTooltip: (params: TooltipHandlerParams) => Maybe<TooltipResult>;
+    release: () => void;
+    isTooltipShown?: () => boolean;
+}

package/build/es5/component/tooltip/interface/theme.d.ts

@@ -0,0 +1,45 @@
+import type { RichTextWordBreak } from '@visactor/vrender';
+import type { IPadding, StringOrNumber, TextAlign, TextBaseLine } from '../../../typings';
+export interface ITooltipTextTheme {
+    fontFamily?: string;
+    fontSize?: number;
+    fontColor?: string;
+    fontWeight?: StringOrNumber;
+    textAlign?: TextAlign;
+    textBaseline?: TextBaseLine;
+    lineHeight?: number;
+    spacing?: number;
+    multiLine?: boolean;
+    maxWidth?: number;
+    wordBreak?: RichTextWordBreak;
+}
+export interface ITooltipTheme {
+    panel?: {
+        padding?: IPadding;
+        backgroundColor?: string;
+        border?: {
+            color?: string;
+            width?: number;
+            radius?: number;
+        };
+        shadow?: {
+            x: number;
+            y: number;
+            blur: number;
+            spread: number;
+            color: string;
+        };
+    };
+    shape?: {
+        size?: number;
+        spacing?: number;
+    };
+    titleLabel?: ITooltipTextTheme;
+    keyLabel?: ITooltipTextTheme;
+    valueLabel?: ITooltipTextTheme;
+    spaceRow?: number;
+    offset?: {
+        x?: number;
+        y?: number;
+    };
+}

package/build/es5/component/tooltip/processor/base.d.ts

@@ -0,0 +1,18 @@
+import type { BaseEventParams } from '../../../event/interface';
+import type { TooltipActiveType, TooltipData } from '../../../typings';
+import type { TooltipHandlerParams } from '../interface';
+import { TooltipResult } from '../interface';
+import type { Tooltip } from '../tooltip';
+import type { MouseEventData, TooltipInfo } from './interface';
+import type { IDimensionInfo } from '../../../event/events/dimension';
+export declare abstract class BaseTooltipProcessor {
+    readonly component: Tooltip;
+    activeType: TooltipActiveType;
+    constructor(component: Tooltip);
+    abstract showTooltip(info: TooltipInfo, params: BaseEventParams, changePositionOnly: boolean): TooltipResult;
+    abstract shouldHandleTooltip(params: BaseEventParams, mouseEventData: Partial<MouseEventData>): boolean;
+    abstract getMouseEventData(params: BaseEventParams): MouseEventData;
+    protected _showTooltipByHandler: (data: TooltipData | undefined, params: TooltipHandlerParams) => TooltipResult;
+    protected _preprocessDimensionInfo(dimensionInfo?: IDimensionInfo[]): IDimensionInfo[] | undefined;
+    protected _getDimensionInfo(params: BaseEventParams): IDimensionInfo[];
+}

package/build/es5/component/tooltip/processor/dimension-tooltip.d.ts

@@ -0,0 +1,10 @@
+import type { BaseEventParams } from '../../../event/interface';
+import type { TooltipActiveType } from '../../../typings';
+import type { DimensionTooltipInfo, MouseEventData } from './interface';
+import { BaseTooltipProcessor } from './base';
+export declare class DimensionTooltipProcessor extends BaseTooltipProcessor {
+    activeType: TooltipActiveType;
+    showTooltip(info: DimensionTooltipInfo, params: BaseEventParams, changePositionOnly: boolean): import("../interface").TooltipResult;
+    shouldHandleTooltip(params: BaseEventParams, mouseEventData: Partial<MouseEventData>): boolean;
+    getMouseEventData(params: BaseEventParams): MouseEventData;
+}

package/build/es5/component/tooltip/processor/index.d.ts

@@ -0,0 +1,5 @@
+export * from './base';
+export * from './dimension-tooltip';
+export * from './mark-tooltip';
+export * from './interface';
+export * from './util';

package/build/es5/component/tooltip/processor/interface.d.ts

@@ -0,0 +1,16 @@
+import type { Datum } from '@visactor/vgrammar';
+import type { IMark } from '../../../mark/interface';
+import type { ISeries } from '../../../series/interface';
+import type { IDimensionInfo } from '../../../event/events/dimension/interface';
+export type DimensionTooltipInfo = IDimensionInfo[];
+export type MarkTooltipInfo = {
+    datum: Datum;
+    mark: IMark;
+    series: ISeries;
+    dimensionInfo: DimensionTooltipInfo;
+};
+export type TooltipInfo = DimensionTooltipInfo | MarkTooltipInfo;
+export type MouseEventData = {
+    tooltipInfo: TooltipInfo;
+    ignore: boolean;
+};

package/build/es5/component/tooltip/processor/mark-tooltip.d.ts

@@ -0,0 +1,10 @@
+import type { BaseEventParams } from '../../../event/interface';
+import type { TooltipActiveType } from '../../../typings';
+import type { MarkTooltipInfo, MouseEventData } from './interface';
+import { BaseTooltipProcessor } from './base';
+export declare class MarkTooltipProcessor extends BaseTooltipProcessor {
+    activeType: TooltipActiveType;
+    showTooltip(info: MarkTooltipInfo, params: BaseEventParams, changePositionOnly: boolean): import("../interface").TooltipResult;
+    shouldHandleTooltip(params: BaseEventParams, mouseEventData: Partial<MouseEventData>): boolean;
+    getMouseEventData(params: BaseEventParams): MouseEventData;
+}

package/build/es5/component/tooltip/processor/util.d.ts

@@ -0,0 +1,4 @@
+import type { Maybe } from '@visactor/vutils';
+import type { DimensionTooltipInfo, MarkTooltipInfo, TooltipInfo } from './interface';
+export declare const isMarkInfo: (info: Maybe<TooltipInfo>) => info is MarkTooltipInfo;
+export declare const isDimensionInfo: (info: Maybe<TooltipInfo>) => info is DimensionTooltipInfo;

package/build/es5/component/tooltip/tooltip.d.ts

@@ -0,0 +1,57 @@
+import type { IComponentOption } from '../interface';
+import { ComponentTypeEnum } from '../interface';
+import type { IModelLayoutOption, IModelRenderOption, ILayoutItem } from '../../model/interface';
+import type { IRegion } from '../../region/interface';
+import { BaseComponent } from '../base';
+import type { BaseEventParams, EventCallback, EventQuery, EventType } from '../../event/interface';
+import type { ITooltipHandler, IToolTipLineActual, TooltipActiveType } from '../../typings/tooltip';
+import type { Datum, IShowTooltipOption } from '../../typings';
+import { TooltipResult, type ITooltip, type ITooltipActiveTypeAsKeys, type ITooltipSpec, type ITooltipTheme, type TooltipHandlerParams, type TotalMouseEventData } from './interface';
+import { MarkTooltipProcessor, DimensionTooltipProcessor } from './processor';
+export type TooltipContent = {
+    title?: IToolTipLineActual;
+    content?: IToolTipLineActual[];
+};
+export declare class Tooltip extends BaseComponent implements ITooltip {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    layoutType: ILayoutItem['layoutType'];
+    static createComponent(spec: any, options: IComponentOption): Tooltip | Tooltip[];
+    tooltipHandler?: ITooltipHandler;
+    private _alwaysShow;
+    private _cacheInfo;
+    private _eventList;
+    protected _spec: ITooltipSpec;
+    protected _theme: ITooltipTheme;
+    protected _processor: ITooltipActiveTypeAsKeys<MarkTooltipProcessor, DimensionTooltipProcessor>;
+    protected _isTooltipShown: boolean;
+    isTooltipShown(): boolean;
+    changeRegions(regions: IRegion[]): void;
+    protected _registerEvent(): void;
+    protected _releaseEvent(): void;
+    onLayout(ctx: IModelLayoutOption): void;
+    onLayoutEnd(ctx: IModelLayoutOption): void;
+    onRender(ctx: IModelRenderOption): void;
+    created(): void;
+    release(): void;
+    protected _initHandler(): void;
+    protected _initProcessor(): void;
+    protected _initEvent(): void;
+    protected _mountEvent: (eType: EventType, query: EventQuery, callback: EventCallback<any>) => void;
+    protected _handleMouseOut: (params: BaseEventParams) => void;
+    protected _handleChartMouseOut: (params: BaseEventParams) => void;
+    protected _handleMouseMove: (params: BaseEventParams) => void;
+    protected _showTooltipByMouseEvent: (activeType: TooltipActiveType, mouseEventData: TotalMouseEventData, params: BaseEventParams, useCache?: boolean) => boolean;
+    protected _getMouseEventData: (params: BaseEventParams) => TotalMouseEventData;
+    protected _hideTooltipByHandler: (params: TooltipHandlerParams) => TooltipResult;
+    protected _initTheme(theme?: any): void;
+    reInit(theme?: any): void;
+    setAttrFromSpec(): void;
+    showTooltip(datum: Datum, options: IShowTooltipOption): false | "none" | TooltipActiveType;
+    hideTooltip(): boolean;
+    private _isSameAsCacheInfo;
+    private _isPointerInChart;
+    private _isPointerOnTooltip;
+    getVisible(): boolean;
+}

package/build/es5/component/tooltip/utils/common.d.ts

@@ -0,0 +1,5 @@
+import type { TooltipActiveType } from '../../../typings';
+import type { ITooltipSpec } from '../interface';
+import type { BaseEventParams } from '../../../event/interface';
+export declare const getTooltipActualActiveType: (spec?: ITooltipSpec) => TooltipActiveType[];
+export declare function isEmptyPos(params: BaseEventParams): boolean;

package/build/es5/component/tooltip/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './show-tooltip';
+export * from './common';

package/build/es5/component/tooltip/utils/show-tooltip.d.ts

@@ -0,0 +1,3 @@
+import type { Datum, IShowTooltipOption, ITooltipHandler, TooltipActiveType } from '../../../typings';
+import type { IComponentOption } from '../../interface';
+export declare function showTooltip(datum: Datum, options: IShowTooltipOption, tooltipHandler: ITooltipHandler, componentOptions: IComponentOption): TooltipActiveType | 'none';

package/build/es5/constant/base.d.ts

@@ -0,0 +1,3 @@
+export declare const PREFIX = "__VCHART";
+export declare const DEFAULT_CHART_WIDTH = 500;
+export declare const DEFAULT_CHART_HEIGHT = 500;

package/build/es5/constant/box-plot.d.ts

@@ -0,0 +1,10 @@
+export declare const BOX_PLOT_OUTLIER_VALUE_FIELD: string;
+export declare enum BOX_PLOT_TOOLTIP_KEYS {
+    OUTLIER = "outlier",
+    MAX = "max",
+    MIN = "min",
+    MEDIAN = "median",
+    Q1 = "q1",
+    Q3 = "q3",
+    SERIES_FIELD = "seriesField"
+}

package/build/es5/constant/event.d.ts

@@ -0,0 +1,53 @@
+export { HOOK_EVENT as VGRAMMAR_HOOK_EVENT } from '@visactor/vgrammar';
+export declare const BASE_EVENTS: string[];
+export declare enum ChartEvent {
+    initialized = "initialized",
+    rendered = "rendered",
+    renderFinished = "renderFinished",
+    animationFinished = "animationFinished",
+    regionSeriesDataFilterOver = "regionSeriesDataFilterOver",
+    afterInitData = "afterInitData",
+    afterInitEvent = "afterInitEvent",
+    afterInitMark = "afterInitMark",
+    rawDataUpdate = "rawDataUpdate",
+    rawDataStatisticsUpdate = "rawDataStatisticsUpdate",
+    viewDataFilterOver = "viewDataFilterOver",
+    viewDataUpdate = "viewDataUpdate",
+    viewDataStatisticsUpdate = "viewDataStatisticsUpdate",
+    markDeltaYUpdate = "markDeltaYUpdate",
+    viewDataLabelUpdate = "viewDataLabelUpdate",
+    scaleDomainUpdate = "scaleDomainUpdate",
+    scaleUpdate = "scaleUpdate",
+    dataZoomChange = "dataZoomChange",
+    drill = "drill",
+    layoutStart = "layoutStart",
+    layoutEnd = "layoutEnd",
+    playerPlay = "playerPlay",
+    playerPause = "playerPause",
+    playerEnd = "playerEnd",
+    playerChange = "playerChange",
+    playerForward = "playerForward",
+    playerBackward = "playerBackward",
+    scrollBarChange = "scrollBarChange",
+    brushStart = "brushStart",
+    brushChange = "brushChange",
+    brushEnd = "brushEnd",
+    legendSelectedDataChange = "legendSelectedDataChange",
+    legendFilter = "legendFilter",
+    legendItemClick = "legendItemClick",
+    legendItemHover = "legendItemHover",
+    legendItemUnHover = "legendItemUnHover",
+    tooltipShow = "tooltipShow",
+    tooltipHide = "tooltipHide",
+    tooltipRelease = "tooltipRelease"
+}
+export declare enum Event_Source_Type {
+    chart = "chart",
+    window = "window"
+}
+export declare enum Event_Bubble_Level {
+    vchart = "vchart",
+    chart = "chart",
+    model = "model",
+    mark = "mark"
+}

package/build/es5/constant/funnel.d.ts

@@ -0,0 +1,14 @@
+export declare const FUNNEL_TRANSFORM_RATIO: string;
+export declare const FUNNEL_REACH_RATIO: string;
+export declare const FUNNEL_HEIGHT_RATIO: string;
+export declare const FUNNEL_VALUE_RATIO: string;
+export declare const FUNNEL_LAST_VALUE_RATIO: string;
+export declare const FUNNEL_NEXT_VALUE_RATIO: string;
+export declare const FUNNEL_LAST_VALUE: string;
+export declare const FUNNEL_CURRENT_VALUE: string;
+export declare const FUNNEL_NEXT_VALUE: string;
+export declare const FUNNEL_TRANSFORM_LEVEL: string;
+export declare const FUNNEL_LABEL_LINE_LENGTH = 20;
+export declare const FUNNEL_LABEL_SPACE_WIDTH = 5;
+export declare const FUNNEL_MAX_SIZE = "80%";
+export declare const FUNNEL_MIN_SIZE = 0;

package/build/es5/constant/hierarchy.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_HIERARCHY_DEPTH: string;
+export declare const DEFAULT_HIERARCHY_ROOT: string;
+export declare const DEFAULT_HIERARCHY_ROOT_INDEX: string;

package/build/es5/constant/index.d.ts

@@ -0,0 +1,106 @@
+export declare const DEFAULT_MEASURE_CANVAS_ID: string;
+export declare const DEFAULT_DATA_INDEX: string;
+export declare const DEFAULT_DATA_KEY: string;
+export declare const DEFAULT_DATA_SERIES_FIELD: string;
+export declare const DEFAULT_SERIES_STYLE_NAME: string;
+export declare enum AttributeLevel {
+    Default = 0,
+    Theme = 1,
+    Chart = 2,
+    Base_Series = 3,
+    Series = 4,
+    Mark = 5,
+    User_Chart = 6,
+    User_Series = 7,
+    User_Mark = 8,
+    Built_In = 99
+}
+export declare const STACK_FIELD_START: string;
+export declare const STACK_FIELD_END: string;
+export declare const STACK_FIELD_START_PERCENT: string;
+export declare const STACK_FIELD_END_PERCENT: string;
+export declare const STACK_FIELD_START_OffsetSilhouette: string;
+export declare const STACK_FIELD_END_OffsetSilhouette: string;
+export declare const SEGMENT_FIELD_START: string;
+export declare const SEGMENT_FIELD_END: string;
+export declare enum LayoutZIndex {
+    Axis_Grid = 100,
+    CrossHair_Grid = 100,
+    Region = 450,
+    Mark = 300,
+    Node = 400,
+    Axis = 100,
+    MarkLine = 500,
+    MarkArea = 100,
+    MarkPoint = 500,
+    DataZoom = 500,
+    ScrollBar = 500,
+    Player = 500,
+    Legend = 500,
+    CrossHair = 500,
+    Indicator = 500,
+    Title = 500,
+    Label = 500,
+    Brush = 500,
+    CustomMark = 500
+}
+export declare enum LayoutLevel {
+    Indicator = 10,
+    Region = 20,
+    Axis = 30,
+    DataZoom = 40,
+    Player = 40,
+    ScrollBar = 40,
+    Legend = 50,
+    Title = 70,
+    CustomMark = 70
+}
+export declare const GradientType: string[];
+export declare const DEFAULT_LINEAR_GRADIENT_CONFIG: {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+export declare const DEFAULT_RADIAL_GRADIENT_CONFIG: {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    r0: number;
+    r1: number;
+};
+export declare const DEFAULT_CONICAL_GRADIENT_CONFIG: {
+    x: number;
+    y: number;
+    startAngle: number;
+    endAngle: number;
+};
+export declare const DEFAULT_GRADIENT_CONFIG: {
+    linear: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
+    radial: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+        r0: number;
+        r1: number;
+    };
+    conical: {
+        x: number;
+        y: number;
+        startAngle: number;
+        endAngle: number;
+    };
+};
+export * from './base';
+export * from './label';
+export * from './polar';
+export * from './layout';
+export * from './event';
+export * from './waterfall';

package/build/es5/constant/label.d.ts

@@ -0,0 +1,6 @@
+export declare const DEFAULT_LABEL_LIMIT: string;
+export declare const DEFAULT_LABEL_ALIGN: string;
+export declare const DEFAULT_LABEL_TEXT: string;
+export declare const DEFAULT_LABEL_VISIBLE: string;
+export declare const DEFAULT_LABEL_X: string;
+export declare const DEFAULT_LABEL_Y: string;

package/build/es5/constant/layout.d.ts

@@ -0,0 +1,2 @@
+export declare const USER_LAYOUT_RECT_LEVEL = 9;
+export declare const DEFAULT_LAYOUT_RECT_LEVEL = 0;

package/build/es5/constant/marker.d.ts

@@ -0,0 +1,4 @@
+import type { IAggrType } from '../component/marker/interface';
+import type { IRegressType } from '../component/marker/mark-area/interface';
+export declare const AGGR_TYPE: IAggrType[];
+export declare const REGRESS_TYPE: IRegressType[];