@progress/kendo-vue-charts 3.5.0 → 3.5.1-dev.202208150613

package/dist/esm/components/y-axis-item/Title.d.ts

@@ -0,0 +1,20 @@
+import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } from '../../additionalTypes';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { YAxisTitle } from '../../common/property-types';
+/**
+ * Represents the props of the Kendo UI for Vue ChartYAxisTitle component.
+ */
+export interface ChartYAxisTitleProps extends YAxisTitle {
+}
+/**
+ * @hidden
+ */
+declare const ChartYAxisTitleVue2: ComponentOptions<Vue2type, DefaultData<{}>, DefaultMethods<{}>, {}, RecordPropsDefinition<ChartYAxisTitleProps>>;
+/**
+ * @hidden
+ */
+declare const ChartYAxisTitle: DefineComponent<ChartYAxisTitleProps, any, {}, {}, {}, {}, {}, {}, string, ChartYAxisTitleProps, ChartYAxisTitleProps, {}>;
+export { ChartYAxisTitle, ChartYAxisTitleVue2 };

package/dist/esm/components/y-axis-item/Title.js

@@ -0,0 +1,84 @@
+// @ts-ignore
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+var isV3 = allVue.version && allVue.version[0] === '3';
+import { Configuration } from './../base/ConfigurationComponent.js';
+import { getDefaultSlots } from '@progress/kendo-vue-common';
+import { removeUndefinedProps } from '../../utils/main.js';
+/**
+ * @hidden
+ */
+
+var ChartYAxisTitleVue2 = {
+  name: 'KendoChartYAxisTitle',
+  props: {
+    background: String,
+    border: {
+      type: Object,
+      default: function _default() {
+        return undefined;
+      }
+    },
+    color: String,
+    font: String,
+    margin: {
+      type: [Object, Number],
+      default: function _default() {
+        return undefined;
+      }
+    },
+    padding: {
+      type: [Object, Number],
+      default: function _default() {
+        return undefined;
+      }
+    },
+    position: {
+      type: String,
+      default: undefined,
+      validator: function validator(value) {
+        return ['top', 'bottom', 'left', 'right', 'center'].includes(value);
+      }
+    },
+    rotation: Number,
+    text: String,
+    visible: {
+      type: Boolean,
+      default: undefined
+    },
+    visual: {
+      type: Function,
+      default: undefined
+    }
+  },
+  // @ts-ignore
+  setup: !isV3 ? undefined : function () {
+    var v3 = !!isV3;
+    return {
+      v3: v3
+    };
+  },
+  render: function render(createElement) {
+    var h = gh || createElement;
+    var defaultSlots = getDefaultSlots(this);
+    var config = removeUndefinedProps(this.$props);
+    return this.v3 ? h(Configuration, {
+      config: config,
+      chartKey: 'title'
+    }, function () {
+      return defaultSlots;
+    }) : h(Configuration, {
+      props: {
+        config: config,
+        chartKey: 'title'
+      }
+    }, [defaultSlots]);
+  }
+};
+/**
+ * @hidden
+ */
+
+var ChartYAxisTitle = ChartYAxisTitleVue2;
+export { ChartYAxisTitle, ChartYAxisTitleVue2 };

package/dist/esm/components/y-axis-item/main.d.ts

@@ -0,0 +1,8 @@
+import { ChartYAxisCrosshair, ChartYAxisCrosshairVue2, ChartYAxisCrosshairProps } from './Crosshair';
+import { ChartYAxisCrosshairTooltip, ChartYAxisCrosshairTooltipVue2, ChartYAxisCrosshairTooltipProps } from './CrosshairTooltip';
+import { ChartYAxisLabels, ChartYAxisLabelsVue2, ChartYAxisLabelsProps } from './Labels';
+import { ChartYAxisNotes, ChartYAxisNotesVue2, ChartYAxisNotesProps } from './Notes';
+import { ChartYAxisNotesIcon, ChartYAxisNotesIconVue2, ChartYAxisNotesIconProps } from './NotesIcon';
+import { ChartYAxisNotesLabel, ChartYAxisNotesLabelVue2, ChartYAxisNotesLabelProps } from './NotesLabel';
+import { ChartYAxisTitle, ChartYAxisTitleVue2, ChartYAxisTitleProps } from './Title';
+export { ChartYAxisCrosshair, ChartYAxisCrosshairVue2, ChartYAxisCrosshairProps, ChartYAxisCrosshairTooltip, ChartYAxisCrosshairTooltipVue2, ChartYAxisCrosshairTooltipProps, ChartYAxisTitle, ChartYAxisTitleVue2, ChartYAxisTitleProps, ChartYAxisLabels, ChartYAxisLabelsVue2, ChartYAxisLabelsProps, ChartYAxisNotes, ChartYAxisNotesVue2, ChartYAxisNotesProps, ChartYAxisNotesIcon, ChartYAxisNotesIconVue2, ChartYAxisNotesIconProps, ChartYAxisNotesLabel, ChartYAxisNotesLabelVue2, ChartYAxisNotesLabelProps };

package/dist/esm/components/y-axis-item/main.js

@@ -0,0 +1,8 @@
+import { ChartYAxisCrosshair, ChartYAxisCrosshairVue2 } from './Crosshair.js';
+import { ChartYAxisCrosshairTooltip, ChartYAxisCrosshairTooltipVue2 } from './CrosshairTooltip.js';
+import { ChartYAxisLabels, ChartYAxisLabelsVue2 } from './Labels.js';
+import { ChartYAxisNotes, ChartYAxisNotesVue2 } from './Notes.js';
+import { ChartYAxisNotesIcon, ChartYAxisNotesIconVue2 } from './NotesIcon.js';
+import { ChartYAxisNotesLabel, ChartYAxisNotesLabelVue2 } from './NotesLabel.js';
+import { ChartYAxisTitle, ChartYAxisTitleVue2 } from './Title.js';
+export { ChartYAxisCrosshair, ChartYAxisCrosshairVue2, ChartYAxisCrosshairTooltip, ChartYAxisCrosshairTooltipVue2, ChartYAxisTitle, ChartYAxisTitleVue2, ChartYAxisLabels, ChartYAxisLabelsVue2, ChartYAxisNotes, ChartYAxisNotesVue2, ChartYAxisNotesIcon, ChartYAxisNotesIconVue2, ChartYAxisNotesLabel, ChartYAxisNotesLabelVue2 };

package/dist/esm/defaults.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/defaults.js

@@ -0,0 +1,15 @@
+import { DateCategoryAxis, DateValueAxis } from '@progress/kendo-charts';
+var dateCategoryAxisFormats = DateCategoryAxis.prototype.options.labels.dateFormats;
+var dateValueAxisFormats = DateValueAxis.prototype.options.labels.dateFormats;
+var dateFormats = {
+    milliseconds: 'HH:mm:ss.SSS',
+    seconds: { time: 'medium' },
+    minutes: { time: 'short' },
+    hours: { time: 'short' },
+    days: { skeleton: 'Md' },
+    weeks: { skeleton: 'Md' },
+    months: { skeleton: 'yyMMM' },
+    years: { skeleton: 'y' }
+};
+Object.assign(dateCategoryAxisFormats, dateFormats);
+Object.assign(dateValueAxisFormats, dateFormats);

package/dist/esm/events/axis-label-click-event.d.ts

@@ -0,0 +1,32 @@
+import { Charts } from '../common/charts';
+import { BaseEvent } from './base-event';
+import { EventAxisOptions } from '../api-types/event-axis-options.interface';
+/**
+ * Arguments for the `axisLabelClick` event.
+ */
+export declare class AxisLabelClickEvent extends BaseEvent {
+    /**
+     * The axis options to which the label belongs.
+     */
+    axis: EventAxisOptions;
+    /**
+     * The original data item that is used to generate the label. Available only for category axes which are populated from the `categoryField` of the series.
+     */
+    dataItem: any;
+    /**
+     * The label sequential or category index.
+     */
+    index: number;
+    /**
+     * The label text.
+     */
+    text: string;
+    /**
+     * The label value or category name.
+     */
+    value: any;
+    /**
+     * @hidden
+     */
+    constructor(e: any, target: Charts);
+}

package/dist/esm/events/axis-label-click-event.js

@@ -0,0 +1,38 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BaseEvent } from './base-event.js';
+/* eslint-disable max-line-length */
+/**
+ * Arguments for the `axisLabelClick` event.
+ */
+var AxisLabelClickEvent = /** @class */ (function (_super) {
+    __extends(AxisLabelClickEvent, _super);
+    /**
+     * @hidden
+     */
+    function AxisLabelClickEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.axis = e.axis;
+        _this.dataItem = e.dataItem;
+        _this.index = e.index;
+        _this.text = e.text;
+        _this.value = e.value;
+        return _this;
+    }
+    return AxisLabelClickEvent;
+}(BaseEvent));
+export { AxisLabelClickEvent };
+// tslint:enable:max-line-length

package/dist/esm/events/base-event.d.ts

@@ -0,0 +1,14 @@
+import { Charts } from '../common/charts';
+/**
+ * @hidden
+ */
+export declare abstract class BaseEvent {
+    /**
+     * The `Chart` component that triggered the event.
+     */
+    target: Charts;
+    /**
+     * @hidden
+     */
+    constructor(target: Charts);
+}

package/dist/esm/events/base-event.js

@@ -0,0 +1,13 @@
+/**
+ * @hidden
+ */
+var BaseEvent = /** @class */ (function () {
+    /**
+     * @hidden
+     */
+    function BaseEvent(target) {
+        this.target = target;
+    }
+    return BaseEvent;
+}());
+export { BaseEvent };

package/dist/esm/events/chart-event-builder.d.ts

@@ -0,0 +1,6 @@
+import { Charts } from './../common/charts';
+/**
+ * @hidden
+ */
+declare function create(name: string, args: any, sender: Charts): any;
+export { create };

package/dist/esm/events/chart-event-builder.js

@@ -0,0 +1,53 @@
+import { AxisLabelClickEvent } from './axis-label-click-event.js';
+import { DragEvent } from './drag-event.js';
+import { DragEndEvent } from './drag-end-event.js';
+import { DragStartEvent } from './drag-start-event.js';
+import { LegendItemHoverEvent } from './legend-item-hover-event.js';
+import { LegendItemClickEvent } from './legend-item-click-event.js';
+import { LegendItemLeaveEvent } from './legend-item-leave-event.js';
+import { NavigatorFilterEvent } from './navigator-filter-event.js';
+import { NoteClickEvent } from './note-click-event.js';
+import { NoteHoverEvent } from './note-hover-event.js';
+import { PlotAreaClickEvent } from './plot-area-click-event.js';
+import { PlotAreaHoverEvent } from './plot-area-hover-event.js';
+import { RenderEvent } from './render-event.js';
+import { SelectEvent } from './select-event.js';
+import { SelectEndEvent } from './select-end-event.js';
+import { SelectStartEvent } from './select-start-event.js';
+import { SeriesClickEvent } from './series-click-event.js';
+import { SeriesHoverEvent } from './series-hover-event.js';
+import { ZoomEvent } from './zoom-event.js';
+import { ZoomEndEvent } from './zoom-end-event.js';
+import { ZoomStartEvent } from './zoom-start-event.js';
+var EVENT_MAP = {
+    axisLabelClick: AxisLabelClickEvent,
+    drag: DragEvent,
+    dragEnd: DragEndEvent,
+    dragStart: DragStartEvent,
+    legendItemHover: LegendItemHoverEvent,
+    legendItemClick: LegendItemClickEvent,
+    legendItemLeave: LegendItemLeaveEvent,
+    navigatorFilter: NavigatorFilterEvent,
+    noteClick: NoteClickEvent,
+    noteHover: NoteHoverEvent,
+    plotAreaClick: PlotAreaClickEvent,
+    plotAreaHover: PlotAreaHoverEvent,
+    render: RenderEvent,
+    select: SelectEvent,
+    selectEnd: SelectEndEvent,
+    selectStart: SelectStartEvent,
+    seriesClick: SeriesClickEvent,
+    seriesHover: SeriesHoverEvent,
+    zoom: ZoomEvent,
+    zoomEnd: ZoomEndEvent,
+    zoomStart: ZoomStartEvent
+};
+/**
+ * @hidden
+ */
+function create(name, args, sender) {
+    if (EVENT_MAP[name]) {
+        return new EVENT_MAP[name](args, sender);
+    }
+}
+export { create };

package/dist/esm/events/dom-event.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @hidden
+ */
+export declare class DomEvent<T> {
+    /**
+     * The `Chart` component that triggered the event.
+     */
+    sender: any;
+    /**
+     * The event
+     */
+    event: T;
+    /**
+     * @hidden
+     */
+    constructor(sender: any, e: T);
+}
+declare function toDomEvent<T>(sender: any, e: T): DomEvent<T>;
+export { toDomEvent };

package/dist/esm/events/dom-event.js

@@ -0,0 +1,18 @@
+/**
+ * @hidden
+ */
+var DomEvent = /** @class */ (function () {
+    /**
+     * @hidden
+     */
+    function DomEvent(sender, e) {
+        this.sender = sender;
+        this.event = e;
+    }
+    return DomEvent;
+}());
+export { DomEvent };
+function toDomEvent(sender, e) {
+    return new DomEvent(sender, e);
+}
+export { toDomEvent };

package/dist/esm/events/dom-events-builder.d.ts

@@ -0,0 +1,7 @@
+import { DomEvents } from './dom-events';
+/**
+ * @hidden
+ */
+export declare class DomEventsBuilder {
+    static create(element: HTMLElement, events: any): DomEvents | undefined;
+}

package/dist/esm/events/dom-events-builder.js

@@ -0,0 +1,32 @@
+import { DomEvents } from './dom-events.js';
+var MISSING_HAMMER_MESSAGE = 'Hammerjs is not loaded.' +
+    'Solution: http://www.telerik.com/kendo-vue-ui/components/charts/troubleshooting/#toc-installation';
+/**
+ * @hidden
+ */
+var DomEventsBuilder = /** @class */ (function () {
+    function DomEventsBuilder() {
+    }
+    DomEventsBuilder.create = function (element, events) {
+        if (typeof window !== 'undefined') {
+            var HAMMER = window.Hammer;
+            if (!HAMMER) {
+                if (process.env.NODE_ENV !== 'production') {
+                    console.warn(MISSING_HAMMER_MESSAGE);
+                }
+                return;
+            }
+            var hammerInstance = new HAMMER(element, {
+                recognizers: [
+                    [HAMMER.Tap],
+                    [HAMMER.Pan],
+                    [HAMMER.Pinch],
+                    [HAMMER.Press, { time: 0 }]
+                ]
+            });
+            return new DomEvents(hammerInstance, events);
+        }
+    };
+    return DomEventsBuilder;
+}());
+export { DomEventsBuilder };

package/dist/esm/events/dom-events.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @hidden
+ */
+export declare class DomEvents {
+    private hammerInstance;
+    private eventHandlers;
+    private previous;
+    constructor(hammerInstance: any, events: any);
+    tap(e: any): void;
+    press(e: any): void;
+    panstart(e: any): void;
+    panmove(e: any): void;
+    panend(e: any): void;
+    pinchstart(e: any): void;
+    pinchmove(e: any): void;
+    pinchend(e: any): void;
+    trigger(name: string, e: any): any;
+    bind(events?: any): void;
+    unbind(): void;
+    destroy(): void;
+    toggleDrag(enable: boolean): void;
+    toggleZoom(enable: boolean): void;
+    private toggle;
+}

package/dist/esm/events/dom-events.js

@@ -0,0 +1,163 @@
+var getTouch = function (domEvent) {
+    return {
+        x: {
+            location: domEvent.pageX
+        },
+        y: {
+            location: domEvent.pageY
+        }
+    };
+};
+var eventArgs = function (e, previousArgs) {
+    var pointers = e.pointers;
+    var pointer = pointers[0];
+    var xLocation = pointer.pageX;
+    var yLocation = pointer.pageY;
+    var distance = 0;
+    if (pointers.length > 1) {
+        var pointer1 = pointers[0];
+        var pointer2 = pointers[1];
+        distance = Math.sqrt(Math.pow(pointer1.pageX - pointer2.pageX, 2) +
+            Math.pow(pointer1.pageY - pointer2.pageY, 2));
+    }
+    return {
+        distance: distance,
+        event: e.srcEvent,
+        preventDefault: function () {
+            e.preventDefault();
+        },
+        target: e.target,
+        touches: pointers.map(getTouch),
+        type: e.type,
+        x: {
+            delta: previousArgs ? xLocation - previousArgs.x.location : 0,
+            initialDelta: e.deltaX,
+            location: xLocation,
+            startLocation: xLocation - e.deltaX
+        },
+        y: {
+            delta: previousArgs ? yLocation - previousArgs.y.location : 0,
+            initialDelta: e.deltaY,
+            location: yLocation,
+            startLocation: yLocation - e.deltaY
+        }
+    };
+};
+function shouldBindGroup(groupNames, events) {
+    for (var idx = 0; idx < groupNames.length; idx++) {
+        if (events[groupNames[idx]]) {
+            return true;
+        }
+    }
+    return false;
+}
+var eventGroups = [{
+        end: 'panend',
+        move: 'panmove',
+        start: 'panstart'
+    }, {
+        gesturechange: 'pinchmove',
+        gestureend: 'pinchend',
+        gesturestart: 'pinchstart'
+    }, {
+        press: 'press'
+    }, {
+        tap: 'tap'
+    }];
+/**
+ * @hidden
+ */
+var DomEvents = /** @class */ (function () {
+    function DomEvents(hammerInstance, events) {
+        this.hammerInstance = hammerInstance;
+        this.eventHandlers = {};
+        this.tap = this.tap.bind(this);
+        this.press = this.press.bind(this);
+        this.panstart = this.panstart.bind(this);
+        this.panmove = this.panmove.bind(this);
+        this.panend = this.panend.bind(this);
+        this.pinchstart = this.pinchstart.bind(this);
+        this.pinchmove = this.pinchmove.bind(this);
+        this.pinchend = this.pinchend.bind(this);
+        if (events) {
+            this.bind(events);
+        }
+    }
+    DomEvents.prototype.tap = function (e) {
+        this.trigger('tap', e);
+    };
+    DomEvents.prototype.press = function (e) {
+        this.trigger('press', e);
+    };
+    DomEvents.prototype.panstart = function (e) {
+        delete this.previous;
+        this.previous = this.trigger('start', e);
+    };
+    DomEvents.prototype.panmove = function (e) {
+        this.previous = this.trigger('move', e);
+    };
+    DomEvents.prototype.panend = function (e) {
+        this.trigger('end', e);
+        delete this.previous;
+    };
+    DomEvents.prototype.pinchstart = function (e) {
+        this.trigger('gesturestart', e);
+    };
+    DomEvents.prototype.pinchmove = function (e) {
+        this.trigger('gesturechange', e);
+    };
+    DomEvents.prototype.pinchend = function (e) {
+        this.trigger('gestureend', e);
+    };
+    DomEvents.prototype.trigger = function (name, e) {
+        var args = eventArgs(e, this.previous);
+        if (this.eventHandlers[name]) {
+            this.eventHandlers[name](args);
+        }
+        return args;
+    };
+    DomEvents.prototype.bind = function (events) {
+        if (events === void 0) { events = {}; }
+        this.unbind();
+        this.eventHandlers = events;
+        for (var idx = 0; idx < eventGroups.length; idx++) {
+            var eventGroup = eventGroups[idx];
+            var groupNames = Object.keys(eventGroup);
+            if (shouldBindGroup(groupNames, events)) {
+                for (var nameIdx = 0; nameIdx < groupNames.length; nameIdx++) {
+                    var name_1 = eventGroup[groupNames[nameIdx]];
+                    this.hammerInstance.on(name_1, this[name_1]);
+                }
+            }
+        }
+    };
+    DomEvents.prototype.unbind = function () {
+        if (this.hammerInstance) {
+            this.hammerInstance.off();
+        }
+        this.eventHandlers = {};
+    };
+    DomEvents.prototype.destroy = function () {
+        if (this.hammerInstance) {
+            this.hammerInstance.destroy();
+            delete this.hammerInstance;
+        }
+        delete this.eventHandlers;
+    };
+    DomEvents.prototype.toggleDrag = function (enable) {
+        this.toggle('pan', enable);
+    };
+    DomEvents.prototype.toggleZoom = function (enable) {
+        this.toggle('pinch', enable);
+    };
+    DomEvents.prototype.toggle = function (recognizer, enable) {
+        if (this.hammerInstance) {
+            var instanceRecognizer = this.hammerInstance.get(recognizer);
+            instanceRecognizer.set({
+                enable: enable
+            });
+        }
+    };
+    return DomEvents;
+}());
+export { DomEvents };

package/dist/esm/events/drag-end-event.d.ts

@@ -0,0 +1,22 @@
+import { Charts } from '../common/charts';
+import { BaseEvent } from './base-event';
+import { AxisRange } from '../api-types/axis-range.interface';
+/**
+ * Arguments for the `dragEnd` event.
+ */
+export declare class DragEndEvent extends BaseEvent {
+    /**
+     * A dictionary which contains the range (min and max values) of named axes. The axis name is used as a key.
+     */
+    axisRanges: {
+        [name: string]: AxisRange;
+    };
+    /**
+     * The original user event that triggered the drag action.
+     */
+    nativeEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: any, target: Charts);
+}

package/dist/esm/events/drag-end-event.js

@@ -0,0 +1,35 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { BaseEvent } from './base-event.js';
+/* eslint-disable max-line-length */
+/**
+ * Arguments for the `dragEnd` event.
+ */
+var DragEndEvent = /** @class */ (function (_super) {
+    __extends(DragEndEvent, _super);
+    /**
+     * @hidden
+     */
+    function DragEndEvent(e, target) {
+        var _this = _super.call(this, target) || this;
+        _this.axisRanges = e.axisRanges;
+        _this.nativeEvent = e.originalEvent;
+        return _this;
+    }
+    return DragEndEvent;
+}(BaseEvent));
+export { DragEndEvent };
+// tslint:enable:max-line-length

package/dist/esm/events/drag-event.d.ts

@@ -0,0 +1,22 @@
+import { Charts } from '../common/charts';
+import { PreventableEvent } from './preventable-event';
+import { AxisRange } from '../api-types/axis-range.interface';
+/**
+ * Arguments for the `drag` event.
+ */
+export declare class DragEvent extends PreventableEvent {
+    /**
+     * A dictionary which contains the range (min and max values) of named axes. The axis name is used as a key.
+     */
+    axisRanges: {
+        [name: string]: AxisRange;
+    };
+    /**
+     * The original user event that triggered the drag action.
+     */
+    nativeEvent: any;
+    /**
+     * @hidden
+     */
+    constructor(e: any, target: Charts);
+}