@genome-spy/core 0.73.0 → 0.74.0

package/dist/src/utils/expression.js

@@ -6,6 +6,7 @@ import {
     isObject,
     isRegExp,
     isString,
+    ascending,
     lerp,
 } from "vega-util";
 import { format as d3format } from "d3-format";
@@ -15,12 +16,63 @@ import linearstep from "./linearstep.js";
 
 /**
  * Some bits are adapted from https://github.com/vega/vega/blob/main/packages/vega-functions/src/codegen.js
+ *
+ * @param {unknown} value
+ * @returns {any}
+ */
+function array(value) {
+    return isArray(value) || ArrayBuffer.isView(value) ? value : null;
+}
+
+/**
+ * @param {unknown} value
+ * @returns {any}
  */
+function sequence(value) {
+    return array(value) || (isString(value) ? value : null);
+}
+
 const functionContext = {
     clamp,
     format(/** @type {number} */ value, /** @type {string} */ format) {
         return d3format(format)(value);
     },
+    /**
+     * Vega's expression docs list these as basic sequence helpers, but the
+     * bundled `vega-expression` version does not currently include them in the
+     * codegen whitelist. Implement them here so specs can rely on them.
+     */
+    join(/** @type {any} */ seq, /** @type {string} */ separator) {
+        return array(seq).join(separator);
+    },
+
+    indexof(
+        /** @type {any} */ seq,
+        /** @type {any} */ value,
+        /** @type {number | undefined} */ start
+    ) {
+        return sequence(seq).indexOf(value, start);
+    },
+
+    lastindexof(
+        /** @type {any} */ seq,
+        /** @type {any} */ value,
+        /** @type {number | undefined} */ start
+    ) {
+        return sequence(seq).lastIndexOf(value, start);
+    },
+
+    reverse(/** @type {any} */ seq) {
+        return array(seq).slice().reverse();
+    },
+
+    slice(
+        /** @type {any} */ seq,
+        /** @type {number} */ start,
+        /** @type {number | undefined} */ end
+    ) {
+        return sequence(seq).slice(start, end);
+    },
     mapHasKey(/** @type {Map<any, any>} */ map, /** @type {any} */ key) {
         return map.has(key);
     },
@@ -34,7 +86,6 @@ const functionContext = {
     isRegExp,
     isString,
     isValid(/** @type {any} */ _) {
-        // eslint-disable-next-line no-self-compare
         return _ != null && _ === _;
     },
     lerp,
@@ -46,6 +97,9 @@ const functionContext = {
     ) {
         return String(str).replace(pattern, replace);
     },
+    sort(/** @type {Array<any>} */ seq) {
+        return array(seq).slice().sort(ascending);
+    },
     smoothstep,
 };
 
@@ -54,7 +108,6 @@ const functionContext = {
  */
 function buildFunctions(codegen) {
     const fn = functions(codegen);
-    // eslint-disable-next-line guard-for-in
     for (const name in functionContext) {
         fn[name] = `this.${name}`;
     }
@@ -85,7 +138,6 @@ export default function createFunction(expr, globalObject = {}) {
         const parsed = parseExpression(expr);
         const generatedCode = cg(parsed);
 
-        // eslint-disable-next-line no-new-func
         const fn = Function(
             "datum",
             "globalObject",
@@ -108,7 +160,9 @@ export default function createFunction(expr, globalObject = {}) {
 
         return exprFunction;
     } catch (e) {
-        throw new Error(`Invalid expression: ${expr}, ${e.message}`);
+        throw new Error(`Invalid expression: ${expr}, ${e.message}`, {
+            cause: e,
+        });
     }
 }
 
@@ -120,14 +174,13 @@ const eventFilterCg = codegenExpression({
 
 /**
  * @param {string} expr
- * @returns {(event: UIEvent) => boolean}
+ * @returns {(event: UIEvent | import("./interactionEvent.js").WheelLikeEvent) => boolean}
  */
 export function createEventFilterFunction(expr) {
     try {
         const parsed = parseExpression(expr);
         const generatedCode = eventFilterCg(parsed);
 
-        // eslint-disable-next-line no-new-func
         const fn = Function(
             "event",
             "globalObject",
@@ -141,10 +194,12 @@ export function createEventFilterFunction(expr) {
             }`
         );
 
-        return /** @type {(event: UIEvent) => boolean} */ (
+        return /** @type {(event: UIEvent | import("./interactionEvent.js").WheelLikeEvent) => boolean} */ (
             /** @type {any} */ (fn)
         );
     } catch (e) {
-        throw new Error(`Invalid expression: ${expr}, ${e.message}`);
+        throw new Error(`Invalid expression: ${expr}, ${e.message}`, {
+            cause: e,
+        });
     }
 }

package/dist/src/utils/field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../../src/utils/field.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,iCAHW,MAAM,SACN,MAAM,uCAgChB"}
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../../src/utils/field.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,iCAHW,MAAM,SACN,MAAM,uCA+BhB"}

package/dist/src/utils/field.js

@@ -25,7 +25,6 @@ export function field(fieldExpr, name = fieldExpr) {
             }
         };
 
-        // eslint-disable-next-line no-new-func
         const fn = /** @type {import("vega-util").AccessorFn} */ (
             new Function(
                 "validator",

package/dist/src/utils/inertia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inertia.d.ts","sourceRoot":"","sources":["../../../src/utils/inertia.js"],"names":[],"mappings":"AAwEA;;;GAGG;AACH,kCAFa,CAAC,SADH,CAAC,iCAoBX;AAzFD;;GAEG;AACH;IACI;;;OAGG;IACH,sBAHW,OAAO,eAAe,EAAE,OAAO,aAC/B,OAAO,EA0BjB;IAvBG,0CAAwB;IACxB,kBAA0B;IAG1B,oBAAsB;IAEtB,oCAAoC;IACpC,UADW,CAAS,IAAM,EAAN,MAAM,KAAE,IAAI,CACZ;IAEpB,oBAAoB;IACpB,kBAAkB;IAElB;;;;MAUC;IAGL,eAQC;IAED;;;;OAIG;IACH,mBAHW,MAAM,YACN,CAAS,IAAM,EAAN,MAAM,KAAE,IAAI,QAkB/B;CACJ"}
+{"version":3,"file":"inertia.d.ts","sourceRoot":"","sources":["../../../src/utils/inertia.js"],"names":[],"mappings":"AAwEA;;;GAGG;AACH,kCAFa,CAAC,SADH,CAAC,iCAmBX;AAxFD;;GAEG;AACH;IACI;;;OAGG;IACH,sBAHW,OAAO,eAAe,EAAE,OAAO,aAC/B,OAAO,EA0BjB;IAvBG,0CAAwB;IACxB,kBAA0B;IAG1B,oBAAsB;IAEtB,oCAAoC;IACpC,UADW,CAAS,IAAM,EAAN,MAAM,KAAE,IAAI,CACZ;IAEpB,oBAAoB;IACpB,kBAAkB;IAElB;;;;MAUC;IAGL,eAQC;IAED;;;;OAIG;IACH,mBAHW,MAAM,YACN,CAAS,IAAM,EAAN,MAAM,KAAE,IAAI,QAkB/B;CACJ"}

package/dist/src/utils/inertia.js

@@ -80,7 +80,6 @@ export function makeEventTemplate(event) {
     const acceptedTypes = ["string", "number", "boolean"];
     const rejectedProps = ["wheelDelta", "wheelDeltaX", "wheelDeltaY"];
 
-    // eslint-disable-next-line guard-for-in
     for (const key in event) {
         const k = /** @type {keyof T} */ (key);
         if (

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

@@ -9,5 +9,5 @@ export default function createBindingInputs(mediator: {
     paramConfigs: ReadonlyMap<string, import("../spec/parameter.js").Parameter>;
     setValue: (name: string, value: any) => void;
     getValue: (name: string) => any;
-}): import("lit-html").TemplateResult<2 | 1 | 3>[];
+}): import("lit-html").TemplateResult<1 | 2 | 3>[];
 //# sourceMappingURL=inputBinding.d.ts.map

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

@@ -0,0 +1,109 @@
+/**
+ * Internal event object used by GenomeSpy's canvas interaction pipeline.
+ *
+ * Interaction is deliberately smaller than DOM Event. It models the pieces
+ * that GenomeSpy needs for hierarchical pointer handling:
+ * - `point` is always in canvas coordinates
+ * - `uiEvent` is the original native or synthesized low-level event
+ * - `target` is the resolved deepest view target after propagation
+ * - `currentTarget` and `relatedTarget` are used by synthesized
+ *   `mouseenter` / `mouseleave` delivery
+ *
+ * Runtime flow:
+ * 1. `InteractionController` converts native canvas events into Interaction
+ *    instances and asks `InteractionDispatcher` to route them.
+ * 2. Container views route the interaction through the view hierarchy and may
+ *    add policy on top, such as wheel claiming, zoom handling, or scrollbar
+ *    dispatch.
+ * 3. `InteractionDispatcher` compares successive hover paths and synthesizes
+ *    subtree-level `mouseenter` / `mouseleave` transitions.
+ *
+ * Differences from the DOM model:
+ * - propagation is view-driven rather than browser-driven
+ * - only the event types used by GenomeSpy are represented
+ * - there is only `stopPropagation()`, not stop-immediate semantics
+ * - mark picking is not encoded into `target`; mark hover lives separately in
+ *   `InteractionController`
+ *
+ * Mouse and wheel helpers:
+ * - `mouseEvent` exposes the underlying MouseEvent for imperative handlers
+ * - `proxiedMouseEvent` exposes only primitive properties for places that
+ *   must not retain live DOM objects
+ * - `wheelEvent` exposes the underlying wheel-like event, optionally with
+ *   temporary delta overrides applied by `setWheelDeltas()`
+ *
+ * Special event types:
+ * - `wheelclaimprobe` asks pointed views whether they would consume wheel,
+ *   without running the actual wheel side effects yet
+ * - `touchgesture` is a synthesized high-level gesture event derived from
+ *   touch input
+ */
+export default class Interaction {
+    /**
+     * @param {import("../view/layout/point.js").default} point
+     * @param {import("./interactionEvent.js").InteractionUiEvent} uiEvent
+     * @param {string} [type]
+     */
+    constructor(point: import("../view/layout/point.js").default, uiEvent: import("./interactionEvent.js").InteractionUiEvent, type?: string);
+    point: import("../view/layout/point.js").default;
+    stopped: boolean;
+    wheelClaimed: boolean;
+    /**
+     * The target is known only after the interaction has been resolved
+     * against the view hierarchy.
+     *
+     * @type {import("../view/view.js").default | undefined}
+     */
+    target: import("../view/view.js").default | undefined;
+    /**
+     * Reserved for the new interaction dispatcher.
+     *
+     * @type {import("../view/view.js").default | undefined}
+     */
+    currentTarget: import("../view/view.js").default | undefined;
+    /**
+     * Reserved for enter/leave-style transition events.
+     *
+     * @type {import("../view/view.js").default | undefined}
+     */
+    relatedTarget: import("../view/view.js").default | undefined;
+    set uiEvent(value: import("./interactionEvent.js").InteractionUiEvent);
+    get uiEvent(): import("./interactionEvent.js").InteractionUiEvent;
+    stopPropagation(): void;
+    /**
+     * Marks the current wheel interaction as claimed by the pointed view
+     * hierarchy.
+     *
+     * This is used both for real wheel events and for the synthetic
+     * `wheelclaimprobe` preflight. Controllers use the claimed state to decide
+     * whether the native wheel event should call `preventDefault()`.
+     */
+    claimWheel(): void;
+    /**
+     * @param {number} deltaX
+     * @param {number} deltaY
+     */
+    setWheelDeltas(deltaX: number, deltaY: number): void;
+    set type(value: string);
+    get type(): string;
+    /**
+     * Returns a primitive-only proxy of the underlying MouseEvent.
+     *
+     * This is intended for places such as expression evaluation, where the
+     * caller needs scalar event fields but should not receive a live DOM event
+     * object with methods, nested objects, or browser-specific prototypes.
+     */
+    get proxiedMouseEvent(): MouseEvent;
+    get mouseEvent(): MouseEvent;
+    /**
+     * Returns a wheel-like event with any temporary delta overrides applied.
+     *
+     * The wrapped event keeps the original event identity for all properties
+     * except `deltaX` and `deltaY`, which allows intermediate handlers to
+     * consume part of the wheel interaction while keeping downstream wheel
+     * handling on the same event instance.
+     */
+    get wheelEvent(): Pick<WheelEvent, "type" | "deltaX" | "deltaY" | "deltaMode" | "preventDefault" | "ctrlKey">;
+    #private;
+}
+//# sourceMappingURL=interaction.d.ts.map

package/dist/src/utils/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../../src/utils/interaction.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAOI;;;;OAIG;IACH,mBAJW,OAAO,yBAAyB,EAAE,OAAO,WACzC,OAAO,uBAAuB,EAAE,kBAAkB,SAClD,MAAM,EA8BhB;IA3BG,iDAAkB;IAElB,iBAAoB;IACpB,sBAAyB;IAGzB;;;;;OAKG;IACH,QAFU,OAAO,iBAAiB,EAAE,OAAO,GAAG,SAAS,CAEhC;IAEvB;;;;OAIG;IACH,eAFU,OAAO,iBAAiB,EAAE,OAAO,GAAG,SAAS,CAEzB;IAE9B;;;;OAIG;IACH,eAFU,OAAO,iBAAiB,EAAE,OAAO,GAAG,SAAS,CAEzB;IAclC,uEAKC;IATD,kEAEC;IASD,wBAEC;IAED;;;;;;;OAOG;IACH,mBAMC;IAED;;;OAGG;IACH,uBAHW,MAAM,UACN,MAAM,QAShB;IAMD,wBAEC;IAND,mBAEC;IAMD;;;;;;OAMG;IACH,oCAQC;IAED,6BAMC;IAED;;;;;;;OAOG;IACH,8GAkBC;;CACJ"}

package/dist/src/utils/interaction.js

@@ -0,0 +1,200 @@
+import {
+    createPrimitiveEventProxy,
+    isWheelEvent,
+    overrideWheelEventDeltas,
+} from "./interactionEvent.js";
+
+/**
+ * Internal event object used by GenomeSpy's canvas interaction pipeline.
+ *
+ * Interaction is deliberately smaller than DOM Event. It models the pieces
+ * that GenomeSpy needs for hierarchical pointer handling:
+ * - `point` is always in canvas coordinates
+ * - `uiEvent` is the original native or synthesized low-level event
+ * - `target` is the resolved deepest view target after propagation
+ * - `currentTarget` and `relatedTarget` are used by synthesized
+ *   `mouseenter` / `mouseleave` delivery
+ *
+ * Runtime flow:
+ * 1. `InteractionController` converts native canvas events into Interaction
+ *    instances and asks `InteractionDispatcher` to route them.
+ * 2. Container views route the interaction through the view hierarchy and may
+ *    add policy on top, such as wheel claiming, zoom handling, or scrollbar
+ *    dispatch.
+ * 3. `InteractionDispatcher` compares successive hover paths and synthesizes
+ *    subtree-level `mouseenter` / `mouseleave` transitions.
+ *
+ * Differences from the DOM model:
+ * - propagation is view-driven rather than browser-driven
+ * - only the event types used by GenomeSpy are represented
+ * - there is only `stopPropagation()`, not stop-immediate semantics
+ * - mark picking is not encoded into `target`; mark hover lives separately in
+ *   `InteractionController`
+ *
+ * Mouse and wheel helpers:
+ * - `mouseEvent` exposes the underlying MouseEvent for imperative handlers
+ * - `proxiedMouseEvent` exposes only primitive properties for places that
+ *   must not retain live DOM objects
+ * - `wheelEvent` exposes the underlying wheel-like event, optionally with
+ *   temporary delta overrides applied by `setWheelDeltas()`
+ *
+ * Special event types:
+ * - `wheelclaimprobe` asks pointed views whether they would consume wheel,
+ *   without running the actual wheel side effects yet
+ * - `touchgesture` is a synthesized high-level gesture event derived from
+ *   touch input
+ */
+export default class Interaction {
+    /** @type {MouseEvent} */
+    #primitiveMouseEventProxy;
+
+    /** @type {import("./interactionEvent.js").WheelLikeEvent | undefined} */
+    #wheelEventProxy;
+
+    /**
+     * @param {import("../view/layout/point.js").default} point
+     * @param {import("./interactionEvent.js").InteractionUiEvent} uiEvent
+     * @param {string} [type]
+     */
+    constructor(point, uiEvent, type) {
+        this.point = point;
+        this.#uiEvent = uiEvent;
+        this.stopped = false;
+        this.wheelClaimed = false;
+        this.#typeOverride = type;
+
+        /**
+         * The target is known only after the interaction has been resolved
+         * against the view hierarchy.
+         *
+         * @type {import("../view/view.js").default | undefined}
+         */
+        this.target = undefined;
+
+        /**
+         * Reserved for the new interaction dispatcher.
+         *
+         * @type {import("../view/view.js").default | undefined}
+         */
+        this.currentTarget = undefined;
+
+        /**
+         * Reserved for enter/leave-style transition events.
+         *
+         * @type {import("../view/view.js").default | undefined}
+         */
+        this.relatedTarget = undefined;
+    }
+
+    /** @type {import("./interactionEvent.js").InteractionUiEvent} */
+    #uiEvent;
+    /** @type {string | undefined} */
+    #typeOverride;
+    /** @type {{ deltaX: number, deltaY: number } | undefined} */
+    #wheelDeltaOverride;
+
+    get uiEvent() {
+        return this.#uiEvent;
+    }
+
+    set uiEvent(value) {
+        this.#uiEvent = value;
+        this.#primitiveMouseEventProxy = undefined;
+        this.#wheelEventProxy = undefined;
+        this.#wheelDeltaOverride = undefined;
+    }
+
+    stopPropagation() {
+        this.stopped = true;
+    }
+
+    /**
+     * Marks the current wheel interaction as claimed by the pointed view
+     * hierarchy.
+     *
+     * This is used both for real wheel events and for the synthetic
+     * `wheelclaimprobe` preflight. Controllers use the claimed state to decide
+     * whether the native wheel event should call `preventDefault()`.
+     */
+    claimWheel() {
+        if (this.type !== "wheel" && this.type !== "wheelclaimprobe") {
+            throw new Error("Can claim wheel only for wheel events!");
+        }
+
+        this.wheelClaimed = true;
+    }
+
+    /**
+     * @param {number} deltaX
+     * @param {number} deltaY
+     */
+    setWheelDeltas(deltaX, deltaY) {
+        if (!isWheelEvent(this.uiEvent)) {
+            throw new Error("Not a WheelEvent!");
+        }
+
+        this.#wheelDeltaOverride = { deltaX, deltaY };
+        this.#wheelEventProxy = undefined;
+    }
+
+    get type() {
+        return this.#typeOverride ?? this.uiEvent.type;
+    }
+
+    set type(value) {
+        this.#typeOverride = value;
+    }
+
+    /**
+     * Returns a primitive-only proxy of the underlying MouseEvent.
+     *
+     * This is intended for places such as expression evaluation, where the
+     * caller needs scalar event fields but should not receive a live DOM event
+     * object with methods, nested objects, or browser-specific prototypes.
+     */
+    get proxiedMouseEvent() {
+        if (!this.#primitiveMouseEventProxy) {
+            this.#primitiveMouseEventProxy = createPrimitiveEventProxy(
+                this.mouseEvent
+            );
+        }
+
+        return this.#primitiveMouseEventProxy;
+    }
+
+    get mouseEvent() {
+        if (this.uiEvent instanceof MouseEvent) {
+            return this.uiEvent;
+        } else {
+            throw new Error("Not a MouseEvent!");
+        }
+    }
+
+    /**
+     * Returns a wheel-like event with any temporary delta overrides applied.
+     *
+     * The wrapped event keeps the original event identity for all properties
+     * except `deltaX` and `deltaY`, which allows intermediate handlers to
+     * consume part of the wheel interaction while keeping downstream wheel
+     * handling on the same event instance.
+     */
+    get wheelEvent() {
+        if (!isWheelEvent(this.uiEvent)) {
+            throw new Error("Not a WheelEvent!");
+        }
+
+        if (!this.#wheelDeltaOverride) {
+            return this.uiEvent;
+        }
+
+        if (!this.#wheelEventProxy) {
+            this.#wheelEventProxy = overrideWheelEventDeltas(
+                this.uiEvent,
+                this.#wheelDeltaOverride.deltaX,
+                this.#wheelDeltaOverride.deltaY
+            );
+        }
+
+        return this.#wheelEventProxy;
+    }
+}

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

@@ -17,13 +17,31 @@
  * @prop {"wheelclaimprobe"} type
  */
 /**
- * @typedef {UIEvent | TouchGestureEvent | WheelClaimProbeEvent} InteractionUiEvent
+ * @typedef {Pick<
+ *      WheelEvent,
+ *      "type" | "deltaX" | "deltaY" | "deltaMode" | "preventDefault" | "ctrlKey"
+ * >} WheelLikeEvent
+ */
+/**
+ * @typedef {UIEvent | WheelLikeEvent | TouchGestureEvent | WheelClaimProbeEvent} InteractionUiEvent
  */
 /**
  * @param {unknown} eventLike
  * @returns {eventLike is TouchGestureEvent}
  */
 export function isTouchGestureEvent(eventLike: unknown): eventLike is TouchGestureEvent;
+/**
+ * @param {unknown} eventLike
+ * @returns {eventLike is WheelLikeEvent}
+ */
+export function isWheelEvent(eventLike: unknown): eventLike is WheelLikeEvent;
+/**
+ * @param {WheelLikeEvent} wheelEvent
+ * @param {number} deltaX
+ * @param {number} deltaY
+ * @returns {WheelLikeEvent}
+ */
+export function overrideWheelEventDeltas(wheelEvent: WheelLikeEvent, deltaX: number, deltaY: number): WheelLikeEvent;
 /**
  * Create a safe proxy for an event-like object that exposes only primitive
  * (string, number, boolean, bigint, symbol, undefined) properties and null.
@@ -33,46 +51,6 @@ export function isTouchGestureEvent(eventLike: unknown): eventLike is TouchGestu
  * @template T
  */
 export function createPrimitiveEventProxy<T>(target: T): T;
-/**
- * This class wraps a MouseEvent (or similar) and allows for
- * its propagation through the view hierarchy in a similar manner
- * as in the DOM.
- */
-export default class InteractionEvent {
-    /**
-     * @param {import("../view/layout/point.js").default} point Event coordinates
-     *      inside the visualization canvas.
-     * @param {InteractionUiEvent} uiEvent The event to be wrapped
-     */
-    constructor(point: import("../view/layout/point.js").default, uiEvent: InteractionUiEvent);
-    point: import("../view/layout/point.js").default;
-    uiEvent: InteractionUiEvent;
-    stopped: boolean;
-    wheelClaimed: boolean;
-    /**
-     * The target is known only in the bubbling phase
-     *
-     * @type {import("../view/view.js").default}
-     */
-    target: import("../view/view.js").default;
-    stopPropagation(): void;
-    /**
-     * Marks the event as wheel-owned by the current interaction path.
-     * This is used by native wheel probes to decide preventDefault timing.
-     */
-    claimWheel(): void;
-    /**
-     * The event type string of the underlying UI event (e.g. "click", "keydown").
-     *
-     * This getter proxies and returns the `type` property from the internal `UIEvent` instance (`this.uiEvent`).
-     *
-     * @returns {string} The UI event type.
-     */
-    get type(): string;
-    get proxiedMouseEvent(): MouseEvent;
-    get mouseEvent(): MouseEvent;
-    #private;
-}
 export type TouchGestureEvent = {
     type: "touchgesture";
     phase: "move" | "end";
@@ -90,5 +68,6 @@ export type TouchGestureEvent = {
 export type WheelClaimProbeEvent = {
     type: "wheelclaimprobe";
 };
-export type InteractionUiEvent = UIEvent | TouchGestureEvent | WheelClaimProbeEvent;
+export type WheelLikeEvent = Pick<WheelEvent, "type" | "deltaX" | "deltaY" | "deltaMode" | "preventDefault" | "ctrlKey">;
+export type InteractionUiEvent = UIEvent | WheelLikeEvent | TouchGestureEvent | WheelClaimProbeEvent;
 //# sourceMappingURL=interactionEvent.d.ts.map

package/dist/src/utils/interactionEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interactionEvent.d.ts","sourceRoot":"","sources":["../../../src/utils/interactionEvent.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AAEH;;GAEG;AAEH;;;GAGG;AACH,+CAHW,OAAO,GACL,SAAS,IAAI,iBAAiB,CAoB1C;AA4ED;;;;;;;GAOG;AACH,0CAFa,CAAC,UAFH,CAAC,GACC,CAAC,CA0Eb;AAzJD;;;;GAIG;AACH;IAII;;;;OAIG;IACH,mBAJW,OAAO,yBAAyB,EAAE,OAAO,WAEzC,kBAAkB,EAc5B;IAXG,iDAAkB;IAClB,4BAAsB;IACtB,iBAAoB;IACpB,sBAAyB;IAEzB;;;;OAIG;IACH,QAFU,OAAO,iBAAiB,EAAE,OAAO,CAEpB;IAG3B,wBAEC;IAED;;;OAGG;IACH,mBAMC;IAED;;;;;;OAMG;IACH,YAFa,MAAM,CAIlB;IAED,oCAQC;IAED,6BAMC;;CACJ;;UAtHS,cAAc;WACd,MAAM,GAAG,KAAK;kBACd,CAAC,GAAG,CAAC;YACL,MAAM;YACN,MAAM;YACN,MAAM;qBACN,MAAM,IAAI;;;;;;;;UASV,iBAAiB;;iCAId,OAAO,GAAG,iBAAiB,GAAG,oBAAoB"}
+{"version":3,"file":"interactionEvent.d.ts","sourceRoot":"","sources":["../../../src/utils/interactionEvent.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AAEH;;;;;GAKG;AAEH;;GAEG;AAEH;;;GAGG;AACH,+CAHW,OAAO,GACL,SAAS,IAAI,iBAAiB,CAoB1C;AAED;;;GAGG;AACH,wCAHW,OAAO,GACL,SAAS,IAAI,cAAc,CAmBvC;AAED;;;;;GAKG;AACH,qDALW,cAAc,UACd,MAAM,UACN,MAAM,GACJ,cAAc,CAe1B;AAED;;;;;;;GAOG;AACH,0CAFa,CAAC,UAFH,CAAC,GACC,CAAC,CA0Eb;;UAhLS,cAAc;WACd,MAAM,GAAG,KAAK;kBACd,CAAC,GAAG,CAAC;YACL,MAAM;YACN,MAAM;YACN,MAAM;qBACN,MAAM,IAAI;;;;;;;;UASV,iBAAiB;;6BAId,IAAI,CACT,UAAU,EACjB,MAAa,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,GAAG,gBAAgB,GAAG,SAAS,CAC7E;iCAIS,OAAO,GAAG,cAAc,GAAG,iBAAiB,GAAG,oBAAoB"}