@genome-spy/core 0.72.0 → 0.74.0

package/dist/src/utils/inferSpecBaseUrl.js

@@ -0,0 +1,73 @@
+const CURATED_EXAMPLE_BASES = [
+    ["/docs/examples/", "/docs/examples/"],
+    ["/examples/core/", "/examples/"],
+    ["/examples/docs/", "/examples/"],
+    ["/examples/app/", "/examples/"],
+];
+
+const EXTERNAL_URL_RE = /^(?:[a-z]+:)?\/\//i;
+const DUMMY_ORIGIN = "https://example.invalid";
+
+/**
+ * @param {string} url
+ */
+function getUrlKind(url) {
+    if (EXTERNAL_URL_RE.test(url)) {
+        return "external";
+    } else if (url.startsWith("/")) {
+        return "root";
+    } else {
+        return "relative";
+    }
+}
+
+/**
+ * @param {string} url
+ */
+export function getCuratedExampleBaseUrl(url) {
+    const parsed = new URL(url, DUMMY_ORIGIN);
+    const match = CURATED_EXAMPLE_BASES.find(([prefix]) =>
+        parsed.pathname.startsWith(prefix)
+    );
+
+    if (!match) {
+        return undefined;
+    }
+
+    return formatOutputUrl(match[1], parsed, getUrlKind(url));
+}
+
+/**
+ * Infers the effective base URL for a spec loaded from the given URL or path.
+ *
+ * Curated shared examples resolve against the examples root so they can use
+ * tidy `data/...` and `shared/...` paths regardless of their subdirectory.
+ *
+ * @param {string} url
+ */
+export default function inferSpecBaseUrl(url) {
+    const curatedBaseUrl = getCuratedExampleBaseUrl(url);
+    if (curatedBaseUrl) {
+        return curatedBaseUrl;
+    }
+
+    const parsed = new URL(url, DUMMY_ORIGIN);
+    const directoryUrl = new URL("./", parsed);
+
+    return formatOutputUrl(directoryUrl.pathname, parsed, getUrlKind(url));
+}
+
+/**
+ * @param {string} pathname
+ * @param {URL} parsed
+ * @param {"external" | "root" | "relative"} kind
+ */
+function formatOutputUrl(pathname, parsed, kind) {
+    if (kind === "external") {
+        return parsed.origin + pathname;
+    } else if (kind === "root") {
+        return pathname;
+    } else {
+        return pathname.slice(1);
+    }
+}

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

@@ -1,3 +1,47 @@
+/**
+ * @typedef {object} TouchGestureEvent
+ * @prop {"touchgesture"} type
+ * @prop {"move" | "end"} phase
+ * @prop {1 | 2} pointerCount
+ * @prop {number} xDelta
+ * @prop {number} yDelta
+ * @prop {number} zDelta
+ * @prop {() => void} [preventDefault]
+ */
+/**
+ * Side-effect-free query event for wheel ownership. Handlers should only
+ * claim wheel if they would consume native wheel at the current pointer
+ * location.
+ *
+ * @typedef {object} WheelClaimProbeEvent
+ * @prop {"wheelclaimprobe"} type
+ */
+/**
+ * @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.
@@ -7,38 +51,23 @@
  * @template T
  */
 export function createPrimitiveEventProxy<T>(target: T): T;
+export type TouchGestureEvent = {
+    type: "touchgesture";
+    phase: "move" | "end";
+    pointerCount: 1 | 2;
+    xDelta: number;
+    yDelta: number;
+    zDelta: number;
+    preventDefault?: () => void;
+};
 /**
- * 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 {UIEvent} uiEvent The event to be wrapped
-     */
-    constructor(point: import("../view/layout/point.js").default, uiEvent: UIEvent);
-    point: import("../view/layout/point.js").default;
-    uiEvent: UIEvent;
-    stopped: boolean;
-    /**
-     * The target is known only in the bubbling phase
-     *
-     * @type {import("../view/view.js").default}
-     */
-    target: import("../view/view.js").default;
-    stopPropagation(): 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;
-}
+ * Side-effect-free query event for wheel ownership. Handlers should only
+ * claim wheel if they would consume native wheel at the current pointer
+ * location.
+ */
+export type WheelClaimProbeEvent = {
+    type: "wheelclaimprobe";
+};
+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":"AA6DA;;;;;;;GAOG;AACH,0CAFa,CAAC,UAFH,CAAC,GACC,CAAC,CA0Eb;AA5ID;;;;GAIG;AACH;IAII;;;;OAIG;IACH,mBAJW,OAAO,yBAAyB,EAAE,OAAO,WAEzC,OAAO,EAajB;IAVG,iDAAkB;IAClB,iBAAsB;IACtB,iBAAoB;IAEpB;;;;OAIG;IACH,QAFU,OAAO,iBAAiB,EAAE,OAAO,CAEpB;IAG3B,wBAEC;IAED;;;;;;OAMG;IACH,YAFa,MAAM,CAIlB;IAED,oCAQC;IAED,6BAMC;;CACJ"}
+{"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"}

package/dist/src/utils/interactionEvent.js

@@ -1,62 +1,100 @@
 /**
- * This class wraps a MouseEvent (or similar) and allows for
- * its propagation through the view hierarchy in a similar manner
- * as in the DOM.
+ * @typedef {object} TouchGestureEvent
+ * @prop {"touchgesture"} type
+ * @prop {"move" | "end"} phase
+ * @prop {1 | 2} pointerCount
+ * @prop {number} xDelta
+ * @prop {number} yDelta
+ * @prop {number} zDelta
+ * @prop {() => void} [preventDefault]
  */
-export default class InteractionEvent {
-    /** @type {MouseEvent} */
-    #primitiveMouseEventProxy;
 
-    /**
-     * @param {import("../view/layout/point.js").default} point Event coordinates
-     *      inside the visualization canvas.
-     * @param {UIEvent} uiEvent The event to be wrapped
-     */
-    constructor(point, uiEvent) {
-        this.point = point;
-        this.uiEvent = uiEvent;
-        this.stopped = false;
+/**
+ * Side-effect-free query event for wheel ownership. Handlers should only
+ * claim wheel if they would consume native wheel at the current pointer
+ * location.
+ *
+ * @typedef {object} WheelClaimProbeEvent
+ * @prop {"wheelclaimprobe"} type
+ */
 
-        /**
-         * The target is known only in the bubbling phase
-         *
-         * @type {import("../view/view.js").default}
-         */
-        this.target = undefined;
-    }
+/**
+ * @typedef {Pick<
+ *      WheelEvent,
+ *      "type" | "deltaX" | "deltaY" | "deltaMode" | "preventDefault" | "ctrlKey"
+ * >} WheelLikeEvent
+ */
 
-    stopPropagation() {
-        this.stopped = true;
-    }
+/**
+ * @typedef {UIEvent | WheelLikeEvent | TouchGestureEvent | WheelClaimProbeEvent} InteractionUiEvent
+ */
 
-    /**
-     * 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() {
-        return this.uiEvent.type;
+/**
+ * @param {unknown} eventLike
+ * @returns {eventLike is TouchGestureEvent}
+ */
+export function isTouchGestureEvent(eventLike) {
+    if (!eventLike || typeof eventLike !== "object") {
+        return false;
     }
 
-    get proxiedMouseEvent() {
-        if (!this.#primitiveMouseEventProxy) {
-            this.#primitiveMouseEventProxy = createPrimitiveEventProxy(
-                this.mouseEvent
-            );
-        }
+    const candidate =
+        /** @type {{type?: unknown, phase?: unknown, pointerCount?: unknown, xDelta?: unknown, yDelta?: unknown, zDelta?: unknown}} */ (
+            eventLike
+        );
 
-        return this.#primitiveMouseEventProxy;
-    }
+    return (
+        candidate.type === "touchgesture" &&
+        (candidate.phase === "move" || candidate.phase === "end") &&
+        (candidate.pointerCount === 1 || candidate.pointerCount === 2) &&
+        Number.isFinite(candidate.xDelta) &&
+        Number.isFinite(candidate.yDelta) &&
+        Number.isFinite(candidate.zDelta)
+    );
+}
 
-    get mouseEvent() {
-        if (this.uiEvent instanceof MouseEvent) {
-            return this.uiEvent;
-        } else {
-            throw new Error("Not a MouseEvent!");
-        }
+/**
+ * @param {unknown} eventLike
+ * @returns {eventLike is WheelLikeEvent}
+ */
+export function isWheelEvent(eventLike) {
+    if (!eventLike || typeof eventLike !== "object") {
+        return false;
     }
+
+    const candidate =
+        /** @type {{type?: unknown, deltaX?: unknown, deltaY?: unknown, deltaMode?: unknown, preventDefault?: unknown}} */ (
+            eventLike
+        );
+
+    return (
+        candidate.type === "wheel" &&
+        Number.isFinite(candidate.deltaX) &&
+        Number.isFinite(candidate.deltaY) &&
+        Number.isFinite(candidate.deltaMode) &&
+        typeof candidate.preventDefault === "function"
+    );
+}
+
+/**
+ * @param {WheelLikeEvent} wheelEvent
+ * @param {number} deltaX
+ * @param {number} deltaY
+ * @returns {WheelLikeEvent}
+ */
+export function overrideWheelEventDeltas(wheelEvent, deltaX, deltaY) {
+    return new Proxy(wheelEvent, {
+        get(target, prop) {
+            if (prop === "deltaX") {
+                return deltaX;
+            } else if (prop === "deltaY") {
+                return deltaY;
+            }
+
+            const value = Reflect.get(target, prop, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
 }
 
 /**

package/dist/src/utils/kWayMerge.js

@@ -26,7 +26,7 @@ export default function kWayMerge(arrays, handler, accessor = (x) => +x) {
         }
     }
 
-    let i = 0;
+    let i;
     while ((i = heap.pop()) !== undefined) {
         const array = arrays[i];
         let pointer = pointers[i];

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

@@ -1 +1 @@
-{"version":3,"file":"mergeObjects.d.ts","sourceRoot":"","sources":["../../../src/utils/mergeObjects.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,qCAFa,CAAC,WAJF,CAAC,EAAE,cACJ,MAAM,SACN,MAAM,EAAE,GACN,CAAC,CAiFb"}
+{"version":3,"file":"mergeObjects.d.ts","sourceRoot":"","sources":["../../../src/utils/mergeObjects.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,qCAFa,CAAC,WAJF,CAAC,EAAE,cACJ,MAAM,SACN,MAAM,EAAE,GACN,CAAC,CAgFb"}