realchart 0.9.1

package/dist/index.d.ts

@@ -0,0 +1,1443 @@
+declare abstract class RcObject {
+    static destroy(obj: RcObject): null;
+    private $_hash;
+    private $_destroyed;
+    private $_destroying;
+    constructor(noHash?: boolean);
+    destroy(): null;
+    protected _doDestory(): void;
+    get destroying(): boolean;
+    get hash(): string;
+    isMe(hash: string): boolean;
+    toString(): string;
+    toBool(v: any): boolean;
+    toNum(v: any, def?: number): number;
+}
+declare abstract class RcWrappableObject extends RcObject {
+    protected _wrapper: any;
+    wrapper(): any;
+    wrapperOrThis(): any;
+    createWrapper<T>(clazz: {
+        new (): T;
+    }): T;
+    setWrapper<T>(wrapper: T): T;
+    isWrapper(w: any): boolean;
+}
+declare abstract class RcEventProvider<T> extends RcObject {
+    private _listeners;
+    addListener(listener: T): void;
+    removeListener(listener: T): void;
+    protected _fireEvent(event: string, ...args: any[]): any;
+}
+
+type Path = string | any[];
+type SizeValue = string | number;
+interface SVGStyles {
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: string;
+    fontFamily?: string;
+    fontSize?: string;
+    fontWeight?: string;
+    fontStyle?: string;
+}
+type SVGStyleOrClass = SVGStyles | string;
+declare enum Align {
+    LEFT = "left",
+    CENTER = "center",
+    RIGHT = "right"
+}
+declare enum VerticalAlign {
+    TOP = "top",
+    MIDDLE = "middle",
+    BOTTOM = "bottom"
+}
+declare enum SectionDir {
+    LEFT = 0,
+    TOP = 1,
+    BOTTOM = 2,
+    RIGHT = 3
+}
+
+interface ISize {
+    width: number;
+    height: number;
+}
+
+interface IRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+interface IPoint {
+    x: number;
+    y: number;
+}
+
+interface IPointerHandler {
+    handleMove(ev: PointerEvent): void;
+    handleClick(ev: PointerEvent): void;
+    handleDblClick(ev: PointerEvent): void;
+    handleWheel(ev: WheelEvent): void;
+}
+declare abstract class RcControl extends RcWrappableObject {
+    static readonly CLASS_NAME = "rct-control";
+    static readonly SHADOW_FILTER = "rr-chart-shadow-filter";
+    private _container;
+    private _dom;
+    private _htmlRoot;
+    private _svg;
+    private _defs;
+    private _root;
+    private _pointerHandler;
+    private _inited;
+    private _testing;
+    private _dirty;
+    private _requestTimer;
+    private _invalidElements;
+    private _toAnimation;
+    private _invalidateLock;
+    private _lockDirty;
+    private _cssVars;
+    loaded: boolean;
+    constructor(doc: Document, container: string | HTMLDivElement, className?: string);
+    protected _doDestory(): void;
+    isInited(): boolean;
+    isTesting(): boolean;
+    doc(): Document;
+    dom(): HTMLElement;
+    width(): number;
+    height(): number;
+    clearDefs(): void;
+    clearTemporaryDefs(): void;
+    appendDom(elt: HTMLElement): void;
+    addElement(elt: RcElement): void;
+    removeElement(elt: RcElement): void;
+    setPointerHandler(handler: IPointerHandler): void;
+    invalidate(force?: boolean): void;
+    invalidateLayout(force?: boolean): void;
+    setLock(): void;
+    releaseLock(validate?: boolean): void;
+    lock(func: (control: RcControl) => void): void;
+    silentLock(func: (control: RcControl) => void): void;
+    getBounds(): DOMRect;
+    setAnimation(to?: number): void;
+    fling(distance: number, duration: number): void;
+    getCssVar(name: string): string;
+    clipBounds(x?: number, y?: number, width?: number, height?: number, rd?: number): ClipElement;
+    clipRect(r: IRect): ClipElement;
+    clipPath(): ClipPathElement;
+    removeDef(element: RcElement): void;
+    containerToElement(element: RcElement, x: number, y: number): IPoint;
+    abstract useImage(src: string): void;
+    protected _setTesting(): void;
+    protected _setSize(w: number, h: number): void;
+    private $_addListener;
+    protected _resigterEventHandlers(dom: HTMLElement): void;
+    protected _unresigterEventHandlers(dom: HTMLElement): void;
+    protected _prepareRenderers(dom: HTMLElement): void;
+    private $_initControl;
+    protected _initDefs(doc: Document, defs: SVGElement): void;
+    protected _render(): void;
+    private $_invalidateElement;
+    private $_requestRender;
+    updateNow(): void;
+    private $_render;
+    protected abstract _doRender(bounds: IRect): void;
+    protected _doBeforeRender(): void;
+    protected _doAfterRender(): void;
+    protected _doRenderBackground(elt: HTMLDivElement, width: number, height: number): void;
+    protected _windowResizeHandler: (event: Event) => void;
+    protected _windowResized(): void;
+    toOffset(event: any): any;
+    private _clickHandler;
+    private _dblClickHandler;
+    private _touchMoveHandler;
+    private _pointerDownHandler;
+    private _pointerMoveHandler;
+    private _pointerUpHandler;
+    private _pointerCancelHandler;
+    private _pointerLeaveHandler;
+    private _keyPressHandler;
+    private _wheelHandler;
+}
+declare class RcElement extends RcObject {
+    static TESTING: boolean;
+    static DEBUGGING: boolean;
+    static TEMP_KEY: string;
+    private _visible;
+    private _x;
+    private _y;
+    private _width;
+    private _height;
+    private _zIndex;
+    private _translateX;
+    private _translateY;
+    private _scaleX;
+    private _scaleY;
+    private _rotation;
+    private _originX;
+    private _originY;
+    private _matrix;
+    protected _styleName: string;
+    protected _styles: any;
+    protected _styleDirty: boolean;
+    private _dom;
+    private _parent;
+    removing: boolean;
+    constructor(doc: Document, styleName: string, tag?: string);
+    protected _doDestory(): void;
+    get doc(): Document;
+    get dom(): SVGElement;
+    get parent(): RcElement;
+    get control(): RcControl;
+    get zIndex(): number;
+    set zIndex(value: number);
+    get x(): number;
+    set x(value: number);
+    get tx(): number;
+    get y(): number;
+    set y(value: number);
+    get ty(): number;
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get visible(): boolean;
+    set visible(value: boolean);
+    setVisible(value: boolean): boolean;
+    get rotation(): number;
+    set rotation(value: number);
+    setRotaion(originX: number, originY: number, rotation: number): RcElement;
+    getStyle(prop: string): string;
+    hasStyle(className: string): boolean;
+    add(child: RcElement): RcElement;
+    insertChild(child: RcElement, before: RcElement): RcElement;
+    insertFirst(child: RcElement): RcElement;
+    removeChild(child: RcElement): void;
+    remove(): RcElement;
+    appendElement(doc: Document, tag: string): SVGElement;
+    insertElement(doc: Document, tag: string, before: Node): SVGElement;
+    getAttr(attr: string): any;
+    setAttr(attr: string, value: any): RcElement;
+    setAttrs(attrs: any): RcElement;
+    unsetAttr(attr: string): RcElement;
+    setBounds(x: number, y: number, width: number, height: number): RcElement;
+    setRect(rect: IRect): RcElement;
+    getRect(): IRect;
+    getSize(): ISize;
+    getBBounds(): IRect;
+    controlToElement(x: number, y: number): IPoint;
+    move(x: number, y: number): RcElement;
+    translate(x: number, y: number): RcElement;
+    translateX(x: number): RcElement;
+    translateY(y: number): RcElement;
+    resize(width: number, height: number, attr?: boolean): RcElement;
+    appendDom(dom: Node): Node;
+    insertDom(dom: Node, before: Node): Node;
+    clearDom(): void;
+    clearStyles(): boolean;
+    clearStyle(props: string[]): boolean;
+    setStyles(styles: any): boolean;
+    resetStyles(styles: any): boolean;
+    protected _resetClass(): void;
+    clearStyleAndClass(): void;
+    setStyleOrClass(style: SVGStyleOrClass): void;
+    addStyleOrClass(style: SVGStyleOrClass): void;
+    setStyleName(value: string): void;
+    setStyle(prop: string, value: string): boolean;
+    putStyles(styles: any, buff?: any): any;
+    putStyle(prop: string, value: string, buff?: any): any;
+    setData(data: string, value?: string): void;
+    unsetData(data: string): void;
+    removeLater(moveToFirst?: boolean, duration?: number): RcElement;
+    fadeout(removeDelay: number, startOpacity: number): RcElement;
+    clipRect(x: number, y: number, width: number, height: number, rd?: number): ClipElement;
+    setClip(cr?: ClipElement | ClipPathElement | string): void;
+    setTemporary(): RcElement;
+    protected _testing(): boolean;
+    protected _doAttached(parent: RcElement): void;
+    protected _doDetached(parent: RcElement): void;
+    protected _updateTransform(): void;
+}
+declare class LayerElement extends RcElement {
+    constructor(doc: Document, styleName: string);
+}
+declare class ClipElement extends RcElement {
+    private _id;
+    private _rect;
+    constructor(doc: Document, x: number, y: number, width: number, height: number, rx?: number, ry?: number);
+    get id(): string;
+    setBounds(x: number, y: number, w: number, h: number): RcElement;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+}
+declare class ClipPathElement extends RcElement {
+    private _id;
+    private _path;
+    constructor(doc: Document);
+    get id(): string;
+    setPath(path: Path): void;
+}
+
+declare enum TextAnchor {
+    START = "start",
+    MIDDLE = "middle",
+    END = "end"
+}
+declare enum TextLayout {
+    TOP = "top",
+    MIDDLE = "middle",
+    BOTTOM = "bottom"
+}
+declare enum TextOverflow {
+    TRUNCATE = "truncate",
+    WRAP = "wrap",
+    ELLIPSIS = "ellipsis"
+}
+declare class TextElement extends RcElement {
+    private _layout;
+    private _overflow;
+    private _dirty;
+    private _text;
+    private _bounds;
+    constructor(doc: Document, styleName?: string);
+    get text(): string;
+    set text(value: string);
+    get anchor(): TextAnchor;
+    set anchor(value: TextAnchor);
+    get layout(): TextLayout;
+    set layout(value: TextLayout);
+    get overflow(): TextOverflow;
+    set overflow(value: TextOverflow);
+    get svg(): string;
+    set svg(value: string);
+    get opacity(): number;
+    set opacity(value: number);
+    getAscent(height: number): number;
+    layoutText(lineHeight?: number): void;
+    isFitIn(bounds: number): boolean;
+    calcWidth(): number;
+    calcRangeWidth(start?: number, end?: number): number;
+    truncate(bounds: number, ellipsis: boolean): void;
+    setContrast(target: Element, darkStyle: SVGStyleOrClass, brightStyle: SVGStyleOrClass): TextElement;
+    clearDom(): void;
+    setStyles(styles: any): boolean;
+    setStyle(prop: string, value: string): boolean;
+    getBBounds(): IRect;
+    getBBoundsTest(): IRect;
+}
+
+type RichTextParamCallback = (target: any, param: string) => string;
+
+declare abstract class ChartItem extends RcObject {
+    readonly chart: IChart;
+    private _visible;
+    constructor(chart: IChart, visible?: boolean);
+    get visible(): boolean;
+    set visible(value: boolean);
+    style: SVGStyleOrClass;
+    load(source: any): ChartItem;
+    prepareRender(): void;
+    protected _changed(): void;
+    protected _doLoadSimple(source: any): boolean;
+    protected _getDefObjProps(prop: string): any;
+    protected _doLoad(source: any): void;
+    protected _doLoadProp(prop: string, value: any): boolean;
+    protected _doPrepareRender(chart: IChart): void;
+}
+declare enum ChartTextEffect {
+    NONE = "none",
+    OUTLINE = "outline",
+    BACKGROUND = "background"
+}
+declare abstract class ChartText extends ChartItem {
+    effect: ChartTextEffect;
+    brightStyle: SVGStyleOrClass;
+    darkStyle: SVGStyleOrClass;
+    backgroundStyle: SVGStyleOrClass;
+    autoContrast: boolean;
+}
+declare abstract class FormattableText extends ChartText {
+    private _numberSymbols;
+    private _numberFormat;
+    private _text;
+    private _numSymbols;
+    private _numberFormatter;
+    private _richTextImpl;
+    constructor(chart: IChart, visible: boolean);
+    prefix: string;
+    suffix: string;
+    get numberSymbols(): string;
+    set numberSymbols(value: string);
+    get numberFormat(): string;
+    set numberFormat(value: string);
+    offset: number;
+    get text(): string;
+    set text(value: string);
+    buildSvg(view: TextElement, target: any, callback: RichTextParamCallback): void;
+    protected _doLoadSimple(source: any): boolean;
+    private $_getNumberText;
+    protected _getText(text: string, value: any, useSymbols: boolean, forceSymbols?: boolean): string;
+}
+declare class BackgroundImage extends ChartItem {
+    url: string;
+    style: SVGStyleOrClass;
+}
+
+declare class Crosshair extends ChartItem {
+    axis: IAxis;
+    constructor(axis: IAxis);
+    showAlways: boolean;
+    showLabel: boolean;
+    labelFormat: string;
+    labelStyles: SVGStyleOrClass;
+}
+
+declare enum LineType {
+    DEFAULT = "default",
+    SPLINE = "spline",
+    STEP = "step"
+}
+
+interface IPointPos {
+    xPos: number;
+    yPos: number;
+    isNull: boolean;
+}
+declare class DataPoint {
+    static swap(pts: IPointPos[]): IPointPos[];
+    source: any;
+    index: number;
+    x: any;
+    y: any;
+    readonly pid: number;
+    isNull: boolean;
+    xValue: number;
+    yValue: number;
+    yRate: number;
+    visible: boolean;
+    color: string;
+    xPos: number;
+    yPos: number;
+    yGroup: number;
+    constructor(source: any);
+    get yAbs(): number;
+    get xAbs(): number;
+    ariaHint(): string;
+    labelCount(): number;
+    getProp(fld: string | number): any;
+    parse(series: ISeries): void;
+    getLabel(index: number): any;
+    getValueOf: (traget: any, param: string) => any;
+    swap(): void;
+    protected _colorIndex(): number;
+    protected _readArray(series: ISeries, v: any[]): void;
+    protected _readObject(series: ISeries, v: any): void;
+    protected _readSingle(v: any): void;
+}
+declare class DataPointCollection {
+    private _owner;
+    private _points;
+    constructor(owner: ISeries);
+    get count(): number;
+    isEmpty(): boolean;
+    get(index: number): DataPoint;
+    load(source: any): void;
+    getProps(prop: string | number): any[];
+    getValues(axis: string): any[];
+    forEach(callback: (p: DataPoint, i?: number) => any): void;
+    getPoints(): DataPoint[];
+    getVisibles(): DataPoint[];
+}
+
+interface ILegendSource {
+    visible: boolean;
+    legendColor(): string;
+    legendLabel(): string;
+    legendVisible(): boolean;
+}
+declare class LegendItem extends ChartItem {
+    legend: Legend;
+    source: ILegendSource;
+    constructor(legend: Legend, source: ILegendSource);
+    text(): string;
+}
+declare enum LegendPosition {
+    BOTTOM = "bottom",
+    TOP = "top",
+    RIGHT = "right",
+    LEFT = "left",
+    PLOT = "plot",
+    SUBPLOT = "subplot"
+}
+declare enum LegendAlignBase {
+    CHART = "chart",
+    PLOT = "plot"
+}
+declare enum LegendLayout {
+    AUTO = "auto",
+    HORIZONTAL = "horizontal",
+    VERTICAL = "vertical"
+}
+declare class Legend extends ChartItem {
+    private _items;
+    constructor(chart: IChart);
+    position: LegendPosition;
+    layout: LegendLayout;
+    alignBase: LegendAlignBase;
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    itemGap: number;
+    markerGap: number;
+    backgroundStyles: SVGStyleOrClass;
+    items(): LegendItem[];
+    isEmpty(): boolean;
+    isVisible(): boolean;
+    getLayout(): LegendLayout;
+    prepareRender(): void;
+    private $_collectItems;
+}
+
+declare class Tooltip extends ChartItem {
+    series: ISeries;
+    static readonly HIDE_DELAY = 700;
+    constructor(series: ISeries);
+    html: string;
+    text: string;
+    offset: number;
+    hideDelay: number;
+    minWidth: number;
+    minHeight: number;
+    followPointer: boolean;
+    getValue(point: DataPoint, param: string): string;
+}
+
+declare enum PointItemPosition {
+    AUTO = "auto",
+    INSIDE = "inside",
+    OUTSIDE = "outside",
+    HEAD = "head",
+    FOOT = "foot",
+    INSIDE_FIRST = "insideFirst",
+    OUTSIDE_FIRST = "outsideFirst"
+}
+declare class DataPointLabel extends FormattableText {
+    position: PointItemPosition;
+    offset: number;
+    constructor(chart: IChart);
+    getText(value: any): string;
+}
+interface IPlottingItem {
+    index: number;
+    xAxis: string | number;
+    yAxis: string | number;
+    visible: boolean;
+    getVisiblePoints(): DataPoint[];
+    getLegendSources(list: ILegendSource[]): void;
+    needAxes(): boolean;
+    isEmpty(): boolean;
+    canCategorized(): boolean;
+    defaultYAxisType(): string;
+    clusterable(): boolean;
+    getBaseValue(axis: IAxis): number;
+    canMinPadding(axis: IAxis): boolean;
+    canMaxPadding(axis: IAxis): boolean;
+    ignoreAxisBase(axis: IAxis): boolean;
+    collectCategories(axis: IAxis): string[];
+    prepareRender(): void;
+    prepareAfter(): void;
+    collectValues(axis: IAxis, vals: number[]): void;
+    pointValuesPrepared(axis: IAxis): void;
+}
+declare enum TrendType {
+    LINEAR = "linear",
+    LOGARITHMIC = "logarithmic",
+    POLYNOMIAL = "polynomial",
+    POWER = "power",
+    EXPONENTIAL = "exponential",
+    MOVING_AVERAGE = "movingAverage"
+}
+declare class MovingAverage {
+    interval: number;
+    type: 'simple' | 'weighted' | 'exponential' | 'triangualr';
+}
+declare class Trendline extends ChartItem {
+    series: Series;
+    _points: {
+        x: number;
+        y: number;
+    }[];
+    constructor(series: Series);
+    type: TrendType;
+    lineType: LineType;
+    movingAverage: MovingAverage;
+    protected _doPrepareRender(chart: IChart): void;
+    protected _getDefObjProps(prop: string): {
+        interval: number;
+        type: string;
+    };
+    $_linear(pts: DataPoint[], list: {
+        x: number;
+        y: number;
+    }[]): void;
+    $_logarithmic(pts: DataPoint[], list: {
+        x: number;
+        y: number;
+    }[]): void;
+    $_polynomial(pts: DataPoint[], list: {
+        x: number;
+        y: number;
+    }[]): void;
+    $_power(pts: DataPoint[], list: {
+        x: number;
+        y: number;
+    }[]): void;
+    $_exponential(pts: DataPoint[], list: {
+        x: number;
+        y: number;
+    }[]): void;
+    $_movingAverage(pts: DataPoint[], list: {
+        x: number;
+        y: number;
+    }[]): void;
+}
+interface ISeriesGroup extends IPlottingItem {
+}
+interface ISeries extends IPlottingItem {
+    chart: IChart;
+    group: ISeriesGroup;
+    xField: string | number;
+    yField: string | number;
+    colorField: string | number;
+    color: string;
+    displayName(): string;
+    createPoints(source: any[]): DataPoint[];
+    getPoints(): DataPointCollection;
+    getValue(point: DataPoint, axis: IAxis): number;
+    isVisible(p: DataPoint): boolean;
+}
+declare abstract class Series extends ChartItem implements ISeries, ILegendSource {
+    static _loadSeries(chart: IChart, src: any, defType?: string): Series;
+    readonly name: string;
+    readonly label: string;
+    readonly pointLabel: DataPointLabel;
+    readonly trendline: Trendline;
+    readonly tooltip: Tooltip;
+    index: number;
+    group: SeriesGroup<Series>;
+    _xAxisObj: IAxis;
+    _yAxisObj: IAxis;
+    protected _points: DataPointCollection;
+    _visPoints: DataPoint[];
+    _minValue: number;
+    _maxValue: number;
+    _referents: Series[];
+    constructor(chart: IChart, name?: string);
+    abstract _type(): string;
+    zOrder: number;
+    xAxis: string | number;
+    yAxis: string | number;
+    xField: string | number;
+    yField: string | number;
+    colorField: string;
+    dataProp: string;
+    xStart: number;
+    xStep: number | string;
+    color: string;
+    pointColors: boolean | string[];
+    clipped: boolean;
+    getPoints(): DataPointCollection;
+    getLabeledPoints(): DataPoint[];
+    getVisiblePoints(): DataPoint[];
+    isEmpty(): boolean;
+    needAxes(): boolean;
+    canCategorized(): boolean;
+    defaultYAxisType(): string;
+    clusterable(): boolean;
+    displayName(): string;
+    legendColor(): string;
+    legendLabel(): string;
+    legendVisible(): boolean;
+    ignoreAxisBase(axis: IAxis): boolean;
+    canMixWith(other: IPlottingItem): boolean;
+    getBaseValue(axis: IAxis): number;
+    canMinPadding(axis: IAxis): boolean;
+    canMaxPadding(axis: IAxis): boolean;
+    protected _createPoint(source: any): DataPoint;
+    createPoints(source: any[]): DataPoint[];
+    getXStart(): number;
+    getXStep(): number;
+    getValue(point: DataPoint, axis: IAxis): number;
+    prepareRender(): void;
+    collectCategories(axis: IAxis): string[];
+    collectValues(axis: IAxis, vals: number[]): void;
+    pointValuesPrepared(axis: IAxis): void;
+    reference(other: Series, axis: IAxis): void;
+    isVisible(point: DataPoint): boolean;
+    getLegendSources(list: ILegendSource[]): void;
+    getLabelPosition(p: PointItemPosition): PointItemPosition;
+    getLabelOff(off: number): number;
+    referBy(ref: Series): void;
+    _referOtherSeries(series: Series): boolean;
+    protected _getField(axis: IAxis): any;
+    protected _colorByPoint(): boolean;
+    protected _doLoad(src: any): void;
+    protected _doLoadPoints(src: any[]): void;
+    protected _doPrepareRender(): void;
+    prepareAfter(): void;
+}
+declare class PlottingItemCollection {
+    readonly chart: IChart;
+    private _map;
+    private _items;
+    private _visibles;
+    private _series;
+    private _visibleSeries;
+    constructor(chart: IChart);
+    get first(): IPlottingItem;
+    get firstSeries(): Series;
+    get firstVisible(): IPlottingItem;
+    get firstVisibleSeries(): Series;
+    isEmpty(): boolean;
+    items(): IPlottingItem[];
+    visibles(): IPlottingItem[];
+    series(): Series[];
+    visibleSeries(): Series[];
+    needAxes(): boolean;
+    get(name: string): Series;
+    getLegendSources(): ILegendSource[];
+    load(src: any): void;
+    prepareRender(): void;
+    prepareAfter(): void;
+    private $_loadItem;
+}
+declare enum SeriesGroupLayout {
+    DEFAULT = "default",
+    OVERLAP = "overlap",
+    STACK = "stack",
+    FILL = "fill"
+}
+declare abstract class SeriesGroup<T extends Series> extends ChartItem implements ISeriesGroup {
+    layoutMax: number;
+    index: number;
+    private _series;
+    protected _visibles: T[];
+    _xAxisObj: IAxis;
+    _yAxisObj: IAxis;
+    _stackPoints: Map<number, DataPoint[]>;
+    layout: SeriesGroupLayout;
+    xAxis: string | number;
+    yAxis: string | number;
+    get series(): T[];
+    needAxes(): boolean;
+    isEmpty(): boolean;
+    canCategorized(): boolean;
+    defaultYAxisType(): string;
+    clusterable(): boolean;
+    getBaseValue(axis: IAxis): number;
+    _type(): string;
+    abstract _seriesType(): string;
+    collectValues(axis: IAxis, vals: number[]): void;
+    pointValuesPrepared(axis: IAxis): void;
+    collectCategories(axis: IAxis): string[];
+    ignoreAxisBase(axis: IAxis): boolean;
+    getLegendSources(list: ILegendSource[]): void;
+    canMinPadding(axis: IAxis): boolean;
+    canMaxPadding(axis: IAxis): boolean;
+    getVisiblePoints(): DataPoint[];
+    protected _doLoadProp(prop: string, value: any): boolean;
+    prepareRender(): void;
+    protected _doPrepareRender(chart: IChart): void;
+    prepareAfter(): void;
+    protected abstract _canContain(ser: Series): boolean;
+    protected _doPrepareSeries(series: T[]): void;
+    private $_loadSeries;
+    private $_add;
+    private $_collectValues;
+    private $_collectPoints;
+    private $_collectStack;
+    private $_collectFill;
+}
+
+interface IAxis {
+    type(): string;
+    chart: IChart;
+    _length: number;
+    _isX: boolean;
+    _isHorz: boolean;
+    _isOpposite: boolean;
+    reversed: boolean;
+    getBaseValue(): number;
+    axisMax(): number;
+    axisMin(): number;
+    getValue(value: any): number;
+    parseValue(value: any): number;
+    contains(value: number): boolean;
+    getPosition(length: number, value: number, point?: boolean): number;
+    getUnitLength(length: number, value: number): number;
+}
+declare abstract class AxisItem extends ChartItem {
+    readonly axis: Axis;
+    constructor(axis: Axis, visible?: boolean);
+}
+declare class AxisLine extends AxisItem {
+    constructor(axis: Axis);
+}
+declare class AxisTitle extends AxisItem {
+    text: string;
+    gap: number;
+    backgroundStyle: SVGStyleOrClass;
+    isVisible(): boolean;
+    protected _doLoadSimple(source: any): boolean;
+}
+declare class AxisGrid extends AxisItem {
+    circular: boolean;
+    startVisible: boolean;
+    endVisible: boolean;
+    constructor(axis: Axis);
+    isVisible(): boolean;
+    getPoints(length: number): number[];
+}
+declare class AxisGuideLabel extends FormattableText {
+    constructor(chart: IChart);
+    align: Align;
+    valign: VerticalAlign;
+}
+declare abstract class AxisGuide extends AxisItem {
+    readonly label: AxisGuideLabel;
+    front: boolean;
+    zindex: number;
+    constructor(axis: Axis);
+}
+declare class AxisGuideLine extends AxisGuide {
+    value: number;
+}
+declare class AxisGuideRange extends AxisGuide {
+    start: number;
+    end: number;
+}
+declare abstract class AxisTick extends AxisItem {
+    length: number;
+    margin: number;
+    constructor(axis: Axis);
+}
+declare enum AxisLabelArrange {
+    NONE = "none",
+    ROTATE = "rotate",
+    STEP = "step",
+    ROWS = "rows"
+}
+declare abstract class AxisLabel extends FormattableText {
+    axis: Axis;
+    constructor(axis: Axis);
+    step: number;
+    startStep: number;
+    rows: number;
+    rotation: number;
+    autoArrange: AxisLabelArrange;
+    wrap: boolean;
+    abstract getTick(v: any): string;
+    getRotation(): number;
+}
+interface IAxisTick {
+    pos: number;
+    value: number;
+    label: string;
+}
+declare enum AxisPosition {
+    NORMAL = "normal",
+    OPPOSITE = "opposite",
+    BASE = "base"
+}
+declare abstract class Axis extends ChartItem implements IAxis {
+    readonly name: string;
+    readonly title: AxisTitle;
+    readonly line: AxisLine;
+    readonly tick: AxisTick;
+    readonly label: AxisLabel;
+    readonly grid: AxisGrid;
+    readonly guides: AxisGuide[];
+    readonly crosshair: Crosshair;
+    _isX: boolean;
+    _isHorz: boolean;
+    _isOpposite: boolean;
+    protected _series: IPlottingItem[];
+    _range: {
+        min: number;
+        max: number;
+    };
+    _ticks: IAxisTick[];
+    _markPoints: number[];
+    _length: number;
+    _minPad: number;
+    _maxPad: number;
+    _values: number[];
+    constructor(chart: IChart, name?: string);
+    abstract type(): string;
+    position: AxisPosition;
+    reversed: boolean;
+    min: number;
+    max: number;
+    marginNear: number;
+    marginFar: number;
+    isEmpty(): boolean;
+    getBaseValue(): number;
+    abstract axisMin(): number;
+    abstract axisMax(): number;
+    protected abstract _createTickModel(): AxisTick;
+    protected abstract _createLabelModel(): AxisLabel;
+    protected abstract _doPrepareRender(): void;
+    protected abstract _doBuildTicks(min: number, max: number, length: number): IAxisTick[];
+    disconnect(): void;
+    collectValues(): void;
+    collectReferentsValues(): void;
+    prepareRender(): void;
+    buildTicks(length: number): void;
+    calcPoints(length: number, phase: number): void;
+    abstract getPosition(length: number, value: number, point?: boolean): number;
+    abstract getUnitLength(length: number, value: number): number;
+    getLabelLength(length: number, value: number): number;
+    getValue(value: any): number;
+    parseValue(value: any): number;
+    contains(value: number): boolean;
+    protected _doLoadProp(prop: string, value: any): boolean;
+    protected _createGrid(): AxisGrid;
+    private $_loadGuides;
+    _connect(series: IPlottingItem): void;
+    protected _doCalcluateRange(values: number[]): {
+        min: number;
+        max: number;
+    };
+}
+declare class AxisCollection {
+    readonly chart: IChart;
+    readonly isX: boolean;
+    private _items;
+    private _map;
+    constructor(chart: IChart, isX: boolean);
+    get count(): number;
+    get first(): Axis;
+    get items(): Axis[];
+    load(src: any): void;
+    contains(axis: Axis): boolean;
+    get(name: string): Axis;
+    disconnect(): void;
+    collectValues(): void;
+    collectReferentsValues(): void;
+    prepareRender(): void;
+    buildTicks(length: number): void;
+    connect(series: IPlottingItem): Axis;
+    forEach(callback: (p: Axis, i?: number) => any): void;
+    private $_loadAxis;
+}
+
+declare class Body extends ChartItem {
+    private _sizeDim;
+    private _cxDim;
+    private _cyDim;
+    _cx: number;
+    _cy: number;
+    _rd: number;
+    _guides: AxisGuide[];
+    _frontGuides: AxisGuide[];
+    size: SizeValue;
+    centerX: SizeValue;
+    centerY: SizeValue;
+    startAngle: number;
+    circular: boolean;
+    image: BackgroundImage;
+    getSize(width: number, height: number): number;
+    getCenter(width: number, height: number): {
+        cx: number;
+        cy: number;
+    };
+    getStartAngle(): number;
+    getPolar(series: Series): {
+        start: number;
+        cx: number;
+        cy: number;
+        rd: number;
+        deg: number;
+    };
+    protected _doLoad(source: any): void;
+    protected _doPrepareRender(chart: IChart): void;
+}
+
+declare class Title extends ChartItem {
+    text: string;
+    align: Align;
+    backgroundStyle: SVGStyleOrClass;
+    isVisible(): boolean;
+    protected _doLoadSimple(source: any): boolean;
+}
+declare enum SubtitlePosition {
+    BOTTOM = "bottom",
+    RIGHT = "right",
+    LEFT = "left",
+    TOP = "top"
+}
+declare class Subtitle extends Title {
+    position: SubtitlePosition;
+    valign: VerticalAlign;
+    text: string;
+}
+
+interface IChart {
+    type: string;
+    xStart: number;
+    xStep: number;
+    first: IPlottingItem;
+    firstSeries: Series;
+    xAxis: IAxis;
+    yAxis: IAxis;
+    colors: string[];
+    _polar: boolean;
+    isInverted(): boolean;
+    animatable(): boolean;
+    startAngle(): number;
+    seriesByName(series: string): Series;
+    axisByName(axis: string): Axis;
+    getAxes(dir: SectionDir): Axis[];
+    _getGroupType(type: string): any;
+    _getSeriesType(type: string): any;
+    _getAxisType(type: string): any;
+    _getSeries(): PlottingItemCollection;
+    _getXAxes(): AxisCollection;
+    _getYAxes(): AxisCollection;
+    getAxesGap(): number;
+    _connectSeries(series: IPlottingItem, isX: boolean): Axis;
+    _getLegendSources(): ILegendSource[];
+    _visibleChanged(item: ChartItem): void;
+    _modelChanged(item: ChartItem): void;
+}
+declare class ChartOptions extends ChartItem {
+    polar: boolean;
+    animatable: boolean;
+    xStart: number;
+    xStep: number;
+    axisGap: number;
+    style: SVGStyleOrClass;
+}
+interface IChartEventListener {
+    onVisibleChanged?(chart: Chart, item: ChartItem): void;
+}
+declare class Chart extends RcEventProvider<IChartEventListener> implements IChart {
+    private _options;
+    private _title;
+    private _subtitle;
+    private _legend;
+    private _series;
+    private _xAxes;
+    private _yAxes;
+    private _body;
+    private _inverted;
+    _polar: boolean;
+    colors: string[];
+    constructor(source?: any);
+    startAngle(): number;
+    get xStart(): number;
+    get xStep(): number;
+    animatable(): boolean;
+    type: string;
+    inverted: boolean;
+    get options(): ChartOptions;
+    get title(): Title;
+    get subtitle(): Subtitle;
+    get first(): IPlottingItem;
+    get firstSeries(): Series;
+    get legend(): Legend;
+    get xAxis(): IAxis;
+    get yAxis(): IAxis;
+    get body(): Body;
+    needAxes(): boolean;
+    _getSeries(): PlottingItemCollection;
+    _getXAxes(): AxisCollection;
+    _getYAxes(): AxisCollection;
+    isInverted(): boolean;
+    isEmpty(): boolean;
+    seriesByName(series: string): Series;
+    axisByName(axis: string): Axis;
+    containsAxis(axis: Axis): boolean;
+    getAxes(dir: SectionDir): Axis[];
+    _getLegendSources(): ILegendSource[];
+    load(source: any): void;
+    _connectSeries(series: IPlottingItem, isX: boolean): Axis;
+    prepareRender(): void;
+    layoutAxes(width: number, height: number, inverted: boolean, phase: number): void;
+    calcAxesPoints(width: number, height: number, inverted: boolean): void;
+    private $_calcAxesPoints;
+    update(): void;
+    _getGroupType(type: string): any;
+    _getSeriesType(type: string): any;
+    _getAxisType(type: string): any;
+    getAxesGap(): number;
+    _visibleChanged(item: ChartItem): void;
+    _modelChanged(item: ChartItem): void;
+}
+
+declare abstract class GroupElement extends RcElement {
+    private static IGNORE_ATTRS;
+    constructor(doc: Document, styleName?: string);
+    protected _movable(): boolean;
+    setAttr(attr: string, value: any): RcElement;
+    protected _doInitChildren(doc: Document): void;
+}
+
+declare class Sides {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    static readonly Empty: Readonly<Sides>;
+    static Temp: Sides;
+    static create(top: number, bottom?: number, left?: number, right?: number): Sides;
+    static createFrom(value: string): Sides;
+    constructor(top?: number, bottom?: number, left?: number, right?: number);
+    clone(): Sides;
+    applyPadding(cs: CSSStyleDeclaration): Sides;
+    applyMargin(cs: CSSStyleDeclaration): Sides;
+    shrink(r: IRect): IRect;
+    toString(): string;
+}
+
+interface IRectShape extends IRect {
+    r?: number;
+    rx?: number;
+    ry?: number;
+    rLeft?: number;
+    rTop?: number;
+    rRight?: number;
+    rBottom?: number;
+}
+declare class RectElement extends RcElement {
+    static create(doc: Document, styleName: string, x: number, y: number, width: number, height: number, r?: number): RectElement;
+    private _rect;
+    constructor(doc: Document, styleName?: string, rect?: IRectShape);
+    get rect(): IRectShape;
+    set rect(value: IRectShape);
+    setBounds(x: number, y: number, width: number, height: number, r?: number): RectElement;
+    setBox(x: number, y: number, width: number, height: number): void;
+    setRadius(value: number): void;
+}
+
+declare abstract class ChartElement<T extends ChartItem> extends RcElement {
+    model: T;
+    mw: number;
+    mh: number;
+    _debugRect: RectElement;
+    constructor(doc: Document, styleName?: any);
+    chart(): IChart;
+    measure(doc: Document, model: T, hintWidth: number, hintHeight: number, phase: number): ISize;
+    layout(param?: any): ChartElement<ChartItem>;
+    resizeByMeasured(): ChartElement<ChartItem>;
+    protected _getDebugRect(): IRect;
+    protected abstract _doMeasure(doc: Document, model: T, intWidth: number, hintHeight: number, phase: number): ISize;
+    protected abstract _doLayout(param: any): void;
+    protected _invalidate(): void;
+    protected _doModelChanged(): void;
+}
+declare abstract class BoundableElement<T extends ChartItem> extends ChartElement<T> {
+    private _background;
+    protected _margins: Sides;
+    protected _paddings: Sides;
+    private _borderRadius;
+    constructor(doc: Document, styleName: string, backStyle: string);
+    protected _getDebugRect(): IRect;
+    measure(doc: Document, model: T, hintWidth: number, hintHeight: number, phase: number): ISize;
+    layout(param?: any): ChartElement<ChartItem>;
+    protected abstract _setBackgroundStyle(back: RectElement): void;
+    protected _getBackOffset(): number;
+}
+
+type Visitor<T extends RcElement> = (element: T, index?: number, count?: number) => void;
+declare class ElementPool<T extends RcElement> extends RcObject {
+    removeDelay: number;
+    private _owner;
+    private _creator;
+    private _pool;
+    private _views;
+    private _removes;
+    private _styleName;
+    constructor(owner: RcElement, creator: {
+        new (doc: Document, styleName?: string): T;
+    }, styleName?: string, removeDelay?: number);
+    protected _doDestory(): void;
+    get isEmpty(): boolean;
+    get count(): number;
+    get first(): T;
+    get last(): T;
+    get(index: number): T;
+    getAll(): T[];
+    elementOf(dom: Element): T;
+    private $_create;
+    prepare(count: number, visitor?: Visitor<T>, initor?: Visitor<T>): ElementPool<T>;
+    reprepare(viewProp: string, objs: RcObject[], objProp: string, cleaner?: Visitor<T>, initor?: Visitor<T>, visitor?: Visitor<T>): ElementPool<T>;
+    borrow(): T;
+    free(element: T, removeDelay?: number): void;
+    freeAll(elements: T[], removeDelay?: number): void;
+    fadeout(element: T, removeDelay: number, startOpacity?: number): void;
+    forEach(visitor: (v: T, i?: number, count?: number) => void): void;
+    visit(visitor: (v: T, i: number, count: number) => boolean): boolean;
+    find(visitor: (v: T) => boolean): T;
+    sort(compare: (v1: T, v2: T) => number): ElementPool<T>;
+    map(callback: (v: T) => any): any[];
+}
+
+declare abstract class RcAnimation {
+    static readonly DURATION = 700;
+    static readonly SHORT_DURATION = 300;
+    delay: number;
+    duration: number;
+    easing: string;
+    private _easing;
+    private _started;
+    private _timer;
+    private _handler;
+    start(): void;
+    protected _start(duration: number, delay?: number, easing?: string): void;
+    protected _stop(): void;
+    protected _doStart(): void;
+    protected _doStop(): void;
+    protected abstract _doUpdate(rate: number): boolean;
+}
+
+declare class LabelElement extends GroupElement {
+    private _back;
+    _outline: TextElement;
+    _text: TextElement;
+    private _model;
+    constructor(doc: Document, styleName?: string);
+    get text(): string;
+    get anchor(): TextAnchor;
+    setText(s: string): LabelElement;
+    setSvg(s: string): LabelElement;
+    setModel(doc: Document, model: ChartText, contrastTarget: Element): LabelElement;
+    setContrast(target: Element): LabelElement;
+    layout(): LabelElement;
+}
+
+interface IPointView {
+    point: DataPoint;
+}
+declare class PointLabelView extends LabelElement {
+    point: DataPoint;
+    moving: boolean;
+    constructor(doc: Document);
+}
+declare class PointLabelContainer extends GroupElement {
+    private _labels;
+    private _maps;
+    constructor(doc: Document);
+    clear(): void;
+    prepareLabel(doc: Document, view: PointLabelView, index: number, p: DataPoint, model: DataPointLabel): void;
+    prepare(doc: Document, model: Series): void;
+    get(point: DataPoint, index: number): PointLabelView;
+    borrow(index: number): PointLabelView;
+    free(index: number, view: PointLabelView, removeDelay?: number): void;
+}
+declare class PointContainer extends LayerElement {
+    inverted: boolean;
+    invert(v: boolean, height: number): boolean;
+}
+type LabelLayoutInfo = {
+    inverted: boolean;
+    pointView: RcElement;
+    x: number;
+    y: number;
+    hPoint: number;
+    wPoint: number;
+    labelView: PointLabelView;
+    labelPos: PointItemPosition;
+    labelOff: number;
+};
+declare abstract class SeriesView<T extends Series> extends ChartElement<T> {
+    static readonly POINT_CLASS = "rct-data-point";
+    static readonly DATA_FOUCS = "focus";
+    protected _pointContainer: PointContainer;
+    private _labelContainer;
+    private _trendLineView;
+    protected _inverted: boolean;
+    protected _animatable: boolean;
+    private _viewRate;
+    constructor(doc: Document, styleName: string);
+    getClipContainer(): RcElement;
+    setViewRate(rate: number): void;
+    protected _doViewRateChanged(rate: number): void;
+    _setChartOptions(inverted: boolean, animatable: boolean): void;
+    _animationStarted(ani: Animation): void;
+    _animationFinished(ani: Animation): void;
+    protected abstract _getPointPool(): ElementPool<RcElement>;
+    pointByDom(elt: Element): IPointView;
+    clicked(elt: Element): void;
+    protected _doPointClicked(view: IPointView): void;
+    protected _doMeasure(doc: Document, model: T, hintWidth: number, hintHeight: number, phase: number): ISize;
+    protected _doLayout(): void;
+    protected abstract _prepareSeries(doc: Document, model: T): void;
+    protected abstract _renderSeries(width: number, height: number): void;
+    protected _labelViews(): PointLabelContainer;
+    protected _getViewRate(): number;
+    protected _animating(): boolean;
+    protected _lazyPrepareLabels(): boolean;
+    protected _afterRender(): void;
+    protected _getShowAnimation(): RcAnimation;
+    protected _runShowEffect(firstTime: boolean): void;
+    private $_renderTrendline;
+    protected _layoutLabel(info: LabelLayoutInfo): void;
+}
+
+declare class AxisGridView extends ChartElement<AxisGrid> {
+    private _pts;
+    private _lines;
+    constructor(doc: Document);
+    protected _doMeasure(doc: Document, model: AxisGrid, hintWidth: number, hintHeight: number, phase: number): ISize;
+    protected _doLayout(): void;
+}
+declare abstract class AxisGuideView<T extends AxisGuide> extends RcElement {
+    model: T;
+    protected _label: TextElement;
+    constructor(doc: Document);
+    vertical(): boolean;
+    prepare(model: T): void;
+    abstract layout(width: number, height: number): void;
+}
+declare class AxisGuideLineView extends AxisGuideView<AxisGuideLine> {
+    private _line;
+    constructor(doc: Document);
+    prepare(model: AxisGuideLine): void;
+    layout(width: number, height: number): void;
+}
+declare class AxisGuideRangeView extends AxisGuideView<AxisGuideRange> {
+    private _box;
+    constructor(doc: Document);
+    prepare(model: AxisGuideRange): void;
+    layout(width: number, height: number): void;
+}
+declare class AxisGuideContainer extends LayerElement {
+    _linePool: AxisGuideLineView[];
+    _rangePool: AxisGuideRangeView[];
+    _views: AxisGuideView<AxisGuide>[];
+    prepare(): void;
+    addAll(doc: Document, guides: AxisGuide[]): void;
+    add(child: AxisGuideView<AxisGuide>): RcElement;
+}
+interface IPlottingOwner {
+    clipSeries(view: RcElement, x: number, y: number, w: number, h: number): void;
+    showTooltip(series: Series, point: DataPoint): void;
+    hideTooltip(): void;
+}
+declare class BodyView extends ChartElement<Body> {
+    static readonly BODY_CLASS = "rct-plot";
+    private _owner;
+    private _polar;
+    private _background;
+    private _image;
+    private _gridContainer;
+    protected _gridViews: Map<Axis, AxisGridView>;
+    private _breakViews;
+    private _seriesContainer;
+    protected _seriesViews: SeriesView<Series>[];
+    private _seriesMap;
+    private _series;
+    _guideContainer: AxisGuideContainer;
+    _frontGuideContainer: AxisGuideContainer;
+    _axisBreakContainer: LayerElement;
+    private _feedbackContainer;
+    private _crosshairLines;
+    private _focused;
+    constructor(doc: Document, owner: IPlottingOwner);
+    prepareGuideContainers(): void;
+    pointerMoved(p: IPoint, target: EventTarget): void;
+    private $_setFocused;
+    seriesByDom(elt: Element): SeriesView<Series>;
+    protected _doMeasure(doc: Document, model: Body, hintWidth: number, hintHeight: number, phase: number): ISize;
+    protected _doLayout(): void;
+    private $_createSeriesView;
+    private $_prepareGrids;
+    private $_prepareSeries;
+    private $_prepareAxisBreaks;
+    private $_preppareCrosshairs;
+}
+
+declare class TitleView extends BoundableElement<Title> {
+    static readonly TITLE_CLASS = "rct-title";
+    static readonly SUBTITLE_CLASS = "rct-subtitle";
+    private _textView;
+    constructor(doc: Document, isSub: boolean);
+    protected _setBackgroundStyle(back: RectElement): void;
+    protected _doMeasure(doc: Document, model: Title, hintWidth: number, hintHeight: number, phase: number): ISize;
+    protected _doLayout(): void;
+}
+
+declare class EmptyView extends GroupElement {
+}
+declare class ChartView extends RcElement {
+    private _model;
+    _inverted: boolean;
+    _emptyView: EmptyView;
+    private _titleSectionView;
+    private _legendSectionView;
+    private _bodyView;
+    private _polarView;
+    private _currBody;
+    private _axisSectionViews;
+    private _tooltipView;
+    private _seriesClip;
+    private _org;
+    private _plotWidth;
+    private _plotHeight;
+    constructor(doc: Document);
+    titleView(): TitleView;
+    subtitleView(): TitleView;
+    bodyView(): BodyView;
+    measure(doc: Document, model: Chart, hintWidth: number, hintHeight: number, phase: number): void;
+    layout(): void;
+    showTooltip(series: Series, point: DataPoint): void;
+    hideTooltip(): void;
+    legendByDom(dom: Element): LegendItem;
+    seriesByDom(dom: Element): SeriesView<Series>;
+    clipSeries(view: RcElement, x: number, y: number, w: number, h: number): void;
+    protected _doAttached(parent: RcElement): void;
+    private $_checkEmpty;
+    private $_prepareBody;
+    private $_prepareAxes;
+    private $_measurePlot;
+    private $_measurePolar;
+}
+
+declare class ChartControl extends RcControl implements IChartEventListener {
+    private _model;
+    private _chartView;
+    constructor(doc: Document, container: string | HTMLDivElement);
+    onVisibleChanged(chart: Chart, item: ChartItem): void;
+    get model(): Chart;
+    set model(value: Chart);
+    chartView(): ChartView;
+    refresh(): void;
+    update(config: any, loadAnimation?: boolean): void;
+    useImage(src: string): void;
+    protected _doRender(bounds: IRect): void;
+    protected _doRenderBackground(elt: HTMLDivElement, width: number, height: number): void;
+}
+
+declare class Globals {
+    static getVersion(): string;
+    static setDebugging(debug: boolean): void;
+    static createChart(doc: Document, container: string | HTMLDivElement, config: any): ChartControl;
+}
+
+declare const getVersion: typeof Globals.getVersion;
+declare const setDebugging: typeof Globals.setDebugging;
+declare const createChart: typeof Globals.createChart;
+
+export { Chart, ChartControl, createChart, getVersion, setDebugging };