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

package/build/es5/compile/signal/compilable-signal.d.ts

@@ -0,0 +1,21 @@
+import type { ISignal, SignalFunctionType } from '@visactor/vgrammar';
+import { GrammarItem } from '../grammar-item';
+import type { Maybe } from '../../typings';
+import type { GrammarItemInitOption } from '../interface';
+import { GrammarType } from '../interface';
+import type { ICompilableSignal } from './interface';
+export declare class CompilableSignal<T> extends GrammarItem implements ICompilableSignal<T> {
+    readonly grammarType = GrammarType.signal;
+    protected _product: Maybe<ISignal<T>>;
+    getProduct: () => Maybe<ISignal<T>>;
+    readonly name: string;
+    protected _value: Maybe<T>;
+    getValue(): T;
+    protected _updateFunc: Maybe<SignalFunctionType<T>>;
+    getUpdateFunc(): SignalFunctionType<T>;
+    constructor(option: GrammarItemInitOption, name: string, value?: T, updateFunc?: SignalFunctionType<T>);
+    updateSignal(value?: T, updateFunc?: SignalFunctionType<T>): void;
+    protected _compileProduct(): void;
+    generateProductId(): string;
+    protected _lookupGrammar(id: string): ISignal<unknown>;
+}

package/build/es5/compile/signal/index.d.ts

@@ -0,0 +1,4 @@
+export * from './compilable-signal';
+export * from './interface';
+export * from './signal-manager';
+export * from './state-manager';

package/build/es5/compile/signal/interface.d.ts

@@ -0,0 +1,12 @@
+import type { SignalFunctionType } from '@visactor/vgrammar';
+import type { Maybe } from '../../typings';
+import type { IGrammarItem, ICompilableInitOption } from '../interface';
+export interface IStateManagerOption extends ICompilableInitOption {
+    stateKeyToSignalName?: (key: string) => string;
+}
+export type StateValueMap = Record<string, unknown>;
+export interface ICompilableSignal<T> extends IGrammarItem {
+    updateSignal: (value?: T, updateFunc?: SignalFunctionType<T>) => void;
+    getValue: () => Maybe<T>;
+    getUpdateFunc: () => Maybe<SignalFunctionType<T>>;
+}

package/build/es5/compile/signal/signal-manager.d.ts

@@ -0,0 +1,11 @@
+import type { SignalFunctionType } from '@visactor/vgrammar';
+import { CompilableSignal } from './compilable-signal';
+import { CompilableBase } from '../compilable-base';
+export declare class SignalManager extends CompilableBase {
+    protected _signalMap: Record<string, CompilableSignal<any>>;
+    getSignalMap(): Record<string, CompilableSignal<any>>;
+    getSignal(name: string): CompilableSignal<any>;
+    updateSignal(name: string, value: any, updateFunc?: SignalFunctionType<any>): void;
+    compile(): void;
+    release(): void;
+}

package/build/es5/compile/signal/state-manager.d.ts

@@ -0,0 +1,12 @@
+import type { IStateManagerOption, StateValueMap } from './interface';
+import { SignalManager } from './signal-manager';
+export declare class StateManager extends SignalManager {
+    protected _stateMap: StateValueMap;
+    getStateMap(): StateValueMap;
+    protected _getDefaultStateMap(): StateValueMap;
+    protected stateKeyToSignalName: (key: string) => string;
+    constructor(option: IStateManagerOption);
+    initStateMap(state?: StateValueMap): void;
+    compile(stateMap?: StateValueMap): void;
+    updateState(newState: Partial<StateValueMap>, noRender?: boolean): Promise<void>;
+}

package/build/es5/compile/util.d.ts

@@ -0,0 +1,2 @@
+import type { RenderMode } from '../typings/spec';
+export declare function toRenderMode(mode: RenderMode): any;

package/build/es5/component/axis/base-axis.d.ts

@@ -0,0 +1,155 @@
+import type { IBaseScale } from '@visactor/vscale';
+import type { IGroup } from '@visactor/vrender';
+import type { IOrientType, IPolarOrientType, StringOrNumber } from '../../typings';
+import { BaseComponent } from '../base';
+import type { IPolarAxisCommonTheme } from './polar/interface';
+import type { ICartesianAxisCommonTheme } from './cartesian/interface';
+import type { CompilableData } from '../../compile/data';
+import type { IAxis, ITick, StatisticsDomain } from './interface';
+import type { IComponentOption } from '../interface';
+import type { ISeries } from '../../series/interface';
+import type { ITransformOptions } from '@visactor/vdataset';
+export declare abstract class AxisComponent extends BaseComponent implements IAxis {
+    static specKey: string;
+    protected _orient: IPolarOrientType | IOrientType;
+    get orient(): IOrientType | IPolarOrientType;
+    protected _scale: IBaseScale;
+    getScale(): IBaseScale;
+    protected _scales: IBaseScale[];
+    getScales(): IBaseScale[];
+    protected _theme: ICartesianAxisCommonTheme | IPolarAxisCommonTheme;
+    protected _tickData: CompilableData;
+    getTickData(): CompilableData;
+    protected _statisticsDomain: StatisticsDomain;
+    getStatisticsDomain(): StatisticsDomain;
+    protected _seriesUserId?: StringOrNumber[];
+    protected _seriesIndex?: number[];
+    protected _regionUserId?: StringOrNumber[];
+    protected _regionIndex?: number[];
+    protected _visible: boolean;
+    get visible(): boolean;
+    protected _tick: ITick | undefined;
+    protected abstract computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    abstract dataToPosition(values: any[], cfg?: any): number;
+    abstract valueToPosition(value: any): number;
+    protected abstract axisHelper(): any;
+    protected abstract getSeriesStatisticsField(s: ISeries): string[];
+    protected abstract updateSeriesScale(): void;
+    protected abstract collectData(depth: number): {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    protected abstract _initData(): void;
+    abstract transformScaleDomain(): void;
+    protected _dataFieldText: string;
+    constructor(spec: any, options: IComponentOption);
+    created(): void;
+    protected isSeriesDataEnable(): boolean;
+    protected setSeriesAndRegionsFromSpec(): void;
+    getBindSeriesFilter(): {
+        userId: StringOrNumber[];
+        specIndex: number[];
+    };
+    protected computeStatisticsDomain: () => void;
+    protected initEvent(): void;
+    protected updateScaleDomain(): void;
+    protected computeData(): void;
+    protected initScales(): void;
+    updateSpec(spec: any): {
+        change: boolean;
+        reMake: boolean;
+        reRender: boolean;
+        reSize: boolean;
+        reCompile: boolean;
+    };
+    protected getLabelFormatMethod(): (value: any, datum: any, index: number) => any;
+    protected getLabelItems(length: number): any[];
+    protected _delegateAxisContainerEvent(component: IGroup): void;
+    protected _getAxisAttributes(): {
+        orient: IOrientType | IPolarOrientType;
+        select: any;
+        hover: any;
+        line: any;
+        label: {
+            visible: any;
+            space: any;
+            inside: any;
+            style: any;
+            formatMethod: (value: any, datum: any, index: number) => any;
+            state: {};
+            autoRotate: boolean;
+            autoHide: boolean;
+            autoLimit: boolean;
+            autoRotateAngle: any;
+            autoHideMethod: any;
+            autoHideSeparation: any;
+            limitEllipsis: any;
+            layoutFunc: any;
+            dataFilter: any;
+        };
+        tick: {
+            visible: any;
+            length: any;
+            inside: any;
+            alignWithLabel: any;
+            style: any;
+            state: {};
+            dataFilter: any;
+        };
+        subTick: {
+            visible: any;
+            length: any;
+            inside: any;
+            count: any;
+            style: any;
+            state: {};
+        };
+        grid: {
+            type: string;
+            visible: any;
+            alternateColor: any;
+            alignWithLabel: any;
+            style: any;
+        };
+        subGrid: {
+            type: string;
+            visible: any;
+            alternateColor: any;
+            style: any;
+        };
+        title: {
+            visible: any;
+            position: any;
+            space: any;
+            autoRotate: boolean;
+            angle: number;
+            textStyle: any;
+            padding: any;
+            shape: {
+                visible: any;
+                space: any;
+                style: any;
+            };
+            background: {
+                visible: any;
+                style: any;
+            };
+            state: {
+                text: {};
+                shape: {};
+                background: {};
+            };
+        };
+        panel: {
+            visible: any;
+            style: any;
+            state: {};
+        };
+    };
+    addTransformToTickData(options: ITransformOptions, execute?: boolean): void;
+}

package/build/es5/component/axis/cartesian/axis.d.ts

@@ -0,0 +1,96 @@
+import type { IBoundsLike } from '@visactor/vutils';
+import type { IEffect, IModelInitOption, ILayoutRect } from '../../../model/interface';
+import type { ICartesianSeries } from '../../../series/interface';
+import type { IRegion } from '../../../region/interface';
+import type { IAxisLocationCfg, ICartesianAxisCommonSpec, IAxisHelper, ICartesianAxisCommonTheme } from './interface';
+import type { IOrientType } from '../../../typings/space';
+import type { IBaseScale } from '@visactor/vscale';
+import type { LayoutItem } from '../../../model/layout-item';
+import type { IPoint, StringOrNumber } from '../../../typings';
+import type { IComponentOption } from '../../interface';
+import { ComponentTypeEnum } from '../../interface';
+import type { IAxis, ITick } from '../interface';
+import type { DataSet } from '@visactor/vdataset';
+import { AxisComponent } from '../base-axis';
+export declare abstract class CartesianAxis extends AxisComponent implements IAxis {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    name: string;
+    directionStr?: 'l2r' | 'r2l' | 't2b' | 'b2t';
+    layoutType: LayoutItem['layoutType'];
+    layoutZIndex: number;
+    layoutLevel: number;
+    protected _dataSet: DataSet;
+    layout3dBox?: {
+        width: number;
+        height: number;
+        length: number;
+    };
+    protected _orient: IOrientType;
+    get orient(): IOrientType;
+    get layoutOrient(): IOrientType;
+    set layoutOrient(v: IOrientType);
+    protected _scales: IBaseScale[];
+    getScales(): IBaseScale[];
+    protected _theme: ICartesianAxisCommonTheme;
+    protected _statisticsDomain: {
+        domain: any[];
+        index: {
+            [key in StringOrNumber]: number;
+        };
+    };
+    getStatisticsDomain(): {
+        domain: any[];
+        index: {
+            [x: string]: number;
+            [x: number]: number;
+        };
+    };
+    protected _tick: ITick | undefined;
+    private _axisStyle;
+    private _latestBounds;
+    private _verticalLimitSize;
+    constructor(spec: ICartesianAxisCommonSpec, options: IComponentOption);
+    static createAxis(spec: any, options: IComponentOption, isHorizontal?: boolean): IAxis;
+    static createComponent(spec: any, options: IComponentOption): IAxis | IAxis[];
+    setLayout3dBox(box3d: {
+        width: number;
+        height: number;
+        length: number;
+    }): void;
+    effect: IEffect;
+    protected abstract computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    abstract dataToPosition(values: any[], cfg?: IAxisLocationCfg): number;
+    abstract valueToPosition(value: any): number;
+    protected updateScaleRange(): boolean;
+    init(option: IModelInitOption): void;
+    setAttrFromSpec(): void;
+    protected getSeriesStatisticsField(s: ICartesianSeries): string[];
+    protected _initData(): void;
+    protected axisHelper(): IAxisHelper;
+    afterCompile(): void;
+    onLayoutEnd(ctx: any): void;
+    onRender(ctx: any): void;
+    changeRegions(regions: IRegion[]): void;
+    update(ctx: IComponentOption): void;
+    resize(ctx: IComponentOption): void;
+    protected collectScale(): IBaseScale[];
+    protected collectData(depth?: number): {
+        min: number;
+        max: number;
+        values: any[];
+    }[];
+    protected updateSeriesScale(): void;
+    setLayoutStartPosition(pos: Partial<IPoint>): void;
+    computeBoundsInRect(rect: ILayoutRect): ILayoutRect;
+    boundsInRect(rect: ILayoutRect): IBoundsLike;
+    updateLayoutAttribute(): void;
+    private _getTitleLimit;
+    private _getUpdateAttribute;
+    protected initEvent(): void;
+    private _fixAxisOnZero;
+}

package/build/es5/component/axis/cartesian/band-axis.d.ts

@@ -0,0 +1,39 @@
+import { BandScale } from '@visactor/vscale';
+import { CartesianAxis } from './axis';
+import type { IAxisLocationCfg, ICartesianBandAxisSpec } from './interface';
+import { ComponentTypeEnum } from '../../interface';
+import { BandAxisMixin } from '../mixin/band-axis-mixin';
+import type { StringOrNumber } from '../../../typings';
+export interface CartesianBandAxis extends Pick<BandAxisMixin, 'valueToPosition' | 'updateGroupScaleRange' | 'getPosition' | 'calcScales' | 'computeBandDomain'>, CartesianAxis {
+}
+export declare class CartesianBandAxis extends CartesianAxis {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _scale: BandScale;
+    protected _scales: BandScale[];
+    protected _spec: ICartesianBandAxisSpec;
+    protected computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): StringOrNumber[];
+    protected updateScaleRange(): boolean;
+    protected initScales(): void;
+    protected axisHelper(): {
+        dataToPosition: (values: any[], cfg?: IAxisLocationCfg) => number;
+        getScale: (depth: number) => BandScale;
+        getBandwidth: (depth: number) => number;
+        getStatisticsDomain: () => {
+            domain: any[];
+            index: {
+                [x: string]: number;
+                [x: number]: number;
+            };
+        };
+        getAxisType: () => ComponentTypeEnum;
+        getAxisId: () => number;
+        isInverse: () => boolean;
+    };
+    dataToPosition(values: any[], cfg?: IAxisLocationCfg): number;
+    transformScaleDomain(): void;
+}

package/build/es5/component/axis/cartesian/config.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_BAND_INNER_PADDING = 0.1;
+export declare const DEFAULT_BAND_OUTER_PADDING = 0.3;

package/build/es5/component/axis/cartesian/index.d.ts

@@ -0,0 +1,6 @@
+export * from './axis';
+export * from './linear-axis';
+export * from './band-axis';
+export * from './time-axis';
+export * from './log-axis';
+export * from './interface';

package/build/es5/component/axis/cartesian/interface/common.d.ts

@@ -0,0 +1,50 @@
+import type { SegmentAttributes, AxisLabelOverlap } from '@visactor/vrender-components';
+import type { IBaseScale } from '@visactor/vscale';
+import type { IAxis, IDomainLine, ILabel, ITitle } from '../../interface';
+import type { StringOrNumber } from '../../../../typings';
+export type ICartesianDomainLineSpec = {
+    startSymbol?: SegmentAttributes['startSymbol'];
+    endSymbol?: SegmentAttributes['endSymbol'];
+    onZero?: boolean;
+    onZeroAxisIndex?: number;
+    onZeroAxisId?: StringOrNumber;
+};
+export type ICartesianDomainLine = IDomainLine & ICartesianDomainLineSpec;
+export type ICartesianTitle = ITitle & {
+    autoRotate?: boolean;
+    inside?: boolean;
+};
+export type ICartesianLabel = ILabel & {
+    flush?: boolean;
+    lastVisible?: boolean | null;
+} & AxisLabelOverlap;
+export interface ILinearAxis extends IAxis {
+    readonly zero: boolean;
+    readonly nice: boolean;
+    setExtendDomain: (key: string, value: number | undefined) => void;
+}
+export interface IAxisHelper {
+    dataToPosition: (values: any[], cfg?: IAxisLocationCfg) => number;
+    getScale?: (depth: number) => IBaseScale;
+    getBandwidth?: (depth: number) => number;
+    setExtendDomain?: (key: string, value: number | undefined) => void;
+    getStatisticsDomain?: () => {
+        domain: any[];
+        index: {
+            [key in StringOrNumber]: number;
+        };
+    };
+    getAxisType: () => string;
+    getAxisId: () => number;
+    isInverse: () => boolean;
+}
+export interface IAxisLocationCfg {
+    bandPosition?: number;
+}
+export interface ITimeLayerType {
+    tickStep?: number;
+    timeFormat?: string;
+    timeFormatMode?: 'utc' | 'local';
+    tickCount?: number;
+    forceTickCount?: number;
+}

package/build/es5/component/axis/cartesian/interface/index.d.ts

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

package/build/es5/component/axis/cartesian/interface/spec.d.ts

@@ -0,0 +1,36 @@
+import type { IOrientType, IRectMarkSpec, StringOrNumber } from '../../../../typings';
+import type { IBandAxisSpec, ILinearAxisSpec, IGrid, ICommonAxisSpec } from '../../interface';
+import type { ICartesianDomainLine, ICartesianLabel, ITimeLayerType, ICartesianTitle } from './common';
+import type { AxisItemStateStyle } from '@visactor/vrender-components';
+export type ICartesianAxisSpec = ICartesianLinearAxisSpec | ICartesianBandAxisSpec | ICartesianTimeAxisSpec | ICartesianLogAxisSpec;
+export type ICartesianAxisCommonSpec = ICommonAxisSpec & {
+    orient: IOrientType;
+    grid?: IGrid;
+    subGrid?: IGrid;
+    domainLine?: ICartesianDomainLine;
+    label?: ICartesianLabel;
+    title?: ICartesianTitle;
+    autoIndent?: boolean;
+    background?: {
+        visible: boolean;
+        style?: Partial<IRectMarkSpec>;
+        state?: AxisItemStateStyle<Partial<IRectMarkSpec>>;
+    };
+    mode?: '2d' | '3d';
+    depth?: number;
+};
+export interface ILinearAxisSync {
+    axisId: StringOrNumber;
+    zeroAlign?: boolean;
+    tickAlign?: boolean;
+}
+export type ICartesianLinearAxisSpec = ICartesianAxisCommonSpec & ILinearAxisSpec & {
+    sync?: ILinearAxisSync;
+};
+export type ICartesianBandAxisSpec = ICartesianAxisCommonSpec & IBandAxisSpec;
+export type ICartesianTimeAxisSpec = Omit<ICartesianAxisCommonSpec, 'inverse'> & {
+    layers?: ITimeLayerType[];
+};
+export type ICartesianLogAxisSpec = ICartesianLinearAxisSpec & {
+    base?: number;
+};

package/build/es5/component/axis/cartesian/interface/theme.d.ts

@@ -0,0 +1,21 @@
+import type { ILayoutPaddingSpec, ILayoutNumber } from '../../../../model/interface';
+import type { ITick, ILabel, IGrid } from '../../interface';
+import type { ICartesianDomainLine, ICartesianTitle } from './common';
+import type { ICartesianAxisCommonSpec } from './spec';
+export interface ICartesianAxisCommonTheme {
+    grid?: IGrid;
+    subGrid?: IGrid;
+    domainLine?: ICartesianDomainLine;
+    label?: ILabel;
+    title?: ICartesianTitle;
+    tick?: ITick;
+    subTick?: ITick;
+    background?: ICartesianAxisCommonSpec['background'];
+    padding?: ILayoutPaddingSpec;
+    width?: ILayoutNumber;
+    maxWidth?: ILayoutNumber;
+    minWidth?: ILayoutNumber;
+    height?: ILayoutNumber;
+    maxHeight?: ILayoutNumber;
+    minHeight?: ILayoutNumber;
+}

package/build/es5/component/axis/cartesian/linear-axis.d.ts

@@ -0,0 +1,27 @@
+import type { LogScale } from '@visactor/vscale';
+import { LinearScale } from '@visactor/vscale';
+import { CartesianAxis } from './axis';
+import type { IAxisHelper } from './interface';
+import { ComponentTypeEnum } from '../../interface';
+import { LinearAxisMixin } from '../mixin/linear-axis-mixin';
+export interface CartesianLinearAxis extends Pick<LinearAxisMixin, 'setExtraAttrFromSpec' | 'computeLinearDomain' | 'valueToPosition' | 'setScaleNice' | '_domain' | 'dataToPosition' | 'transformScaleDomain' | 'setExtendDomain'>, CartesianAxis {
+}
+export declare class CartesianLinearAxis extends CartesianAxis {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _zero: boolean;
+    protected _nice: boolean;
+    protected _extend: {
+        [key: string]: number;
+    };
+    protected _scale: LinearScale | LogScale;
+    protected _scales: LinearScale[] | LogScale[];
+    setAttrFromSpec(): void;
+    protected initScales(): void;
+    protected computeDomain(data: {
+        min: number;
+        max: number;
+        values: any[];
+    }[]): number[];
+    protected axisHelper(): IAxisHelper;
+}

package/build/es5/component/axis/cartesian/log-axis.d.ts

@@ -0,0 +1,15 @@
+import { CartesianLinearAxis } from './linear-axis';
+import { ComponentTypeEnum } from '../../interface';
+import { LinearAxisMixin } from '../mixin/linear-axis-mixin';
+import { LogScale } from '@visactor/vscale';
+export interface CartesianLogAxis extends Pick<LinearAxisMixin, 'valueToPosition' | 'dataToPosition'>, CartesianLinearAxis {
+}
+export declare class CartesianLogAxis extends CartesianLinearAxis {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _zero: boolean;
+    protected _scale: LogScale;
+    protected _scales: LogScale[];
+    protected initScales(): void;
+    transformScaleDomain(): void;
+}

package/build/es5/component/axis/cartesian/time-axis.d.ts

@@ -0,0 +1,20 @@
+import type { IEffect } from '../../../model/interface';
+import { CartesianLinearAxis } from './linear-axis';
+import { ComponentTypeEnum } from '../../interface';
+import { CompilableData } from '../../../compile/data';
+import type { LinearAxisMixin } from '../mixin/linear-axis-mixin';
+export interface CartesianTimeAxis extends Pick<LinearAxisMixin, 'valueToPosition' | 'dataToPosition'>, CartesianLinearAxis {
+}
+export declare class CartesianTimeAxis extends CartesianLinearAxis {
+    static type: ComponentTypeEnum;
+    type: ComponentTypeEnum;
+    protected _layerTickData: CompilableData;
+    protected _zero: boolean;
+    effect: IEffect;
+    setAttrFromSpec(): void;
+    protected _initData(): void;
+    protected computeData(): void;
+    protected getLabelFormatMethod(): any;
+    protected getLabelItems(length: number): any[];
+    transformScaleDomain(): void;
+}

package/build/es5/component/axis/cartesian/util/common.d.ts

@@ -0,0 +1,10 @@
+import type { IOrientType } from '../../../../typings';
+import { Direction } from '../../../../typings';
+import type { ICartesianAxisCommonSpec } from '../interface';
+export declare function isXAxis(orient: IOrientType): boolean;
+export declare function isYAxis(orient: IOrientType): boolean;
+export declare function isZAxis(orient: IOrientType): boolean;
+export declare function autoAxisType(orient: IOrientType, isHorizontal: boolean): "linear" | "band";
+export declare function getOrient(spec: ICartesianAxisCommonSpec, whiteList?: string[]): IOrientType;
+export declare function getDirectionByOrient(orient: IOrientType): Direction;
+export declare function isOrientInSameDirection(orient1: IOrientType, orient2: IOrientType): boolean;

package/build/es5/component/axis/cartesian/util/index.d.ts

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

package/build/es5/component/axis/cartesian/util/time.d.ts

@@ -0,0 +1,80 @@
+import type { StringOrNumber } from '../../../../typings';
+export declare class TimeUtil {
+    private locale_shortWeekdays;
+    private locale_periods;
+    private locale_weekdays;
+    private locale_shortMonths;
+    private numberRe;
+    private pads;
+    private requoteRe;
+    private periodRe;
+    private periodLookup;
+    private weekdayRe;
+    private weekdayLookup;
+    private shortWeekdayRe;
+    private shortWeekdayLookup;
+    private monthRe;
+    private monthLookup;
+    private shortMonthRe;
+    private shortMonthLookup;
+    private static instance;
+    static getInstance(): TimeUtil;
+    private requoteF;
+    private constructor();
+    private requote;
+    private localDate;
+    private utcDate;
+    private newDate;
+    private formatRe;
+    private formatLookup;
+    private locale_months;
+    private formatShortWeekday;
+    private formatWeekday;
+    private formatShortMonth;
+    private formatMonth;
+    private pad;
+    private formatDayOfMonth;
+    private formatHour24;
+    private formatHour12;
+    private formatMilliseconds;
+    private formatMonthNumber;
+    private formatMinutes;
+    private formatPeriod;
+    private formatSeconds;
+    private formatFullYear;
+    private formatUTCShortWeekday;
+    private formatUTCWeekday;
+    private formatUTCShortMonth;
+    private formatUTCMonth;
+    private formatUTCDayOfMonth;
+    private formatUTCHour24;
+    private formatUTCHour12;
+    private formatUTCMilliseconds;
+    private formatUTCMonthNumber;
+    private formatUTCMinutes;
+    private formatUTCPeriod;
+    private formatUTCSeconds;
+    private formatUTCFullYear;
+    private formats;
+    private utcFormats;
+    private parseShortWeekday;
+    private parseWeekday;
+    private parseShortMonth;
+    private parseMonth;
+    private parseDayOfMonth;
+    private parseHour24;
+    private parseMilliseconds;
+    private parseMonthNumber;
+    private parseMinutes;
+    private parsePeriod;
+    private parseSeconds;
+    private parseFullYear;
+    private parses;
+    private parseSpecifier;
+    private newParse;
+    private newFormat;
+    private getFullTimeStamp;
+    timeFormat: (specifier: string, timeText: StringOrNumber) => string;
+    timeUTCFormat: (specifier: string, timeText: StringOrNumber) => string;
+    timeParse: (specifier: string, timeText: string | string) => Date;
+}

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

@@ -0,0 +1,3 @@
+export * from './interface';
+export * from './cartesian/interface/index';
+export * from './polar/interface/index';