charjs 4.4.6

package/dist/core/core.controller.d.ts

@@ -0,0 +1,257 @@
+export default Chart;
+export type ChartEvent = import('../types/index.js').ChartEvent;
+export type Point = import('../types/index.js').Point;
+declare class Chart {
+    static defaults: import("./core.defaults.js").Defaults;
+    static instances: {};
+    static overrides: any;
+    static registry: import("./core.registry.js").Registry;
+    static version: string;
+    static getChart: (key: any) => any;
+    static register(...items: any[]): void;
+    static unregister(...items: any[]): void;
+    constructor(item: any, userConfig: any);
+    config: Config;
+    platform: any;
+    id: number;
+    ctx: any;
+    canvas: any;
+    width: any;
+    height: any;
+    _options: any;
+    _aspectRatio: any;
+    _layers: any[];
+    _metasets: any[];
+    _stacks: any;
+    boxes: any[];
+    currentDevicePixelRatio: any;
+    chartArea: any;
+    _active: any[];
+    _lastEvent: import("../types/index.js").ChartEvent;
+    _listeners: {};
+    /** @type {?{attach?: function, detach?: function, resize?: function}} */
+    _responsiveListeners: {
+        attach?: Function;
+        detach?: Function;
+        resize?: Function;
+    };
+    _sortedMetasets: any[];
+    scales: {};
+    _plugins: PluginService;
+    $proxies: {};
+    _hiddenIndices: {};
+    attached: boolean;
+    _animationsDisabled: boolean;
+    $context: {
+        chart: Chart;
+        type: string;
+    };
+    _doResize: (mode?: any) => number;
+    _dataChanges: any[];
+    get aspectRatio(): any;
+    set data(arg: any);
+    get data(): any;
+    set options(arg: any);
+    get options(): any;
+    get registry(): import("./core.registry.js").Registry;
+    /**
+       * @private
+       */
+    private _initialize;
+    clear(): Chart;
+    stop(): Chart;
+    /**
+       * Resize the chart to its container or to explicit dimensions.
+       * @param {number} [width]
+       * @param {number} [height]
+       */
+    resize(width?: number, height?: number): void;
+    _resizeBeforeDraw: {
+        width: number;
+        height: number;
+    };
+    _resize(width: any, height: any): void;
+    ensureScalesHaveIDs(): void;
+    /**
+       * Builds a map of scale ID to scale object for future lookup.
+       */
+    buildOrUpdateScales(): void;
+    /**
+       * @private
+       */
+    private _updateMetasets;
+    /**
+       * @private
+       */
+    private _removeUnreferencedMetasets;
+    buildOrUpdateControllers(): any[];
+    /**
+       * Reset the elements of all datasets
+       * @private
+       */
+    private _resetElements;
+    /**
+      * Resets the chart back to its state before the initial animation
+      */
+    reset(): void;
+    update(mode: any): void;
+    _minPadding: number;
+    /**
+     * @private
+     */
+    private _updateScales;
+    /**
+     * @private
+     */
+    private _checkEventBindings;
+    /**
+     * @private
+     */
+    private _updateHiddenIndices;
+    /**
+     * @private
+     */
+    private _getUniformDataChanges;
+    /**
+       * Updates the chart layout unless a plugin returns `false` to the `beforeLayout`
+       * hook, in which case, plugins will not be called on `afterLayout`.
+       * @private
+       */
+    private _updateLayout;
+    /**
+       * Updates all datasets unless a plugin returns `false` to the `beforeDatasetsUpdate`
+       * hook, in which case, plugins will not be called on `afterDatasetsUpdate`.
+       * @private
+       */
+    private _updateDatasets;
+    /**
+       * Updates dataset at index unless a plugin returns `false` to the `beforeDatasetUpdate`
+       * hook, in which case, plugins will not be called on `afterDatasetUpdate`.
+       * @private
+       */
+    private _updateDataset;
+    render(): void;
+    draw(): void;
+    /**
+       * @private
+       */
+    private _getSortedDatasetMetas;
+    /**
+       * Gets the visible dataset metas in drawing order
+       * @return {object[]}
+       */
+    getSortedVisibleDatasetMetas(): object[];
+    /**
+       * Draws all datasets unless a plugin returns `false` to the `beforeDatasetsDraw`
+       * hook, in which case, plugins will not be called on `afterDatasetsDraw`.
+       * @private
+       */
+    private _drawDatasets;
+    /**
+       * Draws dataset at index unless a plugin returns `false` to the `beforeDatasetDraw`
+       * hook, in which case, plugins will not be called on `afterDatasetDraw`.
+       * @private
+       */
+    private _drawDataset;
+    /**
+     * Checks whether the given point is in the chart area.
+     * @param {Point} point - in relative coordinates (see, e.g., getRelativePosition)
+     * @returns {boolean}
+     */
+    isPointInArea(point: Point): boolean;
+    getElementsAtEventForMode(e: any, mode: any, options: any, useFinalPosition: any): any;
+    getDatasetMeta(datasetIndex: any): any;
+    getContext(): {
+        chart: Chart;
+        type: string;
+    };
+    getVisibleDatasetCount(): number;
+    isDatasetVisible(datasetIndex: any): boolean;
+    setDatasetVisibility(datasetIndex: any, visible: any): void;
+    toggleDataVisibility(index: any): void;
+    getDataVisibility(index: any): boolean;
+    /**
+       * @private
+       */
+    private _updateVisibility;
+    hide(datasetIndex: any, dataIndex: any): void;
+    show(datasetIndex: any, dataIndex: any): void;
+    /**
+       * @private
+       */
+    private _destroyDatasetMeta;
+    _stop(): void;
+    destroy(): void;
+    toBase64Image(...args: any[]): any;
+    /**
+       * @private
+       */
+    private bindEvents;
+    /**
+     * @private
+     */
+    private bindUserEvents;
+    /**
+     * @private
+     */
+    private bindResponsiveEvents;
+    /**
+       * @private
+       */
+    private unbindEvents;
+    updateHoverStyle(items: any, mode: any, enabled: any): void;
+    /**
+       * Get active (hovered) elements
+       * @returns array
+       */
+    getActiveElements(): any[];
+    /**
+       * Set active (hovered) elements
+       * @param {array} activeElements New active data points
+       */
+    setActiveElements(activeElements: any[]): void;
+    /**
+       * Calls enabled plugins on the specified hook and with the given args.
+       * This method immediately returns as soon as a plugin explicitly returns false. The
+       * returned value can be used, for instance, to interrupt the current action.
+       * @param {string} hook - The name of the plugin method to call (e.g. 'beforeUpdate').
+       * @param {Object} [args] - Extra arguments to apply to the hook call.
+     * @param {import('./core.plugins.js').filterCallback} [filter] - Filtering function for limiting which plugins are notified
+       * @returns {boolean} false if any of the plugins return false, else returns true.
+       */
+    notifyPlugins(hook: string, args?: any, filter?: import('./core.plugins.js').filterCallback): boolean;
+    /**
+     * Check if a plugin with the specific ID is registered and enabled
+     * @param {string} pluginId - The ID of the plugin of which to check if it is enabled
+     * @returns {boolean}
+     */
+    isPluginEnabled(pluginId: string): boolean;
+    /**
+       * @private
+       */
+    private _updateHoverStyles;
+    /**
+       * @private
+       */
+    private _eventHandler;
+    /**
+       * Handle an event
+       * @param {ChartEvent} e the event to handle
+       * @param {boolean} [replay] - true if the event was replayed by `update`
+     * @param {boolean} [inChartArea] - true if the event is inside chartArea
+       * @return {boolean} true if the chart needs to re-render
+       * @private
+       */
+    private _handleEvent;
+    /**
+     * @param {ChartEvent} e - The event
+     * @param {import('../types/index.js').ActiveElement[]} lastActive - Previously active elements
+     * @param {boolean} inChartArea - Is the event inside chartArea
+     * @param {boolean} useFinalPosition - Should the evaluation be done with current or final (after animation) element positions
+     * @returns {import('../types/index.js').ActiveElement[]} - The active elements
+     * @pravate
+     */
+    _getActiveElements(e: ChartEvent, lastActive: import('../types/index.js').ActiveElement[], inChartArea: boolean, useFinalPosition: boolean): import('../types/index.js').ActiveElement[];
+}
+import Config from "./core.config.js";
+import PluginService from "./core.plugins.js";

package/dist/core/core.datasetController.d.ts

@@ -0,0 +1,251 @@
+export default class DatasetController {
+    /**
+     * @type {any}
+     */
+    static defaults: any;
+    /**
+     * Element type used to generate a meta dataset (e.g. Chart.element.LineElement).
+     */
+    static datasetElementType: any;
+    /**
+     * Element type used to generate a meta data (e.g. Chart.element.PointElement).
+     */
+    static dataElementType: any;
+    /**
+       * @param {Chart} chart
+       * @param {number} datasetIndex
+       */
+    constructor(chart: Chart, datasetIndex: number);
+    chart: import("./core.controller.js").default;
+    _ctx: any;
+    index: number;
+    _cachedDataOpts: {};
+    _cachedMeta: any;
+    _type: any;
+    options: any;
+    /** @type {boolean | object} */
+    _parsing: boolean | object;
+    _data: any;
+    _objectData: any;
+    _sharedOptions: any;
+    _drawStart: any;
+    _drawCount: any;
+    enableOptionSharing: boolean;
+    supportsDecimation: boolean;
+    $context: any;
+    _syncList: any[];
+    datasetElementType: any;
+    dataElementType: any;
+    initialize(): void;
+    updateIndex(datasetIndex: any): void;
+    linkScales(): void;
+    getDataset(): any;
+    getMeta(): any;
+    /**
+       * @param {string} scaleID
+       * @return {Scale}
+       */
+    getScaleForId(scaleID: string): Scale;
+    /**
+       * @private
+       */
+    private _getOtherScale;
+    reset(): void;
+    /**
+       * @private
+       */
+    private _destroy;
+    /**
+       * @private
+       */
+    private _dataCheck;
+    addElements(): void;
+    buildOrUpdateElements(resetNewElements: any): void;
+    /**
+       * Merges user-supplied and default dataset-level options
+       * @private
+       */
+    private configure;
+    /**
+       * @param {number} start
+       * @param {number} count
+       */
+    parse(start: number, count: number): void;
+    /**
+       * Parse array of primitive values
+       * @param {object} meta - dataset meta
+       * @param {array} data - data array. Example [1,3,4]
+       * @param {number} start - start index
+       * @param {number} count - number of items to parse
+       * @returns {object} parsed item - item containing index and a parsed value
+       * for each scale id.
+       * Example: {xScale0: 0, yScale0: 1}
+       * @protected
+       */
+    protected parsePrimitiveData(meta: object, data: any[], start: number, count: number): object;
+    /**
+       * Parse array of arrays
+       * @param {object} meta - dataset meta
+       * @param {array} data - data array. Example [[1,2],[3,4]]
+       * @param {number} start - start index
+       * @param {number} count - number of items to parse
+       * @returns {object} parsed item - item containing index and a parsed value
+       * for each scale id.
+       * Example: {x: 0, y: 1}
+       * @protected
+       */
+    protected parseArrayData(meta: object, data: any[], start: number, count: number): object;
+    /**
+       * Parse array of objects
+       * @param {object} meta - dataset meta
+       * @param {array} data - data array. Example [{x:1, y:5}, {x:2, y:10}]
+       * @param {number} start - start index
+       * @param {number} count - number of items to parse
+       * @returns {object} parsed item - item containing index and a parsed value
+       * for each scale id. _custom is optional
+       * Example: {xScale0: 0, yScale0: 1, _custom: {r: 10, foo: 'bar'}}
+       * @protected
+       */
+    protected parseObjectData(meta: object, data: any[], start: number, count: number): object;
+    /**
+       * @protected
+       */
+    protected getParsed(index: any): any;
+    /**
+       * @protected
+       */
+    protected getDataElement(index: any): any;
+    /**
+       * @protected
+       */
+    protected applyStack(scale: any, parsed: any, mode: any): any;
+    /**
+       * @protected
+       */
+    protected updateRangeFromParsed(range: any, scale: any, parsed: any, stack: any): void;
+    /**
+       * @protected
+       */
+    protected getMinMax(scale: any, canStack: any): {
+        min: number;
+        max: number;
+    };
+    getAllParsedValues(scale: any): number[];
+    /**
+       * @return {number|boolean}
+       * @protected
+       */
+    protected getMaxOverflow(): number | boolean;
+    /**
+       * @protected
+       */
+    protected getLabelAndValue(index: any): {
+        label: string;
+        value: string;
+    };
+    /**
+       * @private
+       */
+    private _update;
+    /**
+       * @param {string} mode
+       */
+    update(mode: string): void;
+    draw(): void;
+    /**
+       * Returns a set of predefined style properties that should be used to represent the dataset
+       * or the data if the index is specified
+       * @param {number} index - data index
+       * @param {boolean} [active] - true if hover
+       * @return {object} style object
+       */
+    getStyle(index: number, active?: boolean): object;
+    /**
+       * @protected
+       */
+    protected getContext(index: any, active: any, mode: any): any;
+    /**
+       * @param {string} [mode]
+       * @protected
+       */
+    protected resolveDatasetElementOptions(mode?: string): any;
+    /**
+       * @param {number} index
+       * @param {string} [mode]
+       * @protected
+       */
+    protected resolveDataElementOptions(index: number, mode?: string): any;
+    /**
+       * @private
+       */
+    private _resolveElementOptions;
+    /**
+       * @private
+       */
+    private _resolveAnimations;
+    /**
+       * Utility for getting the options object shared between elements
+       * @protected
+       */
+    protected getSharedOptions(options: any): any;
+    /**
+       * Utility for determining if `options` should be included in the updated properties
+       * @protected
+       */
+    protected includeOptions(mode: any, sharedOptions: any): boolean;
+    /**
+     * @todo v4, rename to getSharedOptions and remove excess functions
+     */
+    _getSharedOptions(start: any, mode: any): {
+        sharedOptions: any;
+        includeOptions: boolean;
+    };
+    /**
+       * Utility for updating an element with new properties, using animations when appropriate.
+       * @protected
+       */
+    protected updateElement(element: any, index: any, properties: any, mode: any): void;
+    /**
+       * Utility to animate the shared options, that are potentially affecting multiple elements.
+       * @protected
+       */
+    protected updateSharedOptions(sharedOptions: any, mode: any, newOptions: any): void;
+    /**
+       * @private
+       */
+    private _setStyle;
+    removeHoverStyle(element: any, datasetIndex: any, index: any): void;
+    setHoverStyle(element: any, datasetIndex: any, index: any): void;
+    /**
+       * @private
+       */
+    private _removeDatasetHoverStyle;
+    /**
+       * @private
+       */
+    private _setDatasetHoverStyle;
+    /**
+       * @private
+       */
+    private _resyncElements;
+    /**
+       * @private
+       */
+    private _insertElements;
+    updateElements(element: any, start: any, count: any, mode: any): void;
+    /**
+       * @private
+       */
+    private _removeElements;
+    /**
+       * @private
+     */
+    private _sync;
+    _onDataPush(...args: any[]): void;
+    _onDataPop(): void;
+    _onDataShift(): void;
+    _onDataSplice(start: any, count: any, ...args: any[]): void;
+    _onDataUnshift(...args: any[]): void;
+}
+export type Chart = import('./core.controller.js').default;
+export type Scale = import('./core.scale.js').default;

package/dist/core/core.defaults.d.ts

@@ -0,0 +1,80 @@
+export const overrides: any;
+export const descriptors: any;
+/**
+ * Please use the module's default export which provides a singleton instance
+ * Note: class is exported for typedoc
+ */
+export class Defaults {
+    constructor(_descriptors: any, _appliers: any);
+    animation: any;
+    backgroundColor: string;
+    borderColor: string;
+    color: string;
+    datasets: {};
+    devicePixelRatio: (context: any) => any;
+    elements: {};
+    events: string[];
+    font: {
+        family: string;
+        size: number;
+        style: string;
+        lineHeight: number;
+        weight: any;
+    };
+    hover: {};
+    hoverBackgroundColor: (ctx: any, options: any) => CanvasGradient;
+    hoverBorderColor: (ctx: any, options: any) => CanvasGradient;
+    hoverColor: (ctx: any, options: any) => CanvasGradient;
+    indexAxis: string;
+    interaction: {
+        mode: string;
+        intersect: boolean;
+        includeInvisible: boolean;
+    };
+    maintainAspectRatio: boolean;
+    onHover: any;
+    onClick: any;
+    parsing: boolean;
+    plugins: {};
+    responsive: boolean;
+    scale: any;
+    scales: {};
+    showLine: boolean;
+    drawActiveElementsOnTop: boolean;
+    /**
+       * @param {string|object} scope
+       * @param {object} [values]
+       */
+    set(scope: string | object, values?: object): any;
+    /**
+       * @param {string} scope
+       */
+    get(scope: string): any;
+    /**
+       * @param {string|object} scope
+       * @param {object} [values]
+       */
+    describe(scope: string | object, values?: object): any;
+    override(scope: any, values: any): any;
+    /**
+       * Routes the named defaults to fallback to another scope/name.
+       * This routing is useful when those target values, like defaults.color, are changed runtime.
+       * If the values would be copied, the runtime change would not take effect. By routing, the
+       * fallback is evaluated at each access, so its always up to date.
+       *
+       * Example:
+       *
+       * 	defaults.route('elements.arc', 'backgroundColor', '', 'color')
+       *   - reads the backgroundColor from defaults.color when undefined locally
+       *
+       * @param {string} scope Scope this route applies to.
+       * @param {string} name Property name that should be routed to different namespace when not defined here.
+       * @param {string} targetScope The namespace where those properties should be routed to.
+       * Empty string ('') is the root of defaults.
+       * @param {string} targetName The target name in the target scope the property should be routed to.
+       */
+    route(scope: string, name: string, targetScope: string, targetName: string): void;
+    apply(appliers: any): void;
+}
+declare const _default: Defaults;
+export default _default;

package/dist/core/core.element.d.ts

@@ -0,0 +1,21 @@
+import type { AnyObject } from '../types/basic.js';
+import type { Point } from '../types/geometric.js';
+import type { Animation } from '../types/animation.js';
+export default class Element<T = AnyObject, O = AnyObject> {
+    static defaults: {};
+    static defaultRoutes: any;
+    x: number;
+    y: number;
+    active: boolean;
+    options: O;
+    $animations: Record<keyof T, Animation>;
+    tooltipPosition(useFinalPosition: boolean): Point;
+    hasValue(): boolean;
+    /**
+     * Gets the current or final value of each prop. Can return extra properties (whole object).
+     * @param props - properties to get
+     * @param [final] - get the final value (animation target)
+     */
+    getProps<P extends (keyof T)[]>(props: P, final?: boolean): Pick<T, P[number]>;
+    getProps<P extends string>(props: P[], final?: boolean): Partial<Record<P, unknown>>;
+}

package/dist/core/core.interaction.d.ts

@@ -0,0 +1,92 @@
+declare namespace _default {
+    export { evaluateInteractionItems };
+    export namespace modes {
+        /**
+             * Returns items at the same index. If the options.intersect parameter is true, we only return items if we intersect something
+             * If the options.intersect mode is false, we find the nearest item and return the items at the same index as that item
+             * @function Chart.Interaction.modes.index
+             * @since v2.4.0
+             * @param {Chart} chart - the chart we are returning items from
+             * @param {Event} e - the event we are find things at
+             * @param {InteractionOptions} options - options to use
+             * @param {boolean} [useFinalPosition] - use final element position (animation target)
+             * @return {InteractionItem[]} - items that are found
+             */
+        function index(chart: import("./core.controller.js").default, e: Event, options: InteractionOptions, useFinalPosition?: boolean): InteractionItem[];
+        /**
+             * Returns items in the same dataset. If the options.intersect parameter is true, we only return items if we intersect something
+             * If the options.intersect is false, we find the nearest item and return the items in that dataset
+             * @function Chart.Interaction.modes.dataset
+             * @param {Chart} chart - the chart we are returning items from
+             * @param {Event} e - the event we are find things at
+             * @param {InteractionOptions} options - options to use
+             * @param {boolean} [useFinalPosition] - use final element position (animation target)
+             * @return {InteractionItem[]} - items that are found
+             */
+        function dataset(chart: import("./core.controller.js").default, e: Event, options: InteractionOptions, useFinalPosition?: boolean): InteractionItem[];
+        /**
+             * Point mode returns all elements that hit test based on the event position
+             * of the event
+             * @function Chart.Interaction.modes.intersect
+             * @param {Chart} chart - the chart we are returning items from
+             * @param {Event} e - the event we are find things at
+             * @param {InteractionOptions} options - options to use
+             * @param {boolean} [useFinalPosition] - use final element position (animation target)
+             * @return {InteractionItem[]} - items that are found
+             */
+        function point(chart: import("./core.controller.js").default, e: Event, options: InteractionOptions, useFinalPosition?: boolean): InteractionItem[];
+        /**
+             * nearest mode returns the element closest to the point
+             * @function Chart.Interaction.modes.intersect
+             * @param {Chart} chart - the chart we are returning items from
+             * @param {Event} e - the event we are find things at
+             * @param {InteractionOptions} options - options to use
+             * @param {boolean} [useFinalPosition] - use final element position (animation target)
+             * @return {InteractionItem[]} - items that are found
+             */
+        function nearest(chart: import("./core.controller.js").default, e: Event, options: InteractionOptions, useFinalPosition?: boolean): InteractionItem[];
+        /**
+             * x mode returns the elements that hit-test at the current x coordinate
+             * @function Chart.Interaction.modes.x
+             * @param {Chart} chart - the chart we are returning items from
+             * @param {Event} e - the event we are find things at
+             * @param {InteractionOptions} options - options to use
+             * @param {boolean} [useFinalPosition] - use final element position (animation target)
+             * @return {InteractionItem[]} - items that are found
+             */
+        function x(chart: import("./core.controller.js").default, e: Event, options: InteractionOptions, useFinalPosition?: boolean): InteractionItem[];
+        /**
+             * y mode returns the elements that hit-test at the current y coordinate
+             * @function Chart.Interaction.modes.y
+             * @param {Chart} chart - the chart we are returning items from
+             * @param {Event} e - the event we are find things at
+             * @param {InteractionOptions} options - options to use
+             * @param {boolean} [useFinalPosition] - use final element position (animation target)
+             * @return {InteractionItem[]} - items that are found
+             */
+        function y(chart: import("./core.controller.js").default, e: Event, options: InteractionOptions, useFinalPosition?: boolean): InteractionItem[];
+    }
+}
+export default _default;
+export type Chart = import('./core.controller.js').default;
+export type ChartEvent = import('../types/index.js').ChartEvent;
+export type InteractionOptions = {
+    axis?: string;
+    intersect?: boolean;
+    includeInvisible?: boolean;
+};
+export type InteractionItem = {
+    datasetIndex: number;
+    index: number;
+    element: import('./core.element.js').default;
+};
+export type Point = import('../types/index.js').Point;
+/**
+ * Helper function to select candidate elements for interaction
+ * @param {Chart} chart - the chart
+ * @param {string} axis - the axis mode. x|y|xy|r
+ * @param {Point} position - the point to be nearest to, in relative coordinates
+ * @param {function} handler - the callback to execute for each visible item
+ * @param {boolean} [intersect] - consider intersecting items
+ */
+declare function evaluateInteractionItems(chart: Chart, axis: string, position: Point, handler: Function, intersect?: boolean): void;