charjs 4.4.6

package/dist/controllers/controller.bar.d.ts

@@ -0,0 +1,62 @@
+export default class BarController extends DatasetController {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static overrides: any;
+    /**
+       * Overriding primitive data parsing since we support mixed primitive/array
+       * data for float bars
+       * @protected
+       */
+    protected parsePrimitiveData(meta: any, data: any, start: any, count: any): any[];
+    /**
+       * Overriding array data parsing since we support mixed primitive/array
+       * data for float bars
+       * @protected
+       */
+    protected parseArrayData(meta: any, data: any, start: any, count: any): any[];
+    /**
+       * Overriding object data parsing since we support mixed primitive/array
+       * value-scale data for float bars
+       * @protected
+       */
+    protected parseObjectData(meta: any, data: any, start: any, count: any): any[];
+    update(mode: any): void;
+    /**
+       * Returns the stacks based on groups and bar visibility.
+       * @param {number} [last] - The dataset index
+       * @param {number} [dataIndex] - The data index of the ruler
+       * @returns {string[]} The list of stack IDs
+       * @private
+       */
+    private _getStacks;
+    /**
+       * Returns the effective number of stacks based on groups and bar visibility.
+       * @private
+       */
+    private _getStackCount;
+    /**
+       * Returns the stack index for the given dataset based on groups and bar visibility.
+       * @param {number} [datasetIndex] - The dataset index
+       * @param {string} [name] - The stack name to find
+     * @param {number} [dataIndex]
+       * @returns {number} The stack index
+       * @private
+       */
+    private _getStackIndex;
+    /**
+       * @private
+       */
+    private _getRuler;
+    /**
+       * Note: pixel values are not clamped to the scale area.
+       * @private
+       */
+    private _calculateBarValuePixels;
+    /**
+       * @private
+       */
+    private _calculateBarIndexPixels;
+}
+import DatasetController from "../core/core.datasetController.js";

package/dist/controllers/controller.bubble.d.ts

@@ -0,0 +1,35 @@
+export default class BubbleController extends DatasetController {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static overrides: any;
+    /**
+       * Parse array of primitive values
+       * @protected
+       */
+    protected parsePrimitiveData(meta: any, data: any, start: any, count: any): any;
+    /**
+       * Parse array of arrays
+       * @protected
+       */
+    protected parseArrayData(meta: any, data: any, start: any, count: any): any;
+    /**
+       * Parse array of objects
+       * @protected
+       */
+    protected parseObjectData(meta: any, data: any, start: any, count: any): any;
+    /**
+       * @protected
+       */
+    protected getMaxOverflow(): number;
+    /**
+       * @protected
+       */
+    protected getLabelAndValue(index: any): {
+        label: any;
+        value: string;
+    };
+    update(mode: any): void;
+}
+import DatasetController from "../core/core.datasetController.js";

package/dist/controllers/controller.doughnut.d.ts

@@ -0,0 +1,64 @@
+export default class DoughnutController extends DatasetController {
+    static id: string;
+    static descriptors: {
+        _scriptable: (name: any) => boolean;
+        _indexable: (name: any) => boolean;
+    };
+    /**
+     * @type {any}
+     */
+    static overrides: any;
+    constructor(chart: any, datasetIndex: any);
+    innerRadius: number;
+    outerRadius: number;
+    offsetX: number;
+    offsetY: number;
+    /**
+       * Override data parsing, since we are not using scales
+       */
+    parse(start: any, count: any): void;
+    /**
+       * @private
+       */
+    private _getRotation;
+    /**
+       * @private
+       */
+    private _getCircumference;
+    /**
+       * Get the maximal rotation & circumference extents
+       * across all visible datasets.
+       */
+    _getRotationExtents(): {
+        rotation: number;
+        circumference: number;
+    };
+    /**
+     * @private
+     */
+    private _circumference;
+    calculateTotal(): number;
+    calculateCircumference(value: any): number;
+    getLabelAndValue(index: any): {
+        label: any;
+        value: string;
+    };
+    getMaxBorderWidth(arcs: any): number;
+    getMaxOffset(arcs: any): number;
+    /**
+       * Get radius length offset of the dataset in relation to the visible datasets weights. This allows determining the inner and outer radius correctly
+       * @private
+       */
+    private _getRingWeightOffset;
+    /**
+       * @private
+       */
+    private _getRingWeight;
+    /**
+       * Returns the sum of all visible data set weights.
+       * @private
+       */
+    private _getVisibleDatasetWeightTotal;
+}
+export type Chart = import('../core/core.controller.js').default;
+import DatasetController from "../core/core.datasetController.js";

package/dist/controllers/controller.line.d.ts

@@ -0,0 +1,13 @@
+export default class LineController extends DatasetController {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static overrides: any;
+    update(mode: any): void;
+    /**
+       * @protected
+       */
+    protected getMaxOverflow(): any;
+}
+import DatasetController from "../core/core.datasetController.js";

package/dist/controllers/controller.pie.d.ts

@@ -0,0 +1,3 @@
+export default class PieController extends DoughnutController {
+}
+import DoughnutController from "./controller.doughnut.js";

package/dist/controllers/controller.polarArea.d.ts

@@ -0,0 +1,35 @@
+export default class PolarAreaController extends DatasetController {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static overrides: any;
+    constructor(chart: any, datasetIndex: any);
+    innerRadius: number;
+    outerRadius: number;
+    getLabelAndValue(index: any): {
+        label: any;
+        value: string;
+    };
+    parseObjectData(meta: any, data: any, start: any, count: any): {
+        r: unknown;
+    }[];
+    update(mode: any): void;
+    /**
+     * @protected
+     */
+    protected getMinMax(): {
+        min: number;
+        max: number;
+    };
+    /**
+       * @private
+       */
+    private _updateRadius;
+    countVisibleElements(): number;
+    /**
+       * @private
+       */
+    private _computeAngle;
+}
+import DatasetController from "../core/core.datasetController.js";

package/dist/controllers/controller.radar.d.ts

@@ -0,0 +1,19 @@
+export default class RadarController extends DatasetController {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static overrides: any;
+    /**
+       * @protected
+       */
+    protected getLabelAndValue(index: any): {
+        label: any;
+        value: string;
+    };
+    parseObjectData(meta: any, data: any, start: any, count: any): {
+        r: unknown;
+    }[];
+    update(mode: any): void;
+}
+import DatasetController from "../core/core.datasetController.js";

package/dist/controllers/controller.scatter.d.ts

@@ -0,0 +1,20 @@
+export default class ScatterController extends DatasetController {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static overrides: any;
+    /**
+       * @protected
+       */
+    protected getLabelAndValue(index: any): {
+        label: any;
+        value: string;
+    };
+    update(mode: any): void;
+    /**
+       * @protected
+       */
+    protected getMaxOverflow(): any;
+}
+import DatasetController from "../core/core.datasetController.js";

package/dist/controllers/index.d.ts

@@ -0,0 +1,8 @@
+export { default as BarController } from "./controller.bar.js";
+export { default as BubbleController } from "./controller.bubble.js";
+export { default as DoughnutController } from "./controller.doughnut.js";
+export { default as LineController } from "./controller.line.js";
+export { default as PolarAreaController } from "./controller.polarArea.js";
+export { default as PieController } from "./controller.pie.js";
+export { default as RadarController } from "./controller.radar.js";
+export { default as ScatterController } from "./controller.scatter.js";

package/dist/core/core.adapters.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @namespace Chart._adapters
+ * @since 2.8.0
+ * @private
+ */
+import type { AnyObject } from '../types/basic.js';
+import type { ChartOptions } from '../types/index.js';
+export type TimeUnit = 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+export interface DateAdapter<T extends AnyObject = AnyObject> {
+    readonly options: T;
+    /**
+     * Will called with chart options after adapter creation.
+     */
+    init(this: DateAdapter<T>, chartOptions: ChartOptions): void;
+    /**
+     * Returns a map of time formats for the supported formatting units defined
+     * in Unit as well as 'datetime' representing a detailed date/time string.
+     */
+    formats(this: DateAdapter<T>): Record<string, string>;
+    /**
+     * Parses the given `value` and return the associated timestamp.
+     * @param value - the value to parse (usually comes from the data)
+     * @param [format] - the expected data format
+     */
+    parse(this: DateAdapter<T>, value: unknown, format?: TimeUnit): number | null;
+    /**
+     * Returns the formatted date in the specified `format` for a given `timestamp`.
+     * @param timestamp - the timestamp to format
+     * @param format - the date/time token
+     */
+    format(this: DateAdapter<T>, timestamp: number, format: TimeUnit): string;
+    /**
+     * Adds the specified `amount` of `unit` to the given `timestamp`.
+     * @param timestamp - the input timestamp
+     * @param amount - the amount to add
+     * @param unit - the unit as string
+     */
+    add(this: DateAdapter<T>, timestamp: number, amount: number, unit: TimeUnit): number;
+    /**
+     * Returns the number of `unit` between the given timestamps.
+     * @param a - the input timestamp (reference)
+     * @param b - the timestamp to subtract
+     * @param unit - the unit as string
+     */
+    diff(this: DateAdapter<T>, a: number, b: number, unit: TimeUnit): number;
+    /**
+     * Returns start of `unit` for the given `timestamp`.
+     * @param timestamp - the input timestamp
+     * @param unit - the unit as string
+     * @param [weekday] - the ISO day of the week with 1 being Monday
+     * and 7 being Sunday (only needed if param *unit* is `isoWeek`).
+     */
+    startOf(this: DateAdapter<T>, timestamp: number, unit: TimeUnit | 'isoWeek', weekday?: number): number;
+    /**
+     * Returns end of `unit` for the given `timestamp`.
+     * @param timestamp - the input timestamp
+     * @param unit - the unit as string
+     */
+    endOf(this: DateAdapter<T>, timestamp: number, unit: TimeUnit | 'isoWeek'): number;
+}
+/**
+ * Date adapter (current used by the time scale)
+ * @namespace Chart._adapters._date
+ * @memberof Chart._adapters
+ * @private
+ */
+declare class DateAdapterBase implements DateAdapter {
+    /**
+     * Override default date adapter methods.
+     * Accepts type parameter to define options type.
+     * @example
+     * Chart._adapters._date.override<{myAdapterOption: string}>({
+     *   init() {
+     *     console.log(this.options.myAdapterOption);
+     *   }
+     * })
+     */
+    static override<T extends AnyObject = AnyObject>(members: Partial<Omit<DateAdapter<T>, 'options'>>): void;
+    readonly options: AnyObject;
+    constructor(options: AnyObject);
+    init(): void;
+    formats(): Record<string, string>;
+    parse(): number | null;
+    format(): string;
+    add(): number;
+    diff(): number;
+    startOf(): number;
+    endOf(): number;
+}
+declare const _default: {
+    _date: typeof DateAdapterBase;
+};
+export default _default;

package/dist/core/core.animation.d.ts

@@ -0,0 +1,21 @@
+export default class Animation {
+    constructor(cfg: any, target: any, prop: any, to: any);
+    _active: boolean;
+    _fn: any;
+    _easing: any;
+    _start: number;
+    _duration: number;
+    _total: number;
+    _loop: boolean;
+    _target: any;
+    _prop: any;
+    _from: unknown;
+    _to: any;
+    _promises: any[];
+    active(): boolean;
+    update(cfg: any, to: any, date: any): void;
+    cancel(): void;
+    tick(date: any): void;
+    wait(): Promise<any>;
+    _notify(resolved: any): void;
+}

package/dist/core/core.animations.d.ts

@@ -0,0 +1,22 @@
+export default class Animations {
+    constructor(chart: any, config: any);
+    _chart: any;
+    _properties: Map<any, any>;
+    configure(config: any): void;
+    /**
+       * Utility to handle animation of `options`.
+       * @private
+       */
+    private _animateOptions;
+    /**
+       * @private
+       */
+    private _createAnimations;
+    /**
+       * Update `target` properties to new values, using configured animations
+       * @param {object} target - object to update
+       * @param {object} values - new target properties
+       * @returns {boolean|undefined} - `true` if animations were started
+       **/
+    update(target: object, values: object): boolean | undefined;
+}

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

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

package/dist/core/core.animator.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @typedef { import('./core.animation.js').default } Animation
+ * @typedef { import('./core.controller.js').default } Chart
+ */
+/**
+ * Please use the module's default export which provides a singleton instance
+ * Note: class is export for typedoc
+ */
+export class Animator {
+    _request: any;
+    _charts: Map<any, any>;
+    _running: boolean;
+    _lastDate: number;
+    /**
+       * @private
+       */
+    private _notify;
+    /**
+       * @private
+       */
+    private _refresh;
+    /**
+       * @private
+       */
+    private _update;
+    /**
+       * @private
+       */
+    private _getAnims;
+    /**
+       * @param {Chart} chart
+       * @param {string} event - event name
+       * @param {Function} cb - callback
+       */
+    listen(chart: Chart, event: string, cb: Function): void;
+    /**
+       * Add animations
+       * @param {Chart} chart
+       * @param {Animation[]} items - animations
+       */
+    add(chart: Chart, items: Animation[]): void;
+    /**
+       * Counts number of active animations for the chart
+       * @param {Chart} chart
+       */
+    has(chart: Chart): boolean;
+    /**
+       * Start animating (all charts)
+       * @param {Chart} chart
+       */
+    start(chart: Chart): void;
+    running(chart: any): boolean;
+    /**
+       * Stop all animations for the chart
+       * @param {Chart} chart
+       */
+    stop(chart: Chart): void;
+    /**
+       * Remove chart from Animator
+       * @param {Chart} chart
+       */
+    remove(chart: Chart): boolean;
+}
+declare const _default: Animator;
+export default _default;
+export type Animation = import('./core.animation.js').default;
+export type Chart = import('./core.controller.js').default;

package/dist/core/core.config.d.ts

@@ -0,0 +1,86 @@
+export function getIndexAxis(type: any, options: any): any;
+export function determineAxis(id: any, ...scaleOptions: any[]): any;
+export default class Config {
+    constructor(config: any);
+    _config: any;
+    _scopeCache: Map<any, any>;
+    _resolverCache: Map<any, any>;
+    get platform(): any;
+    set type(arg: any);
+    get type(): any;
+    set data(arg: any);
+    get data(): any;
+    set options(arg: any);
+    get options(): any;
+    get plugins(): any;
+    update(): void;
+    clearCache(): void;
+    /**
+     * Returns the option scope keys for resolving dataset options.
+     * These keys do not include the dataset itself, because it is not under options.
+     * @param {string} datasetType
+     * @return {string[][]}
+     */
+    datasetScopeKeys(datasetType: string): string[][];
+    /**
+     * Returns the option scope keys for resolving dataset animation options.
+     * These keys do not include the dataset itself, because it is not under options.
+     * @param {string} datasetType
+     * @param {string} transition
+     * @return {string[][]}
+     */
+    datasetAnimationScopeKeys(datasetType: string, transition: string): string[][];
+    /**
+     * Returns the options scope keys for resolving element options that belong
+     * to an dataset. These keys do not include the dataset itself, because it
+     * is not under options.
+     * @param {string} datasetType
+     * @param {string} elementType
+     * @return {string[][]}
+     */
+    datasetElementScopeKeys(datasetType: string, elementType: string): string[][];
+    /**
+     * Returns the options scope keys for resolving plugin options.
+     * @param {{id: string, additionalOptionScopes?: string[]}} plugin
+     * @return {string[][]}
+     */
+    pluginScopeKeys(plugin: {
+        id: string;
+        additionalOptionScopes?: string[];
+    }): string[][];
+    /**
+     * @private
+     */
+    private _cachedScopes;
+    /**
+     * Resolves the objects from options and defaults for option value resolution.
+     * @param {object} mainScope - The main scope object for options
+     * @param {string[][]} keyLists - The arrays of keys in resolution order
+     * @param {boolean} [resetCache] - reset the cache for this mainScope
+     */
+    getOptionScopes(mainScope: object, keyLists: string[][], resetCache?: boolean): any;
+    /**
+     * Returns the option scopes for resolving chart options
+     * @return {object[]}
+     */
+    chartOptionScopes(): object[];
+    /**
+     * @param {object[]} scopes
+     * @param {string[]} names
+     * @param {function|object} context
+     * @param {string[]} [prefixes]
+     * @return {object}
+     */
+    resolveNamedOptions(scopes: object[], names: string[], context: Function | object, prefixes?: string[]): object;
+    /**
+     * @param {object[]} scopes
+     * @param {object} [context]
+     * @param {string[]} [prefixes]
+     * @param {{scriptable: boolean, indexable: boolean, allKeys?: boolean}} [descriptorDefaults]
+     */
+    createResolver(scopes: object[], context?: object, prefixes?: string[], descriptorDefaults?: {
+        scriptable: boolean;
+        indexable: boolean;
+        allKeys?: boolean;
+    }): any;
+}