@thewhitehaven04/chartjs-plugin-zoom 2.2.15 → 2.2.16

package/dist/src/core.d.ts

@@ -0,0 +1,24 @@
+import { type ScaleRange, type State } from './state.js';
+import type { Chart, Point, Scale, UpdateMode } from 'chart.js';
+import type { PanTrigger, ZoomTrigger } from './options.js';
+import type { ZoomAmount } from './types.js';
+export declare function zoom(chart: Chart, amount: ZoomAmount, transition?: UpdateMode, trigger?: ZoomTrigger): void;
+export declare function zoomRect(chart: Chart, p0: Point, p1: Point, transition?: UpdateMode, trigger?: ZoomTrigger): void;
+export declare function zoomScale(chart: Chart, scaleId: string, range: ScaleRange, transition?: UpdateMode, trigger?: ZoomTrigger): void;
+export declare function resetZoom(chart: Chart, transition?: UpdateMode): void;
+export declare function getZoomLevel(chart: Chart): number;
+type PanAmount = number | Partial<Point>;
+export declare function pan(chart: Chart, delta: PanAmount, enabledScales?: Scale[], transition?: UpdateMode, trigger?: PanTrigger): void;
+export declare function getInitialScaleBounds(chart: Chart): Record<string, {
+    min?: number | undefined;
+    max?: number | undefined;
+}>;
+export declare function getZoomedScaleBounds(chart: Chart): Record<string, {
+    min?: number | undefined;
+    max?: number | undefined;
+}>;
+export declare function isZoomedOrPanned(chart: Chart): boolean;
+export declare function isZoomingOrPanningState(state: State): boolean;
+export declare function isZoomingOrPanning(chart: Chart): boolean;
+export {};
+//# sourceMappingURL=core.d.ts.map

package/dist/src/defaults.d.ts

@@ -0,0 +1,3 @@
+import type { ZoomPluginOptions } from './options';
+export declare const defaults: ZoomPluginOptions;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/src/hammer.d.ts

@@ -0,0 +1,6 @@
+import type { Chart } from 'chart.js';
+import type { ZoomPluginOptions } from './options';
+export declare function startHammer(chart: Chart, options: ZoomPluginOptions): void;
+export declare function stopHammer(chart: Chart): void;
+export declare function hammerOptionsChanged(oldOptions: ZoomPluginOptions, newOptions: ZoomPluginOptions): boolean;
+//# sourceMappingURL=hammer.d.ts.map

package/dist/src/handlers.d.ts

@@ -0,0 +1,24 @@
+import type { Chart } from 'chart.js';
+import type { ModeOption, ZoomPluginOptions } from './options';
+export declare function mouseMove(chart: Chart, event: MouseEvent): void;
+export declare function mouseDown(chart: Chart, event: MouseEvent): void;
+export declare function computeDragRect(chart: Chart, mode: ModeOption | undefined, pointEvents: {
+    dragStart: MouseEvent;
+    dragEnd: MouseEvent;
+}, maintainAspectRatio: boolean | undefined): {
+    width: number;
+    height: number;
+    zoomX: number;
+    zoomY: number;
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+};
+export declare function mouseUp(chart: Chart, event: MouseEvent): void;
+export declare function wheel(chart: Chart, event: WheelEvent & {
+    target?: HTMLCanvasElement;
+}): void;
+export declare function addListeners(chart: Chart, options: ZoomPluginOptions): void;
+export declare function removeListeners(chart: Chart): void;
+//# sourceMappingURL=handlers.d.ts.map

package/dist/src/index.umd.d.ts

@@ -0,0 +1,3 @@
+import Zoom from './plugin';
+export default Zoom;
+//# sourceMappingURL=index.umd.d.ts.map

package/dist/src/options.d.ts

@@ -0,0 +1,196 @@
+/// <reference types="hammerjs" />
+import type { Chart, Color, Point } from 'chart.js';
+export type Mode = 'x' | 'y' | 'xy';
+export type ModeFn = (context: {
+    chart: Chart;
+}) => Mode;
+export type ModeOption = Mode | ModeFn;
+export type ModifierKey = 'ctrl' | 'alt' | 'shift' | 'meta';
+export type DrawTime = 'afterDraw' | 'afterDatasetsDraw' | 'beforeDraw' | 'beforeDatasetsDraw';
+export type ZoomTrigger = 'api' | 'drag' | 'wheel' | 'pinch';
+export type PanTrigger = 'api' | 'drag' | 'wheel' | 'other';
+type RejectableStartEvent<T = Event | HammerInput> = (context: {
+    chart: Chart;
+    event: T;
+    point: Point;
+}) => boolean | undefined;
+type RejectEvent<T = Event | HammerInput> = (context: {
+    chart: Chart;
+    event: T;
+}) => void;
+type GenericEvent = (context: {
+    chart: Chart;
+}) => void;
+export interface WheelOptions {
+    /**
+     * Enable the zoom via mouse wheel
+     */
+    enabled?: boolean;
+    /**
+     * Speed of zoom via mouse wheel
+     * (percentage of zoom on a wheel event)
+     */
+    speed?: number;
+    /**
+     * Modifier key required for zooming with mouse
+     */
+    modifierKey?: ModifierKey | null;
+}
+export interface DragOptions {
+    /**
+     * Enable the zoom via drag
+     */
+    enabled?: boolean;
+    /**
+     * Minimal zoom distance required before actually applying zoom
+     */
+    threshold?: number;
+    /**
+     * Border color of the drag area
+     */
+    borderColor?: Color;
+    /**
+     * Border width of the drag area
+     */
+    borderWidth?: number;
+    /**
+     * Background color of the drag area
+     */
+    backgroundColor?: Color;
+    /**
+     * Modifier key required for drag-to-zoom
+     */
+    modifierKey?: ModifierKey | null;
+    /**
+     * Draw time required for drag-to-zoom
+     */
+    drawTime?: DrawTime;
+    /**
+     * Maintain aspect ratio of the drag rectangle
+     */
+    maintainAspectRatio?: boolean;
+}
+export interface PinchOptions {
+    /**
+     * Enable the zoom via pinch
+     */
+    enabled?: boolean;
+}
+/**
+ * Container for zoom options
+ */
+export interface ZoomOptions {
+    /**
+     * Zooming directions. Remove the appropriate direction to disable
+     * E.g. 'y' would only allow zooming in the y direction
+     * A function that is called as the user is zooming and returns the
+     * available directions can also be used:
+     *    mode: function({ chart }) {
+     *      return 'xy';
+     *    },
+     */
+    mode?: ModeOption;
+    /**
+     * Options of the mouse wheel mode
+     */
+    wheel?: WheelOptions;
+    /**
+     * Options of the drag-to-zoom mode
+     */
+    drag?: DragOptions;
+    /**
+     * Options of the pinch mode
+     */
+    pinch?: PinchOptions;
+    scaleMode?: ModeOption;
+    /** @deprecated Use scaleMode instead */
+    overScaleMode?: ModeOption;
+    /**
+     * Function called while the user is zooming
+     */
+    onZoom?: (context: {
+        chart: Chart;
+        trigger: ZoomTrigger;
+        amount?: {
+            x: number;
+            y: number;
+        } & {
+            focalPoint: Point;
+        };
+    }) => void;
+    /**
+     * Function called once zooming is completed
+     */
+    onZoomComplete?: GenericEvent;
+    /**
+     * Function called when wheel input occurs without modifier key
+     */
+    onZoomRejected?: RejectEvent<Event>;
+    onZoomStart?: RejectableStartEvent<Event>;
+}
+/**
+ * Container for pan options
+ */
+export interface PanOptions {
+    /**
+     * Boolean to enable panning
+     */
+    enabled?: boolean;
+    /**
+     * Panning directions. Remove the appropriate direction to disable
+     * E.g. 'y' would only allow panning in the y direction
+     * A function that is called as the user is panning and returns the
+     * available directions can also be used:
+     *   mode: function({ chart }) {
+     *     return 'xy';
+     *   },
+     */
+    mode?: ModeOption;
+    /**
+     * Modifier key required for panning with mouse
+     */
+    modifierKey?: ModifierKey | null;
+    scaleMode?: ModeOption;
+    /** @deprecated Use scaleMode instead */
+    overScaleMode?: ModeOption;
+    /**
+     * Minimal pan distance required before actually applying pan
+     */
+    threshold?: number;
+    /**
+     * Function called while the user is panning
+     */
+    onPan?: (context: {
+        chart: Chart;
+        trigger: PanTrigger;
+        delta: {
+            x: number;
+            y: number;
+        };
+    }) => void;
+    /**
+     * Function called once panning is completed
+     */
+    onPanComplete?: GenericEvent;
+    /**
+     * Function called when pan fails because modifier key was not detected.
+     * event is the Hammer event that failed - see https://hammerjs.github.io/api#event-object
+     */
+    onPanRejected?: RejectEvent<HammerInput>;
+    onPanStart?: RejectableStartEvent<HammerInput>;
+}
+export interface ScaleLimits {
+    min?: number | 'original';
+    max?: number | 'original';
+    minRange?: number;
+}
+export interface LimitOptions {
+    [axisId: string]: ScaleLimits;
+}
+export interface ZoomPluginOptions {
+    pan?: PanOptions;
+    limits?: LimitOptions;
+    zoom?: ZoomOptions;
+}
+export {};
+//# sourceMappingURL=options.d.ts.map

package/dist/src/plugin.d.ts

@@ -0,0 +1,25 @@
+import type { Chart, ChartEvent } from 'chart.js';
+import type { ZoomPluginOptions } from './options';
+declare const _default: {
+    id: string;
+    version: string;
+    defaults: ZoomPluginOptions;
+    start(chart: Chart, _args: unknown, options: ZoomPluginOptions): void;
+    beforeEvent(chart: Chart, { event }: {
+        event: ChartEvent;
+        replay: boolean;
+        cancelable: true;
+        inChartArea: boolean;
+    }): boolean | void;
+    beforeUpdate(chart: Chart, _args: unknown, options: ZoomPluginOptions): void;
+    beforeDatasetsDraw(chart: Chart, _args: unknown, options: ZoomPluginOptions): void;
+    afterDatasetsDraw(chart: Chart, _args: unknown, options: ZoomPluginOptions): void;
+    beforeDraw(chart: Chart, _args: unknown, options: ZoomPluginOptions): void;
+    afterDraw(chart: Chart, _args: unknown, options: ZoomPluginOptions): void;
+    stop(chart: Chart): void;
+    panFunctions: Record<string, import("./scale.types").PanFunction>;
+    zoomFunctions: Record<string, import("./scale.types").ZoomFunction>;
+    zoomRectFunctions: Record<string, import("./scale.types").ZoomRectFunction>;
+};
+export default _default;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/src/scale.types.d.ts

@@ -0,0 +1,12 @@
+import { type ScaleRange } from './state';
+import type { Point, Scale } from 'chart.js';
+import type { LimitOptions } from './options';
+export type ZoomFunction = (scale: Scale, zoom: number, center: Point, limits: LimitOptions) => boolean;
+export type ZoomRectFunction = (scale: Scale, from: number, to: number, limits: LimitOptions) => boolean;
+export type PanFunction = (scale: Scale, delta: number, limits: LimitOptions) => boolean;
+export declare function zoomDelta(val: number | undefined, min: number | undefined, range: number, newRange: number): ScaleRange;
+export declare function updateRange(scale: Scale, { min, max }: ScaleRange, limits?: LimitOptions, zoom?: boolean, pan?: boolean): boolean;
+export declare const zoomFunctions: Record<string, ZoomFunction>;
+export declare const zoomRectFunctions: Record<string, ZoomRectFunction>;
+export declare const panFunctions: Record<string, PanFunction>;
+//# sourceMappingURL=scale.types.d.ts.map

package/dist/src/scale.types.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=scale.types.test.d.ts.map

package/dist/src/state.d.ts

@@ -0,0 +1,53 @@
+import { Chart, type Point } from 'chart.js';
+import type { ZoomPluginOptions } from './options';
+export type ScaleRange = {
+    min: number;
+    max: number;
+};
+export type OriginalLimits = {
+    min: {
+        scale?: number;
+        options?: unknown;
+    };
+    max: {
+        scale?: number;
+        options?: unknown;
+    };
+};
+export type OriginalScaleLimits = Record<string, OriginalLimits>;
+export type UpdatedScaleLimits = Record<string, ScaleRange>;
+export type HandlerFunctions = {
+    click: (chart: Chart, event: MouseEvent, options: ZoomPluginOptions) => void;
+    keydown: (chart: Chart, event: KeyboardEvent) => void;
+    mousedown: (chart: Chart, event: MouseEvent, options: ZoomPluginOptions) => void;
+    mousemove: (chart: Chart, event: MouseEvent, options: ZoomPluginOptions) => void;
+    mouseup: (chart: Chart, event: MouseEvent, options: ZoomPluginOptions) => void;
+    onZoomComplete: ({ chart }: {
+        chart: Chart;
+    }) => void;
+    wheel: (chart: Chart, event: WheelEvent) => void;
+};
+export type HandlerName = keyof HandlerFunctions;
+export type HandlerFunction = HandlerFunctions[HandlerName];
+export type Handler = EventListener;
+export type Handlers = Partial<Record<HandlerName, Handler>>;
+export type HandlerTarget = Partial<Record<HandlerName, HTMLCanvasElement | Document>>;
+export interface State {
+    originalScaleLimits: OriginalScaleLimits;
+    updatedScaleLimits: UpdatedScaleLimits;
+    handlers: Handlers;
+    targets: HandlerTarget;
+    panDelta: Record<string, number>;
+    dragging: boolean;
+    panning: boolean;
+    options: ZoomPluginOptions;
+    dragStart?: MouseEvent;
+    dragEnd?: MouseEvent;
+    filterNextClick?: boolean;
+    scale?: number | null;
+    delta?: Point | null;
+    panScales?: string[];
+}
+export declare function getState(chart: Chart): State;
+export declare function removeState(chart: Chart): void;
+//# sourceMappingURL=state.d.ts.map

package/dist/src/utils.d.ts

@@ -0,0 +1,14 @@
+import type { Chart, Point, Scale } from 'chart.js';
+import type { DragOptions, ModeOption, ModifierKey, PanOptions } from './options';
+export declare const getModifierKey: (opts?: DragOptions | PanOptions) => ModifierKey | undefined;
+export declare const keyPressed: (key: ModifierKey | undefined, event: TouchEvent | MouseEvent | PointerEvent) => boolean | undefined;
+export declare const keyNotPressed: (key: ModifierKey | undefined, event: TouchEvent | MouseEvent | PointerEvent) => boolean | undefined;
+export declare function directionEnabled(mode: ModeOption | undefined, dir: 'x' | 'y', chart: Chart): boolean;
+export declare function debounce(fn: () => void, delay: number | undefined): () => number | undefined;
+/**
+ * Evaluate the chart's mode, scaleMode, and overScaleMode properties to
+ * determine which axes are eligible for scaling.
+ * options.overScaleMode can be a function if user want zoom only one scale of many for example.
+ */
+export declare function getEnabledScalesByPoint(options: PanOptions | undefined, point: Point, chart: Chart): Scale[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thewhitehaven04/chartjs-plugin-zoom",
-  "version": "2.2.15",
+  "version": "2.2.16",
   "description": "A fork of the ChartJS Zoom plugin that enables zoom and pan functionality in Chart.js charts",
   "homepage": "https://www.chartjs.org/chartjs-plugin-zoom/",
   "repository": {
@@ -23,8 +23,7 @@
   },
   "files": [
     "dist/**/*.js",
-    "dist/src/index.d.ts",
-    "dist/src/types.d.ts",
+    "dist/src/*.d.ts",
     "dist/**/*.map"
   ],
   "scripts": {