chrtjs 0.0.1-security → 4.4.6

package/dist/scales/scale.category.d.ts

@@ -0,0 +1,21 @@
+export default class CategoryScale extends Scale {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static defaults: any;
+    /** @type {number} */
+    _startValue: number;
+    _valueRange: number;
+    _addedLabels: any[];
+    init(scaleOptions: any): void;
+    parse(raw: any, index: any): number;
+    buildTicks(): {
+        value: any;
+    }[];
+    getLabelForValue(value: any): any;
+    getPixelForValue(value: any): number;
+    getPixelForTick(index: any): number;
+    getValueForPixel(pixel: any): number;
+}
+import Scale from "../core/core.scale.js";

package/dist/scales/scale.linear.d.ts

@@ -0,0 +1,10 @@
+export default class LinearScale extends LinearScaleBase {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static defaults: any;
+    getPixelForValue(value: any): number;
+    getValueForPixel(pixel: any): number;
+}
+import LinearScaleBase from "./scale.linearbase.js";

package/dist/scales/scale.linearbase.d.ts

@@ -0,0 +1,20 @@
+export default class LinearScaleBase extends Scale {
+    /** @type {number} */
+    start: number;
+    /** @type {number} */
+    end: number;
+    /** @type {number} */
+    _startValue: number;
+    /** @type {number} */
+    _endValue: number;
+    _valueRange: number;
+    parse(raw: any, index: any): number;
+    handleTickRangeOptions(): void;
+    getTickLimit(): number;
+    /**
+       * @protected
+       */
+    protected computeTickLimit(): number;
+    getLabelForValue(value: any): string;
+}
+import Scale from "../core/core.scale.js";

package/dist/scales/scale.logarithmic.d.ts

@@ -0,0 +1,25 @@
+export default class LogarithmicScale extends Scale {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static defaults: any;
+    /** @type {number} */
+    start: number;
+    /** @type {number} */
+    end: number;
+    /** @type {number} */
+    _startValue: number;
+    _valueRange: number;
+    parse(raw: any, index: any): number;
+    _zero: boolean;
+    handleTickRangeOptions(): void;
+    /**
+       * @param {number} value
+       * @return {string}
+       */
+    getLabelForValue(value: number): string;
+    getPixelForValue(value: any): number;
+    getValueForPixel(pixel: any): number;
+}
+import Scale from "../core/core.scale.js";

package/dist/scales/scale.radialLinear.d.ts

@@ -0,0 +1,63 @@
+export default class RadialLinearScale extends LinearScaleBase {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static defaults: any;
+    static defaultRoutes: {
+        'angleLines.color': string;
+        'pointLabels.color': string;
+        'ticks.color': string;
+    };
+    static descriptors: {
+        angleLines: {
+            _fallback: string;
+        };
+    };
+    /** @type {number} */
+    xCenter: number;
+    /** @type {number} */
+    yCenter: number;
+    /** @type {number} */
+    drawingArea: number;
+    /** @type {string[]} */
+    _pointLabels: string[];
+    _pointLabelItems: any[];
+    _padding: import("../types.js").ChartArea;
+    generateTickLabels(ticks: any): void;
+    setCenterPoint(leftMovement: any, rightMovement: any, topMovement: any, bottomMovement: any): void;
+    getIndexAngle(index: any): number;
+    getDistanceFromCenterForValue(value: any): number;
+    getValueForDistanceFromCenter(distance: any): any;
+    getPointLabelContext(index: any): any;
+    getPointPosition(index: any, distanceFromCenter: any, additionalAngle?: number): {
+        x: number;
+        y: number;
+        angle: number;
+    };
+    getPointPositionForValue(index: any, value: any): {
+        x: number;
+        y: number;
+        angle: number;
+    };
+    getBasePosition(index: any): {
+        x: number;
+        y: number;
+        angle: number;
+    };
+    getPointLabelPosition(index: any): {
+        left: any;
+        top: any;
+        right: any;
+        bottom: any;
+    };
+    /**
+       * @protected
+       */
+    protected drawGrid(): void;
+    /**
+       * @protected
+       */
+    protected drawLabels(): void;
+}
+import LinearScaleBase from "./scale.linearbase.js";

package/dist/scales/scale.time.d.ts

@@ -0,0 +1,130 @@
+export default class TimeScale extends Scale {
+    static id: string;
+    /**
+     * @type {any}
+     */
+    static defaults: any;
+    /**
+       * @param {object} props
+       */
+    constructor(props: object);
+    /** @type {{data: number[], labels: number[], all: number[]}} */
+    _cache: {
+        data: number[];
+        labels: number[];
+        all: number[];
+    };
+    /** @type {Unit} */
+    _unit: Unit;
+    /** @type {Unit=} */
+    _majorUnit: Unit | undefined;
+    _offsets: {};
+    _normalized: boolean;
+    _parseOpts: {
+        parser: any;
+        round: any;
+        isoWeekday: any;
+    };
+    init(scaleOpts: any, opts?: {}): void;
+    _adapter: DateAdapter;
+    /**
+       * @param {*} raw
+       * @param {number?} [index]
+       * @return {number}
+       */
+    parse(raw: any, index?: number | null): number;
+    /**
+       * @private
+       */
+    private _getLabelBounds;
+    /**
+       * Returns the start and end offsets from edges in the form of {start, end}
+       * where each value is a relative width to the scale and ranges between 0 and 1.
+       * They add extra margins on the both sides by scaling down the original scale.
+       * Offsets are added when the `offset` option is true.
+       * @param {number[]} timestamps
+       * @protected
+       */
+    protected initOffsets(timestamps?: number[]): void;
+    /**
+       * Generates a maximum of `capacity` timestamps between min and max, rounded to the
+       * `minor` unit using the given scale time `options`.
+       * Important: this method can return ticks outside the min and max range, it's the
+       * responsibility of the calling code to clamp values if needed.
+       * @protected
+       */
+    protected _generate(): number[];
+    /**
+       * @param {number} value
+       * @return {string}
+       */
+    getLabelForValue(value: number): string;
+    /**
+       * @param {number} value
+       * @param {string|undefined} format
+       * @return {string}
+       */
+    format(value: number, format: string | undefined): string;
+    /**
+       * Function to format an individual tick mark
+       * @param {number} time
+       * @param {number} index
+       * @param {object[]} ticks
+       * @param {string|undefined} [format]
+       * @return {string}
+       * @private
+       */
+    private _tickFormatFunction;
+    /**
+       * @param {object[]} ticks
+       */
+    generateTickLabels(ticks: object[]): void;
+    /**
+       * @param {number} value - Milliseconds since epoch (1 January 1970 00:00:00 UTC)
+       * @return {number}
+       */
+    getDecimalForValue(value: number): number;
+    /**
+       * @param {number} value - Milliseconds since epoch (1 January 1970 00:00:00 UTC)
+       * @return {number}
+       */
+    getPixelForValue(value: number): number;
+    /**
+       * @param {number} pixel
+       * @return {number}
+       */
+    getValueForPixel(pixel: number): number;
+    /**
+       * @param {string} label
+       * @return {{w:number, h:number}}
+       * @private
+       */
+    private _getLabelSize;
+    /**
+       * @param {number} exampleTime
+       * @return {number}
+       * @private
+       */
+    private _getLabelCapacity;
+    /**
+       * @protected
+       */
+    protected getDataTimestamps(): any;
+    /**
+       * @protected
+       */
+    protected getLabelTimestamps(): number[];
+    /**
+       * @param {number[]} values
+       * @protected
+       */
+    protected normalize(values: number[]): number[];
+}
+export type Unit = import('../core/core.adapters.js').TimeUnit;
+export type Interval = {
+    common: boolean;
+    size: number;
+    steps?: number;
+};
+export type DateAdapter = import('../core/core.adapters.js').DateAdapter;
+import Scale from "../core/core.scale.js";

package/dist/scales/scale.timeseries.d.ts

@@ -0,0 +1,39 @@
+export default TimeSeriesScale;
+declare class TimeSeriesScale extends TimeScale {
+    /** @type {object[]} */
+    _table: object[];
+    /** @type {number} */
+    _minPos: number;
+    /** @type {number} */
+    _tableRange: number;
+    /**
+       * @protected
+       */
+    protected initOffsets(): void;
+    /**
+       * Returns an array of {time, pos} objects used to interpolate a specific `time` or position
+       * (`pos`) on the scale, by searching entries before and after the requested value. `pos` is
+       * a decimal between 0 and 1: 0 being the start of the scale (left or top) and 1 the other
+       * extremity (left + width or top + height). Note that it would be more optimized to directly
+       * store pre-computed pixels, but the scale dimensions are not guaranteed at the time we need
+       * to create the lookup table. The table ALWAYS contains at least two items: min and max.
+       * @param {number[]} timestamps
+       * @return {object[]}
+       * @protected
+       */
+    protected buildLookupTable(timestamps: number[]): object[];
+    /**
+      * Generates all timestamps defined in the data.
+      * Important: this method can return ticks outside the min and max range, it's the
+      * responsibility of the calling code to clamp values if needed.
+      * @protected
+      */
+    protected _generate(): any;
+    /**
+       * Returns all timestamps
+       * @return {number[]}
+       * @private
+       */
+    private _getTimestampsForTable;
+}
+import TimeScale from "./scale.time.js";

package/dist/types/animation.d.ts

@@ -0,0 +1,34 @@
+import {Chart} from './index.js';
+import {AnyObject} from './basic.js';
+
+export declare class Animation {
+  constructor(cfg: AnyObject, target: AnyObject, prop: string, to?: unknown);
+  active(): boolean;
+  update(cfg: AnyObject, to: unknown, date: number): void;
+  cancel(): void;
+  tick(date: number): void;
+  readonly _to: unknown;
+}
+
+export interface AnimationEvent {
+  chart: Chart;
+  numSteps: number;
+  initial: boolean;
+  currentStep: number;
+}
+
+export declare class Animator {
+  listen(chart: Chart, event: 'complete' | 'progress', cb: (event: AnimationEvent) => void): void;
+  add(chart: Chart, items: readonly Animation[]): void;
+  has(chart: Chart): boolean;
+  start(chart: Chart): void;
+  running(chart: Chart): boolean;
+  stop(chart: Chart): void;
+  remove(chart: Chart): boolean;
+}
+
+export declare class Animations {
+  constructor(chart: Chart, animations: AnyObject);
+  configure(animations: AnyObject): void;
+  update(target: AnyObject, values: AnyObject): undefined | boolean;
+}

package/dist/types/basic.d.ts

@@ -0,0 +1,3 @@
+
+export type AnyObject = Record<string, any>;
+export type EmptyObject = Record<string, never>;

package/dist/types/color.d.ts

@@ -0,0 +1 @@
+export type Color = string | CanvasGradient | CanvasPattern;

package/dist/types/geometric.d.ts

@@ -0,0 +1,52 @@
+export interface ChartArea {
+  top: number;
+  left: number;
+  right: number;
+  bottom: number;
+  width: number;
+  height: number;
+}
+
+export interface Point {
+  x: number;
+  y: number;
+}
+
+export type TRBL = {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+
+export type TRBLCorners = {
+  topLeft: number;
+  topRight: number;
+  bottomLeft: number;
+  bottomRight: number;
+};
+
+export type CornerRadius = number | Partial<TRBLCorners>;
+
+export type RoundedRect = {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  radius?: CornerRadius
+}
+
+export type Padding = Partial<TRBL> | number | Point;
+
+export interface SplinePoint {
+  x: number;
+  y: number;
+  skip?: boolean;
+
+  // Both Bezier and monotone interpolations have these fields
+  // but they are added in different spots
+  cp1x?: number;
+  cp1y?: number;
+  cp2x?: number;
+  cp2y?: number;
+}