@ai-qa/workflow 2.0.2 → 2.0.4

package/qa-dashboard/node_modules/chart.js/dist/elements/element.arc.d.ts

@@ -0,0 +1,51 @@
+import Element from '../core/core.element.js';
+import type { ArcOptions, Point } from '../types/index.js';
+export interface ArcProps extends Point {
+    startAngle: number;
+    endAngle: number;
+    innerRadius: number;
+    outerRadius: number;
+    circumference: number;
+}
+export default class ArcElement extends Element<ArcProps, ArcOptions> {
+    static id: string;
+    static defaults: {
+        borderAlign: string;
+        borderColor: string;
+        borderDash: any[];
+        borderDashOffset: number;
+        borderJoinStyle: any;
+        borderRadius: number;
+        borderWidth: number;
+        offset: number;
+        spacing: number;
+        angle: any;
+        circular: boolean;
+        selfJoin: boolean;
+    };
+    static defaultRoutes: {
+        backgroundColor: string;
+    };
+    static descriptors: {
+        _scriptable: boolean;
+        _indexable: (name: any) => boolean;
+    };
+    circumference: number;
+    endAngle: number;
+    fullCircles: number;
+    innerRadius: number;
+    outerRadius: number;
+    pixelMargin: number;
+    startAngle: number;
+    constructor(cfg: any);
+    inRange(chartX: number, chartY: number, useFinalPosition: boolean): boolean;
+    getCenterPoint(useFinalPosition: boolean): {
+        x: number;
+        y: number;
+    };
+    tooltipPosition(useFinalPosition: boolean): {
+        x: number;
+        y: number;
+    };
+    draw(ctx: CanvasRenderingContext2D): void;
+}

package/qa-dashboard/node_modules/chart.js/dist/elements/element.bar.d.ts

@@ -0,0 +1,32 @@
+export default class BarElement extends Element<import("../types/basic.js").AnyObject, import("../types/basic.js").AnyObject> {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static defaults: any;
+    constructor(cfg: any);
+    options: any;
+    horizontal: any;
+    base: any;
+    width: any;
+    height: any;
+    inflateAmount: any;
+    draw(ctx: any): void;
+    inRange(mouseX: any, mouseY: any, useFinalPosition: any): boolean;
+    inXRange(mouseX: any, useFinalPosition: any): boolean;
+    inYRange(mouseY: any, useFinalPosition: any): boolean;
+    getCenterPoint(useFinalPosition: any): {
+        x: number;
+        y: number;
+    };
+    getRange(axis: any): number;
+}
+export type BarProps = {
+    x: number;
+    y: number;
+    base: number;
+    horizontal: boolean;
+    width: number;
+    height: number;
+};
+import Element from "../core/core.element.js";

package/qa-dashboard/node_modules/chart.js/dist/elements/element.line.d.ts

@@ -0,0 +1,87 @@
+export default class LineElement extends Element<import("../types/basic.js").AnyObject, import("../types/basic.js").AnyObject> {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static defaults: any;
+    static descriptors: {
+        _scriptable: boolean;
+        _indexable: (name: any) => boolean;
+    };
+    constructor(cfg: any);
+    animated: boolean;
+    options: any;
+    _chart: any;
+    _loop: any;
+    _fullLoop: any;
+    _path: any;
+    _points: any;
+    _segments: import("../helpers/helpers.segment.js").Segment[];
+    _decimated: boolean;
+    _pointsUpdated: boolean;
+    _datasetIndex: any;
+    updateControlPoints(chartArea: any, indexAxis: any): void;
+    set points(arg: any);
+    get points(): any;
+    get segments(): import("../helpers/helpers.segment.js").Segment[];
+    /**
+       * First non-skipped point on this line
+       * @returns {PointElement|undefined}
+       */
+    first(): PointElement | undefined;
+    /**
+       * Last non-skipped point on this line
+       * @returns {PointElement|undefined}
+       */
+    last(): PointElement | undefined;
+    /**
+       * Interpolate a point in this line at the same value on `property` as
+       * the reference `point` provided
+       * @param {PointElement} point - the reference point
+       * @param {string} property - the property to match on
+       * @returns {PointElement|undefined}
+       */
+    interpolate(point: PointElement, property: string): PointElement | undefined;
+    /**
+       * Append a segment of this line to current path.
+       * @param {CanvasRenderingContext2D} ctx
+       * @param {object} segment
+       * @param {number} segment.start - start index of the segment, referring the points array
+       * @param {number} segment.end - end index of the segment, referring the points array
+       * @param {boolean} segment.loop - indicates that the segment is a loop
+       * @param {object} params
+       * @param {boolean} params.move - move to starting point (vs line to it)
+       * @param {boolean} params.reverse - path the segment from end to start
+       * @param {number} params.start - limit segment to points starting from `start` index
+       * @param {number} params.end - limit segment to points ending at `start` + `count` index
+       * @returns {undefined|boolean} - true if the segment is a full loop (path should be closed)
+       */
+    pathSegment(ctx: CanvasRenderingContext2D, segment: {
+        start: number;
+        end: number;
+        loop: boolean;
+    }, params: {
+        move: boolean;
+        reverse: boolean;
+        start: number;
+        end: number;
+    }): undefined | boolean;
+    /**
+       * Append all segments of this line to current path.
+       * @param {CanvasRenderingContext2D|Path2D} ctx
+       * @param {number} [start]
+       * @param {number} [count]
+       * @returns {undefined|boolean} - true if line is a full loop (path should be closed)
+       */
+    path(ctx: CanvasRenderingContext2D | Path2D, start?: number, count?: number): undefined | boolean;
+    /**
+       * Draw
+       * @param {CanvasRenderingContext2D} ctx
+       * @param {object} chartArea
+       * @param {number} [start]
+       * @param {number} [count]
+       */
+    draw(ctx: CanvasRenderingContext2D, chartArea: object, start?: number, count?: number): void;
+}
+export type PointElement = import('./element.point.js').default;
+import Element from "../core/core.element.js";

package/qa-dashboard/node_modules/chart.js/dist/elements/element.point.d.ts

@@ -0,0 +1,39 @@
+import Element from '../core/core.element.js';
+import type { CartesianParsedData, ChartArea, Point, PointHoverOptions, PointOptions } from '../types/index.js';
+export type PointProps = Point;
+export default class PointElement extends Element<PointProps, PointOptions & PointHoverOptions> {
+    static id: string;
+    parsed: CartesianParsedData;
+    skip?: boolean;
+    stop?: boolean;
+    /**
+     * @type {any}
+     */
+    static defaults: {
+        borderWidth: number;
+        hitRadius: number;
+        hoverBorderWidth: number;
+        hoverRadius: number;
+        pointStyle: string;
+        radius: number;
+        rotation: number;
+    };
+    /**
+     * @type {any}
+     */
+    static defaultRoutes: {
+        backgroundColor: string;
+        borderColor: string;
+    };
+    constructor(cfg: any);
+    inRange(mouseX: number, mouseY: number, useFinalPosition?: boolean): boolean;
+    inXRange(mouseX: number, useFinalPosition?: boolean): boolean;
+    inYRange(mouseY: number, useFinalPosition?: boolean): boolean;
+    getCenterPoint(useFinalPosition?: boolean): {
+        x: number;
+        y: number;
+    };
+    size(options?: Partial<PointOptions & PointHoverOptions>): number;
+    draw(ctx: CanvasRenderingContext2D, area: ChartArea): void;
+    getRange(): any;
+}

package/qa-dashboard/node_modules/chart.js/dist/elements/index.d.ts

@@ -0,0 +1,4 @@
+export { default as ArcElement } from "./element.arc.js";
+export { default as LineElement } from "./element.line.js";
+export { default as PointElement } from "./element.point.js";
+export { default as BarElement } from "./element.bar.js";

package/qa-dashboard/node_modules/chart.js/dist/helpers/helpers.canvas.d.ts

@@ -0,0 +1,75 @@
+import type { Chart, Point, FontSpec, CanvasFontSpec, PointStyle, RenderTextOpts } from '../types/index.js';
+import type { TRBL, SplinePoint, RoundedRect, TRBLCorners } from '../types/geometric.js';
+/**
+ * Converts the given font object into a CSS font string.
+ * @param font - A font object.
+ * @return The CSS font string. See https://developer.mozilla.org/en-US/docs/Web/CSS/font
+ * @private
+ */
+export declare function toFontString(font: FontSpec): string;
+/**
+ * @private
+ */
+export declare function _measureText(ctx: CanvasRenderingContext2D, data: Record<string, number>, gc: string[], longest: number, string: string): number;
+type Thing = string | undefined | null;
+type Things = (Thing | Thing[])[];
+/**
+ * @private
+ */
+export declare function _longestText(ctx: CanvasRenderingContext2D, font: string, arrayOfThings: Things, cache?: {
+    data?: Record<string, number>;
+    garbageCollect?: string[];
+    font?: string;
+}): number;
+/**
+ * Returns the aligned pixel value to avoid anti-aliasing blur
+ * @param chart - The chart instance.
+ * @param pixel - A pixel value.
+ * @param width - The width of the element.
+ * @returns The aligned pixel value.
+ * @private
+ */
+export declare function _alignPixel(chart: Chart, pixel: number, width: number): number;
+/**
+ * Clears the entire canvas.
+ */
+export declare function clearCanvas(canvas?: HTMLCanvasElement, ctx?: CanvasRenderingContext2D): void;
+export interface DrawPointOptions {
+    pointStyle: PointStyle;
+    rotation?: number;
+    radius: number;
+    borderWidth: number;
+}
+export declare function drawPoint(ctx: CanvasRenderingContext2D, options: DrawPointOptions, x: number, y: number): void;
+export declare function drawPointLegend(ctx: CanvasRenderingContext2D, options: DrawPointOptions, x: number, y: number, w: number): void;
+/**
+ * Returns true if the point is inside the rectangle
+ * @param point - The point to test
+ * @param area - The rectangle
+ * @param margin - allowed margin
+ * @private
+ */
+export declare function _isPointInArea(point: Point, area: TRBL, margin?: number): boolean;
+export declare function clipArea(ctx: CanvasRenderingContext2D, area: TRBL): void;
+export declare function unclipArea(ctx: CanvasRenderingContext2D): void;
+/**
+ * @private
+ */
+export declare function _steppedLineTo(ctx: CanvasRenderingContext2D, previous: Point, target: Point, flip?: boolean, mode?: string): void;
+/**
+ * @private
+ */
+export declare function _bezierCurveTo(ctx: CanvasRenderingContext2D, previous: SplinePoint, target: SplinePoint, flip?: boolean): void;
+/**
+ * Render text onto the canvas
+ */
+export declare function renderText(ctx: CanvasRenderingContext2D, text: string | string[], x: number, y: number, font: CanvasFontSpec, opts?: RenderTextOpts): void;
+/**
+ * Add a path of a rectangle with rounded corners to the current sub-path
+ * @param ctx - Context
+ * @param rect - Bounding rect
+ */
+export declare function addRoundedRectPath(ctx: CanvasRenderingContext2D, rect: RoundedRect & {
+    radius: TRBLCorners;
+}): void;
+export {};

package/qa-dashboard/node_modules/chart.js/dist/helpers/helpers.collection.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Binary search
+ * @param table - the table search. must be sorted!
+ * @param value - value to find
+ * @param cmp
+ * @private
+ */
+export declare function _lookup(table: number[], value: number, cmp?: (value: number) => boolean): {
+    lo: number;
+    hi: number;
+};
+export declare function _lookup<T>(table: T[], value: number, cmp: (value: number) => boolean): {
+    lo: number;
+    hi: number;
+};
+/**
+ * Binary search
+ * @param table - the table search. must be sorted!
+ * @param key - property name for the value in each entry
+ * @param value - value to find
+ * @param last - lookup last index
+ * @private
+ */
+export declare const _lookupByKey: (table: Record<string, number>[], key: string, value: number, last?: boolean) => {
+    lo: number;
+    hi: number;
+};
+/**
+ * Reverse binary search
+ * @param table - the table search. must be sorted!
+ * @param key - property name for the value in each entry
+ * @param value - value to find
+ * @private
+ */
+export declare const _rlookupByKey: (table: Record<string, number>[], key: string, value: number) => {
+    lo: number;
+    hi: number;
+};
+/**
+ * Return subset of `values` between `min` and `max` inclusive.
+ * Values are assumed to be in sorted order.
+ * @param values - sorted array of values
+ * @param min - min value
+ * @param max - max value
+ */
+export declare function _filterBetween(values: number[], min: number, max: number): number[];
+export interface ArrayListener<T> {
+    _onDataPush?(...item: T[]): void;
+    _onDataPop?(): void;
+    _onDataShift?(): void;
+    _onDataSplice?(index: number, deleteCount: number, ...items: T[]): void;
+    _onDataUnshift?(...item: T[]): void;
+}
+/**
+ * Hooks the array methods that add or remove values ('push', pop', 'shift', 'splice',
+ * 'unshift') and notify the listener AFTER the array has been altered. Listeners are
+ * called on the '_onData*' callbacks (e.g. _onDataPush, etc.) with same arguments.
+ */
+export declare function listenArrayEvents<T>(array: T[], listener: ArrayListener<T>): void;
+/**
+ * Removes the given array event listener and cleanup extra attached properties (such as
+ * the _chartjs stub and overridden methods) if array doesn't have any more listeners.
+ */
+export declare function unlistenArrayEvents<T>(array: T[], listener: ArrayListener<T>): void;
+/**
+ * @param items
+ */
+export declare function _arrayUnique<T>(items: T[]): T[];

package/qa-dashboard/node_modules/chart.js/dist/helpers/helpers.color.d.ts

@@ -0,0 +1,13 @@
+import { Color } from '@kurkle/color';
+export declare function isPatternOrGradient(value: unknown): value is CanvasPattern | CanvasGradient;
+export declare function color(value: CanvasGradient): CanvasGradient;
+export declare function color(value: CanvasPattern): CanvasPattern;
+export declare function color(value: string | {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+} | [number, number, number] | [number, number, number, number]): Color;
+export declare function getHoverColor(value: CanvasGradient): CanvasGradient;
+export declare function getHoverColor(value: CanvasPattern): CanvasPattern;
+export declare function getHoverColor(value: string): string;

package/qa-dashboard/node_modules/chart.js/dist/helpers/helpers.config.d.ts

@@ -0,0 +1,31 @@
+import type { AnyObject } from '../types/basic.js';
+import type { ChartMeta } from '../types/index.js';
+import type { ResolverObjectKey, ResolverCache, ResolverProxy, DescriptorDefaults, Descriptor, ContextProxy } from './helpers.config.types.js';
+export * from './helpers.config.types.js';
+/**
+ * Creates a Proxy for resolving raw values for options.
+ * @param scopes - The option scopes to look for values, in resolution order
+ * @param prefixes - The prefixes for values, in resolution order.
+ * @param rootScopes - The root option scopes
+ * @param fallback - Parent scopes fallback
+ * @param getTarget - callback for getting the target for changed values
+ * @returns Proxy
+ * @private
+ */
+export declare function _createResolver<T extends AnyObject[] = AnyObject[], R extends AnyObject[] = T>(scopes: T, prefixes?: string[], rootScopes?: R, fallback?: ResolverObjectKey, getTarget?: () => AnyObject): any;
+/**
+ * Returns an Proxy for resolving option values with context.
+ * @param proxy - The Proxy returned by `_createResolver`
+ * @param context - Context object for scriptable/indexable options
+ * @param subProxy - The proxy provided for scriptable options
+ * @param descriptorDefaults - Defaults for descriptors
+ * @private
+ */
+export declare function _attachContext<T extends AnyObject[] = AnyObject[], R extends AnyObject[] = T>(proxy: ResolverProxy<T, R>, context: AnyObject, subProxy?: ResolverProxy<T, R>, descriptorDefaults?: DescriptorDefaults): ContextProxy<T, R>;
+/**
+ * @private
+ */
+export declare function _descriptors(proxy: ResolverCache, defaults?: DescriptorDefaults): Descriptor;
+export declare function _parseObjectDataRadialScale(meta: ChartMeta<'line' | 'scatter'>, data: AnyObject[], start: number, count: number): {
+    r: unknown;
+}[];

package/qa-dashboard/node_modules/chart.js/dist/helpers/helpers.config.types.d.ts

@@ -0,0 +1,41 @@
+import type { AnyObject } from '../types/basic.js';
+import type { Merge } from '../types/utils.js';
+export type ResolverObjectKey = string | boolean;
+export interface ResolverCache<T extends AnyObject[] = AnyObject[], R extends AnyObject[] = T> {
+    [Symbol.toStringTag]: 'Object';
+    _cacheable: boolean;
+    _scopes: T;
+    _rootScopes: T | R;
+    _fallback: ResolverObjectKey;
+    _keys?: string[];
+    _scriptable?: boolean;
+    _indexable?: boolean;
+    _allKeys?: boolean;
+    _storage?: T[number];
+    _getTarget(): T[number];
+    override<S extends AnyObject>(scope: S): ResolverProxy<(T[number] | S)[], T | R>;
+}
+export type ResolverProxy<T extends AnyObject[] = AnyObject[], R extends AnyObject[] = T> = Merge<T[number]> & ResolverCache<T, R>;
+export interface DescriptorDefaults {
+    scriptable: boolean;
+    indexable: boolean;
+    allKeys?: boolean;
+}
+export interface Descriptor {
+    allKeys: boolean;
+    scriptable: boolean;
+    indexable: boolean;
+    isScriptable(key: string): boolean;
+    isIndexable(key: string): boolean;
+}
+export interface ContextCache<T extends AnyObject[] = AnyObject[], R extends AnyObject[] = T> {
+    _cacheable: boolean;
+    _proxy: ResolverProxy<T, R>;
+    _context: AnyObject;
+    _subProxy: ResolverProxy<T, R>;
+    _stack: Set<string>;
+    _descriptors: Descriptor;
+    setContext(ctx: AnyObject): ContextProxy<T, R>;
+    override<S extends AnyObject>(scope: S): ContextProxy<(T[number] | S)[], T | R>;
+}
+export type ContextProxy<T extends AnyObject[] = AnyObject[], R extends AnyObject[] = T> = Merge<T[number]> & ContextCache<T, R>;

package/qa-dashboard/node_modules/chart.js/dist/helpers/helpers.core.d.ts

@@ -0,0 +1,147 @@
+/**
+ * @namespace Chart.helpers
+ */
+import type { AnyObject } from '../types/basic.js';
+import type { ActiveDataPoint, ChartEvent } from '../types/index.js';
+/**
+ * An empty function that can be used, for example, for optional callback.
+ */
+export declare function noop(): void;
+/**
+ * Returns a unique id, sequentially generated from a global variable.
+ */
+export declare const uid: () => number;
+/**
+ * Returns true if `value` is neither null nor undefined, else returns false.
+ * @param value - The value to test.
+ * @since 2.7.0
+ */
+export declare function isNullOrUndef(value: unknown): value is null | undefined;
+/**
+ * Returns true if `value` is an array (including typed arrays), else returns false.
+ * @param value - The value to test.
+ * @function
+ */
+export declare function isArray<T = unknown>(value: unknown): value is T[];
+/**
+ * Returns true if `value` is an object (excluding null), else returns false.
+ * @param value - The value to test.
+ * @since 2.7.0
+ */
+export declare function isObject(value: unknown): value is AnyObject;
+/**
+ * Returns true if `value` is a finite number, else returns false
+ * @param value  - The value to test.
+ */
+declare function isNumberFinite(value: unknown): value is number;
+export { isNumberFinite as isFinite, };
+/**
+ * Returns `value` if finite, else returns `defaultValue`.
+ * @param value - The value to return if defined.
+ * @param defaultValue - The value to return if `value` is not finite.
+ */
+export declare function finiteOrDefault(value: unknown, defaultValue: number): number;
+/**
+ * Returns `value` if defined, else returns `defaultValue`.
+ * @param value - The value to return if defined.
+ * @param defaultValue - The value to return if `value` is undefined.
+ */
+export declare function valueOrDefault<T>(value: T | undefined, defaultValue: T): T;
+export declare const toPercentage: (value: number | string, dimension: number) => number;
+export declare const toDimension: (value: number | string, dimension: number) => number;
+/**
+ * Calls `fn` with the given `args` in the scope defined by `thisArg` and returns the
+ * value returned by `fn`. If `fn` is not a function, this method returns undefined.
+ * @param fn - The function to call.
+ * @param args - The arguments with which `fn` should be called.
+ * @param [thisArg] - The value of `this` provided for the call to `fn`.
+ */
+export declare function callback<T extends (this: TA, ...restArgs: unknown[]) => R, TA, R>(fn: T | undefined, args: unknown[], thisArg?: TA): R | undefined;
+/**
+ * Note(SB) for performance sake, this method should only be used when loopable type
+ * is unknown or in none intensive code (not called often and small loopable). Else
+ * it's preferable to use a regular for() loop and save extra function calls.
+ * @param loopable - The object or array to be iterated.
+ * @param fn - The function to call for each item.
+ * @param [thisArg] - The value of `this` provided for the call to `fn`.
+ * @param [reverse] - If true, iterates backward on the loopable.
+ */
+export declare function each<T, TA>(loopable: Record<string, T>, fn: (this: TA, v: T, i: string) => void, thisArg?: TA, reverse?: boolean): void;
+export declare function each<T, TA>(loopable: T[], fn: (this: TA, v: T, i: number) => void, thisArg?: TA, reverse?: boolean): void;
+/**
+ * Returns true if the `a0` and `a1` arrays have the same content, else returns false.
+ * @param a0 - The array to compare
+ * @param a1 - The array to compare
+ * @private
+ */
+export declare function _elementsEqual(a0: ActiveDataPoint[], a1: ActiveDataPoint[]): boolean;
+/**
+ * Returns a deep copy of `source` without keeping references on objects and arrays.
+ * @param source - The value to clone.
+ */
+export declare function clone<T>(source: T): T;
+/**
+ * The default merger when Chart.helpers.merge is called without merger option.
+ * Note(SB): also used by mergeConfig and mergeScaleConfig as fallback.
+ * @private
+ */
+export declare function _merger(key: string, target: AnyObject, source: AnyObject, options: AnyObject): void;
+export interface MergeOptions {
+    merger?: (key: string, target: AnyObject, source: AnyObject, options?: AnyObject) => void;
+}
+/**
+ * Recursively deep copies `source` properties into `target` with the given `options`.
+ * IMPORTANT: `target` is not cloned and will be updated with `source` properties.
+ * @param target - The target object in which all sources are merged into.
+ * @param source - Object(s) to merge into `target`.
+ * @param [options] - Merging options:
+ * @param [options.merger] - The merge method (key, target, source, options)
+ * @returns The `target` object.
+ */
+export declare function merge<T>(target: T, source: [], options?: MergeOptions): T;
+export declare function merge<T, S1>(target: T, source: S1, options?: MergeOptions): T & S1;
+export declare function merge<T, S1>(target: T, source: [S1], options?: MergeOptions): T & S1;
+export declare function merge<T, S1, S2>(target: T, source: [S1, S2], options?: MergeOptions): T & S1 & S2;
+export declare function merge<T, S1, S2, S3>(target: T, source: [S1, S2, S3], options?: MergeOptions): T & S1 & S2 & S3;
+export declare function merge<T, S1, S2, S3, S4>(target: T, source: [S1, S2, S3, S4], options?: MergeOptions): T & S1 & S2 & S3 & S4;
+export declare function merge<T>(target: T, source: AnyObject[], options?: MergeOptions): AnyObject;
+/**
+ * Recursively deep copies `source` properties into `target` *only* if not defined in target.
+ * IMPORTANT: `target` is not cloned and will be updated with `source` properties.
+ * @param target - The target object in which all sources are merged into.
+ * @param source - Object(s) to merge into `target`.
+ * @returns The `target` object.
+ */
+export declare function mergeIf<T>(target: T, source: []): T;
+export declare function mergeIf<T, S1>(target: T, source: S1): T & S1;
+export declare function mergeIf<T, S1>(target: T, source: [S1]): T & S1;
+export declare function mergeIf<T, S1, S2>(target: T, source: [S1, S2]): T & S1 & S2;
+export declare function mergeIf<T, S1, S2, S3>(target: T, source: [S1, S2, S3]): T & S1 & S2 & S3;
+export declare function mergeIf<T, S1, S2, S3, S4>(target: T, source: [S1, S2, S3, S4]): T & S1 & S2 & S3 & S4;
+export declare function mergeIf<T>(target: T, source: AnyObject[]): AnyObject;
+/**
+ * Merges source[key] in target[key] only if target[key] is undefined.
+ * @private
+ */
+export declare function _mergerIf(key: string, target: AnyObject, source: AnyObject): void;
+/**
+ * @private
+ */
+export declare function _deprecated(scope: string, value: unknown, previous: string, current: string): void;
+/**
+ * @private
+ */
+export declare function _splitKey(key: string): string[];
+export declare function resolveObjectKey(obj: AnyObject, key: string): any;
+/**
+ * @private
+ */
+export declare function _capitalize(str: string): string;
+export declare const defined: (value: unknown) => boolean;
+export declare const isFunction: (value: unknown) => value is (...args: any[]) => any;
+export declare const setsEqual: <T>(a: Set<T>, b: Set<T>) => boolean;
+/**
+ * @param e - The event
+ * @private
+ */
+export declare function _isClickEvent(e: ChartEvent): boolean;

package/qa-dashboard/node_modules/chart.js/dist/helpers/helpers.curve.d.ts

@@ -0,0 +1,17 @@
+import type { ChartArea } from '../types/index.js';
+import type { SplinePoint } from '../types/geometric.js';
+export declare function splineCurve(firstPoint: SplinePoint, middlePoint: SplinePoint, afterPoint: SplinePoint, t: number): {
+    previous: SplinePoint;
+    next: SplinePoint;
+};
+/**
+ * This function calculates Bézier control points in a similar way than |splineCurve|,
+ * but preserves monotonicity of the provided data and ensures no local extremums are added
+ * between the dataset discrete points due to the interpolation.
+ * See : https://en.wikipedia.org/wiki/Monotone_cubic_interpolation
+ */
+export declare function splineCurveMonotone(points: SplinePoint[], indexAxis?: 'x' | 'y'): void;
+/**
+ * @private
+ */
+export declare function _updateBezierControlPoints(points: SplinePoint[], options: any, area: ChartArea, loop: boolean, indexAxis: 'x' | 'y'): void;

package/qa-dashboard/node_modules/chart.js/dist/helpers/helpers.dataset.d.ts

@@ -0,0 +1,2 @@
+import type { Chart, ChartMeta, TRBL } from '../types/index.js';
+export declare function getDatasetClipArea(chart: Chart, meta: ChartMeta): TRBL | false;

package/qa-dashboard/node_modules/chart.js/dist/helpers/helpers.dom.d.ts

@@ -0,0 +1,48 @@
+import type PrivateChart from '../core/core.controller.js';
+import type { Chart, ChartEvent } from '../types.js';
+/**
+ * @private
+ */
+export declare function _isDomSupported(): boolean;
+/**
+ * @private
+ */
+export declare function _getParentNode(domNode: HTMLCanvasElement): HTMLCanvasElement;
+export declare function getStyle(el: HTMLElement, property: string): string;
+/**
+ * Gets an event's x, y coordinates, relative to the chart area
+ * @param event
+ * @param chart
+ * @returns x and y coordinates of the event
+ */
+export declare function getRelativePosition(event: Event | ChartEvent | TouchEvent | MouseEvent, chart: Chart | PrivateChart): {
+    x: number;
+    y: number;
+};
+export declare function getMaximumSize(canvas: HTMLCanvasElement, bbWidth?: number, bbHeight?: number, aspectRatio?: number): {
+    width: number;
+    height: number;
+};
+/**
+ * @param chart
+ * @param forceRatio
+ * @param forceStyle
+ * @returns True if the canvas context size or transformation has changed.
+ */
+export declare function retinaScale(chart: Chart | PrivateChart, forceRatio: number, forceStyle?: boolean): boolean | void;
+/**
+ * Detects support for options object argument in addEventListener.
+ * https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener#Safely_detecting_option_support
+ * @private
+ */
+export declare const supportsEventListenerOptions: boolean;
+/**
+ * The "used" size is the final value of a dimension property after all calculations have
+ * been performed. This method uses the computed style of `element` but returns undefined
+ * if the computed style is not expressed in pixels. That can happen in some cases where
+ * `element` has a size relative to its parent and this last one is not yet displayed,
+ * for example because of `display: none` on a parent node.
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/used_value
+ * @returns Size in pixels or undefined if unknown.
+ */
+export declare function readUsedSize(element: HTMLElement, property: 'width' | 'height'): number | undefined;