charjs 4.4.6

package/dist/core/core.layouts.d.ts

@@ -0,0 +1,88 @@
+declare namespace _default {
+    /**
+       * Register a box to a chart.
+       * A box is simply a reference to an object that requires layout. eg. Scales, Legend, Title.
+       * @param {Chart} chart - the chart to use
+       * @param {LayoutItem} item - the item to add to be laid out
+       */
+    function addBox(chart: import("./core.controller.js").default, item: LayoutItem): void;
+    /**
+       * Remove a layoutItem from a chart
+       * @param {Chart} chart - the chart to remove the box from
+       * @param {LayoutItem} layoutItem - the item to remove from the layout
+       */
+    function removeBox(chart: import("./core.controller.js").default, layoutItem: LayoutItem): void;
+    /**
+       * Sets (or updates) options on the given `item`.
+       * @param {Chart} chart - the chart in which the item lives (or will be added to)
+       * @param {LayoutItem} item - the item to configure with the given options
+       * @param {object} options - the new item options.
+       */
+    function configure(chart: import("./core.controller.js").default, item: LayoutItem, options: any): void;
+    /**
+       * Fits boxes of the given chart into the given size by having each box measure itself
+       * then running a fitting algorithm
+       * @param {Chart} chart - the chart
+       * @param {number} width - the width to fit into
+       * @param {number} height - the height to fit into
+     * @param {number} minPadding - minimum padding required for each side of chart area
+       */
+    function update(chart: import("./core.controller.js").default, width: number, height: number, minPadding: number): void;
+}
+export default _default;
+export type Chart = import('./core.controller.js').default;
+export type LayoutItem = {
+    /**
+     * - The position of the item in the chart layout. Possible values are
+     * 'left', 'top', 'right', 'bottom', and 'chartArea'
+     */
+    position: string;
+    /**
+     * - The weight used to sort the item. Higher weights are further away from the chart area
+     */
+    weight: number;
+    /**
+     * - if true, and the item is horizontal, then push vertical boxes down
+     */
+    fullSize: boolean;
+    /**
+     * - returns true if the layout item is horizontal (ie. top or bottom)
+     */
+    isHorizontal: Function;
+    /**
+     * - Takes two parameters: width and height. Returns size of item
+     */
+    update: Function;
+    /**
+     * - Draws the element
+     */
+    draw: Function;
+    /**
+     * -  Returns an object with padding on the edges
+     */
+    getPadding?: Function;
+    /**
+     * - Width of item. Must be valid after update()
+     */
+    width: number;
+    /**
+     * - Height of item. Must be valid after update()
+     */
+    height: number;
+    /**
+     * - Left edge of the item. Set by layout system and cannot be used in update
+     */
+    left: number;
+    /**
+     * - Top edge of the item. Set by layout system and cannot be used in update
+     */
+    top: number;
+    /**
+     * - Right edge of the item. Set by layout system and cannot be used in update
+     */
+    right: number;
+    /**
+     * - Bottom edge of the item. Set by layout system and cannot be used in update
+     */
+    bottom: number;
+};

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

@@ -0,0 +1 @@
+export function applyLayoutsDefaults(defaults: any): void;

package/dist/core/core.plugins.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @typedef { import('./core.controller.js').default } Chart
+ * @typedef { import('../types/index.js').ChartEvent } ChartEvent
+ * @typedef { import('../plugins/plugin.tooltip.js').default } Tooltip
+ */
+/**
+ * @callback filterCallback
+ * @param {{plugin: object, options: object}} value
+ * @param {number} [index]
+ * @param {array} [array]
+ * @param {object} [thisArg]
+ * @return {boolean}
+ */
+export default class PluginService {
+    _init: any[];
+    /**
+       * Calls enabled plugins for `chart` 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 {Chart} chart - The chart instance for which plugins should be called.
+       * @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 {filterCallback} [filter] - Filtering function for limiting which plugins are notified
+       * @returns {boolean} false if any of the plugins return false, else returns true.
+       */
+    notify(chart: Chart, hook: string, args?: object, filter?: filterCallback): boolean;
+    /**
+       * @private
+       */
+    private _notify;
+    invalidate(): void;
+    _oldCache: {
+        plugin: any;
+        options: any;
+    }[];
+    _cache: {
+        plugin: any;
+        options: any;
+    }[];
+    /**
+       * @param {Chart} chart
+       * @private
+       */
+    private _descriptors;
+    _createDescriptors(chart: any, all: any): {
+        plugin: any;
+        options: any;
+    }[];
+    /**
+       * @param {Chart} chart
+       * @private
+       */
+    private _notifyStateChanges;
+}
+export type Chart = import('./core.controller.js').default;
+export type ChartEvent = import('../types/index.js').ChartEvent;
+export type Tooltip = any;
+export type filterCallback = (value: {
+    plugin: object;
+    options: object;
+}, index?: number, array?: any[], thisArg?: object) => boolean;

package/dist/core/core.registry.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Please use the module's default export which provides a singleton instance
+ * Note: class is exported for typedoc
+ */
+export class Registry {
+    controllers: TypedRegistry;
+    elements: TypedRegistry;
+    plugins: TypedRegistry;
+    scales: TypedRegistry;
+    _typedRegistries: TypedRegistry[];
+    /**
+       * @param  {...any} args
+       */
+    add(...args: any[]): void;
+    remove(...args: any[]): void;
+    /**
+       * @param  {...typeof DatasetController} args
+       */
+    addControllers(...args: (typeof DatasetController)[]): void;
+    /**
+       * @param  {...typeof Element} args
+       */
+    addElements(...args: (typeof Element)[]): void;
+    /**
+       * @param  {...any} args
+       */
+    addPlugins(...args: any[]): void;
+    /**
+       * @param  {...typeof Scale} args
+       */
+    addScales(...args: (typeof Scale)[]): void;
+    /**
+       * @param {string} id
+       * @returns {typeof DatasetController}
+       */
+    getController(id: string): typeof DatasetController;
+    /**
+       * @param {string} id
+       * @returns {typeof Element}
+       */
+    getElement(id: string): typeof Element;
+    /**
+       * @param {string} id
+       * @returns {object}
+       */
+    getPlugin(id: string): object;
+    /**
+       * @param {string} id
+       * @returns {typeof Scale}
+       */
+    getScale(id: string): typeof Scale;
+    /**
+       * @param  {...typeof DatasetController} args
+       */
+    removeControllers(...args: (typeof DatasetController)[]): void;
+    /**
+       * @param  {...typeof Element} args
+       */
+    removeElements(...args: (typeof Element)[]): void;
+    /**
+       * @param  {...any} args
+       */
+    removePlugins(...args: any[]): void;
+    /**
+       * @param  {...typeof Scale} args
+       */
+    removeScales(...args: (typeof Scale)[]): void;
+    /**
+       * @private
+       */
+    private _each;
+    /**
+       * @private
+       */
+    private _exec;
+    /**
+       * @private
+       */
+    private _getRegistryForType;
+    /**
+       * @private
+       */
+    private _get;
+}
+declare const _default: Registry;
+export default _default;
+import TypedRegistry from "./core.typedRegistry.js";
+import DatasetController from "./core.datasetController.js";
+import Element from "./core.element.js";
+import Scale from "./core.scale.js";

package/dist/core/core.scale.autoskip.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @typedef { import('./core.controller.js').default } Chart
+ * @typedef {{value:number | string, label?:string, major?:boolean, $context?:any}} Tick
+ */
+/**
+ * Returns a subset of ticks to be plotted to avoid overlapping labels.
+ * @param {import('./core.scale.js').default} scale
+ * @param {Tick[]} ticks
+ * @return {Tick[]}
+ * @private
+ */
+export function autoSkip(scale: import('./core.scale.js').default, ticks: Tick[]): Tick[];
+export type Chart = import('./core.controller.js').default;
+export type Tick = {
+    value: number | string;
+    label?: string;
+    major?: boolean;
+    $context?: any;
+};

package/dist/core/core.scale.d.ts

@@ -0,0 +1,343 @@
+export default class Scale extends Element<import("../types/basic.js").AnyObject, import("../types/basic.js").AnyObject> {
+    constructor(cfg: any);
+    /** @type {string} */
+    id: string;
+    /** @type {string} */
+    type: string;
+    /** @type {any} */
+    options: any;
+    /** @type {CanvasRenderingContext2D} */
+    ctx: CanvasRenderingContext2D;
+    /** @type {Chart} */
+    chart: Chart;
+    /** @type {number} */
+    top: number;
+    /** @type {number} */
+    bottom: number;
+    /** @type {number} */
+    left: number;
+    /** @type {number} */
+    right: number;
+    /** @type {number} */
+    width: number;
+    /** @type {number} */
+    height: number;
+    _margins: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    /** @type {number} */
+    maxWidth: number;
+    /** @type {number} */
+    maxHeight: number;
+    /** @type {number} */
+    paddingTop: number;
+    /** @type {number} */
+    paddingBottom: number;
+    /** @type {number} */
+    paddingLeft: number;
+    /** @type {number} */
+    paddingRight: number;
+    /** @type {string=} */
+    axis: string | undefined;
+    /** @type {number=} */
+    labelRotation: number | undefined;
+    min: any;
+    max: any;
+    _range: {
+        min: number;
+        max: number;
+    };
+    /** @type {Tick[]} */
+    ticks: Tick[];
+    /** @type {object[]|null} */
+    _gridLineItems: object[] | null;
+    /** @type {object[]|null} */
+    _labelItems: object[] | null;
+    /** @type {object|null} */
+    _labelSizes: object | null;
+    _length: number;
+    _maxLength: number;
+    _longestTextCache: {};
+    /** @type {number} */
+    _startPixel: number;
+    /** @type {number} */
+    _endPixel: number;
+    _reversePixels: boolean;
+    _userMax: any;
+    _userMin: any;
+    _suggestedMax: any;
+    _suggestedMin: any;
+    _ticksLength: number;
+    _borderValue: number;
+    _cache: {};
+    _dataLimitsCached: boolean;
+    $context: any;
+    /**
+       * @param {any} options
+       * @since 3.0
+       */
+    init(options: any): void;
+    /**
+       * Parse a supported input value to internal representation.
+       * @param {*} raw
+       * @param {number} [index]
+       * @since 3.0
+       */
+    parse(raw: any, index?: number): any;
+    /**
+       * @return {{min: number, max: number, minDefined: boolean, maxDefined: boolean}}
+       * @protected
+       * @since 3.0
+       */
+    protected getUserBounds(): {
+        min: number;
+        max: number;
+        minDefined: boolean;
+        maxDefined: boolean;
+    };
+    /**
+       * @param {boolean} canStack
+       * @return {{min: number, max: number}}
+       * @protected
+       * @since 3.0
+       */
+    protected getMinMax(canStack: boolean): {
+        min: number;
+        max: number;
+    };
+    /**
+       * Get the padding needed for the scale
+       * @return {{top: number, left: number, bottom: number, right: number}} the necessary padding
+       * @private
+       */
+    private getPadding;
+    /**
+       * Returns the scale tick objects
+       * @return {Tick[]}
+       * @since 2.7
+       */
+    getTicks(): Tick[];
+    /**
+       * @return {string[]}
+       */
+    getLabels(): string[];
+    /**
+     * @return {import('../types.js').LabelItem[]}
+     */
+    getLabelItems(chartArea?: import("../types.js").ChartArea): import('../types.js').LabelItem[];
+    beforeLayout(): void;
+    beforeUpdate(): void;
+    /**
+       * @param {number} maxWidth - the max width in pixels
+       * @param {number} maxHeight - the max height in pixels
+       * @param {{top: number, left: number, bottom: number, right: number}} margins - the space between the edge of the other scales and edge of the chart
+       *   This space comes from two sources:
+       *     - padding - space that's required to show the labels at the edges of the scale
+       *     - thickness of scales or legends in another orientation
+       */
+    update(maxWidth: number, maxHeight: number, margins: {
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+    }): void;
+    /**
+       * @protected
+       */
+    protected configure(): void;
+    _alignToPixels: any;
+    afterUpdate(): void;
+    beforeSetDimensions(): void;
+    setDimensions(): void;
+    afterSetDimensions(): void;
+    _callHooks(name: any): void;
+    beforeDataLimits(): void;
+    determineDataLimits(): void;
+    afterDataLimits(): void;
+    beforeBuildTicks(): void;
+    /**
+       * @return {object[]} the ticks
+       */
+    buildTicks(): object[];
+    afterBuildTicks(): void;
+    beforeTickToLabelConversion(): void;
+    /**
+       * Convert ticks to label strings
+       * @param {Tick[]} ticks
+       */
+    generateTickLabels(ticks: Tick[]): void;
+    afterTickToLabelConversion(): void;
+    beforeCalculateLabelRotation(): void;
+    calculateLabelRotation(): void;
+    afterCalculateLabelRotation(): void;
+    afterAutoSkip(): void;
+    beforeFit(): void;
+    fit(): void;
+    _calculatePadding(first: any, last: any, sin: any, cos: any): void;
+    /**
+       * Handle margins and padding interactions
+       * @private
+       */
+    private _handleMargins;
+    afterFit(): void;
+    /**
+       * @return {boolean}
+       */
+    isHorizontal(): boolean;
+    /**
+       * @return {boolean}
+       */
+    isFullSize(): boolean;
+    /**
+       * @param {Tick[]} ticks
+       * @private
+       */
+    private _convertTicksToLabels;
+    /**
+       * @return {{ first: object, last: object, widest: object, highest: object, widths: Array, heights: array }}
+       * @private
+       */
+    private _getLabelSizes;
+    /**
+       * Returns {width, height, offset} objects for the first, last, widest, highest tick
+       * labels where offset indicates the anchor point offset from the top in pixels.
+       * @return {{ first: object, last: object, widest: object, highest: object, widths: Array, heights: array }}
+       * @private
+       */
+    private _computeLabelSizes;
+    /**
+       * Used to get the label to display in the tooltip for the given value
+       * @param {*} value
+       * @return {string}
+       */
+    getLabelForValue(value: any): string;
+    /**
+       * Returns the location of the given data point. Value can either be an index or a numerical value
+       * The coordinate (0, 0) is at the upper-left corner of the canvas
+       * @param {*} value
+       * @param {number} [index]
+       * @return {number}
+       */
+    getPixelForValue(value: any, index?: number): number;
+    /**
+       * Used to get the data value from a given pixel. This is the inverse of getPixelForValue
+       * The coordinate (0, 0) is at the upper-left corner of the canvas
+       * @param {number} pixel
+       * @return {*}
+       */
+    getValueForPixel(pixel: number): any;
+    /**
+       * Returns the location of the tick at the given index
+       * The coordinate (0, 0) is at the upper-left corner of the canvas
+       * @param {number} index
+       * @return {number}
+       */
+    getPixelForTick(index: number): number;
+    /**
+       * Utility for getting the pixel location of a percentage of scale
+       * The coordinate (0, 0) is at the upper-left corner of the canvas
+       * @param {number} decimal
+       * @return {number}
+       */
+    getPixelForDecimal(decimal: number): number;
+    /**
+       * @param {number} pixel
+       * @return {number}
+       */
+    getDecimalForPixel(pixel: number): number;
+    /**
+       * Returns the pixel for the minimum chart value
+       * The coordinate (0, 0) is at the upper-left corner of the canvas
+       * @return {number}
+       */
+    getBasePixel(): number;
+    /**
+       * @return {number}
+       */
+    getBaseValue(): number;
+    /**
+       * @protected
+       */
+    protected getContext(index: any): any;
+    /**
+       * @return {number}
+       * @private
+       */
+    private _tickSize;
+    /**
+       * @return {boolean}
+       * @private
+       */
+    private _isVisible;
+    /**
+       * @private
+       */
+    private _computeGridLineItems;
+    /**
+       * @private
+       */
+    private _computeLabelItems;
+    _getXAxisLabelAlignment(): string;
+    _getYAxisLabelAlignment(tl: any): {
+        textAlign: string;
+        x: any;
+    };
+    /**
+       * @private
+       */
+    private _computeLabelArea;
+    /**
+     * @protected
+     */
+    protected drawBackground(): void;
+    getLineWidthForValue(value: any): any;
+    /**
+       * @protected
+       */
+    protected drawGrid(chartArea: any): void;
+    /**
+       * @protected
+       */
+    protected drawBorder(): void;
+    /**
+       * @protected
+       */
+    protected drawLabels(chartArea: any): void;
+    /**
+       * @protected
+       */
+    protected drawTitle(): void;
+    draw(chartArea: any): void;
+    /**
+       * @return {object[]}
+       * @private
+       */
+    private _layers;
+    /**
+       * Returns visible dataset metas that are attached to this scale
+       * @param {string} [type] - if specified, also filter by dataset type
+       * @return {object[]}
+       */
+    getMatchingVisibleMetas(type?: string): object[];
+    /**
+       * @param {number} index
+       * @return {object}
+       * @protected
+       */
+    protected _resolveTickFontOptions(index: number): object;
+    /**
+     * @protected
+     */
+    protected _maxDigits(): number;
+}
+export type Chart = import('../types/index.js').Chart;
+export type Tick = {
+    value: number | string;
+    label?: string;
+    major?: boolean;
+    $context?: any;
+};
+import Element from "./core.element.js";

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

@@ -0,0 +1 @@
+export function applyScaleDefaults(defaults: any): void;

package/dist/core/core.ticks.d.ts

@@ -0,0 +1,31 @@
+declare namespace _default {
+    export { formatters };
+}
+export default _default;
+declare namespace formatters {
+    /**
+     * Formatter for value labels
+     * @method Chart.Ticks.formatters.values
+     * @param value the value to display
+     * @return {string|string[]} the label to display
+     */
+    function values(value: any): string | string[];
+    /**
+     * Formatter for numeric ticks
+     * @method Chart.Ticks.formatters.numeric
+     * @param tickValue {number} the value to be formatted
+     * @param index {number} the position of the tickValue parameter in the ticks array
+     * @param ticks {object[]} the list of ticks being converted
+     * @return {string} string representation of the tickValue parameter
+     */
+    function numeric(tickValue: number, index: number, ticks: any[]): string;
+    /**
+     * Formatter for logarithmic ticks
+     * @method Chart.Ticks.formatters.logarithmic
+     * @param tickValue {number} the value to be formatted
+     * @param index {number} the position of the tickValue parameter in the ticks array
+     * @param ticks {object[]} the list of ticks being converted
+     * @return {string} string representation of the tickValue parameter
+     */
+    function logarithmic(tickValue: number, index: number, ticks: any[]): string;
+}

package/dist/core/core.typedRegistry.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @typedef {{id: string, defaults: any, overrides?: any, defaultRoutes: any}} IChartComponent
+ */
+export default class TypedRegistry {
+    constructor(type: any, scope: any, override: any);
+    type: any;
+    scope: any;
+    override: any;
+    items: any;
+    isForType(type: any): boolean;
+    /**
+       * @param {IChartComponent} item
+       * @returns {string} The scope where items defaults were registered to.
+       */
+    register(item: IChartComponent): string;
+    /**
+       * @param {string} id
+       * @returns {object?}
+       */
+    get(id: string): object | null;
+    /**
+       * @param {IChartComponent} item
+       */
+    unregister(item: IChartComponent): void;
+}
+export type IChartComponent = {
+    id: string;
+    defaults: any;
+    overrides?: any;
+    defaultRoutes: any;
+};
+import defaults from "./core.defaults.js";
+import { overrides } from "./core.defaults.js";

package/dist/core/index.d.ts

@@ -0,0 +1,15 @@
+export type { DateAdapter, TimeUnit } from './core.adapters.js';
+export { default as _adapters } from './core.adapters.js';
+export { default as Animation } from './core.animation.js';
+export { default as Animations } from './core.animations.js';
+export { default as animator } from './core.animator.js';
+export { default as Chart } from './core.controller.js';
+export { default as DatasetController } from './core.datasetController.js';
+export { default as defaults } from './core.defaults.js';
+export { default as Element } from './core.element.js';
+export { default as Interaction } from './core.interaction.js';
+export { default as layouts } from './core.layouts.js';
+export { default as plugins } from './core.plugins.js';
+export { default as registry } from './core.registry.js';
+export { default as Scale } from './core.scale.js';
+export { default as Ticks } from './core.ticks.js';