@msobiecki/react-marauders-path 1.28.0 → 1.30.0

package/README.md

@@ -2,13 +2,15 @@
 
 [![License](https://img.shields.io/badge/license-%20%20GNU%20GPLv3%20-green.svg)](https://github.com/msobiecki/react-marauders-path/blob/master/LICENSE)
 
-A lightweight, type-safe React library for handling keyboard, wheel, and gesture events including tap, double-tap, press, swipe, drag, and pinch interactions.
+A lightweight, type-safe React library for handling keyboard, pointer, mouse, wheel, and gesture events including tap, double-tap, press, swipe, drag, and pinch interactions.
 
 ![react-marauders-path](./docs/images/logotype.png)
 
 ## Features
 
 - 🎮 **Keyboard Event Handling** - Detect single keys, key combinations, and sequences with configurable timing thresholds
+- 🖱️ **Pointer Event Handling** - Listen to pointer movement and lifecycle events with pointer type filtering
+- 🖱️ **Mouse Event Handling** - Listen to mouse interactions through a pointer-powered mouse API with button filtering
 - 👐 **Gesture Event Handling** - Detect tap, double-tap, press, swipe, drag, and pinch gestures
   - 👆 **Tap Gesture Handling** - Detect single taps or clicks with configurable movement and duration thresholds
   - 👆👆 **Double-Tap Gesture Handling** - Detect consecutive taps or clicks with configurable timing and position thresholds
@@ -85,6 +87,39 @@ useKey(
 );
 ```
 
+### Pointer Event Hook
+
+```typescript
+import { usePointer, PointerEventTypes } from '@msobiecki/react-marauders-path';
+
+function MyComponent() {
+  usePointer((event, type, data) => {
+    console.log(`Pointer ${type} at X: ${data.x}, Y: ${data.y}`);
+  }, {
+    eventType: [PointerEventTypes.Down, PointerEventTypes.Move, PointerEventTypes.Up],
+  });
+
+  return <div>Use pointer input</div>;
+}
+```
+
+### Mouse Event Hook
+
+```typescript
+import { useMouse, MouseEventTypes, MouseButtons } from '@msobiecki/react-marauders-path';
+
+function MyComponent() {
+  useMouse((event, type, data) => {
+    console.log(`Mouse ${type} at X: ${data.x}, Y: ${data.y}, button: ${data.button}`);
+  }, {
+    eventType: [MouseEventTypes.Move, MouseEventTypes.Click, MouseEventTypes.DoubleClick],
+    eventButtons: [MouseButtons.Left],
+  });
+
+  return <div>Use mouse input</div>;
+}
+```
+
 ### Gesture Event Hook
 
 ```typescript
@@ -226,6 +261,69 @@ interface UseKeyOptions {
 }
 ```
 
+### `usePointer(callback, options?)`
+
+Hook for handling pointer events with configurable event types, pointer types, and listener options.
+
+**Parameters:**
+
+- `callback: (event: PointerEvent, type: PointerEventType, data: PointerData) => void | boolean` - Called when a pointer event occurs
+- `options?: UsePointerOptions` - Optional configuration
+
+**Options:**
+
+```typescript
+interface UsePointerOptions {
+  eventType?: PointerEventType[]; // Default: ["pointermove", "pointerenter", "pointerleave", "pointerup", "pointerdown", "pointerover", "pointerout", "pointercancel"]
+  eventPointerTypes?: Array<"touch" | "mouse" | "pen">; // Default: ["touch", "mouse", "pen"]
+  eventCapture?: boolean; // Default: false
+  eventOnce?: boolean; // Default: false
+  eventStopImmediatePropagation?: boolean; // Default: false
+  container?: RefObject<HTMLElement>; // Default: window
+}
+```
+
+**Pointer Data:**
+
+```typescript
+interface PointerData {
+  x: number; // Pointer X position
+  y: number; // Pointer Y position
+}
+```
+
+### `useMouse(callback, options?)`
+
+Hook for handling mouse-like events through pointer events with button filtering and synthesized click/double-click support.
+
+**Parameters:**
+
+- `callback: (event: MouseEvent, type: MouseEventType, data: MouseData) => void | boolean` - Called when a mouse event occurs
+- `options?: UseMouseOptions` - Optional configuration
+
+**Options:**
+
+```typescript
+interface UseMouseOptions {
+  eventType?: MouseEventType[]; // Default: ["mousemove", "mousedown", "mouseup", "click", "dblclick"]
+  eventButtons?: Array<0 | 1 | 2 | 3 | 4>; // Default: [0, 1, 2]
+  eventCapture?: boolean; // Default: false
+  eventOnce?: boolean; // Default: false
+  eventStopImmediatePropagation?: boolean; // Default: false
+  container?: RefObject<HTMLElement>; // Default: window
+}
+```
+
+**Mouse Data:**
+
+```typescript
+interface MouseData {
+  x: number; // Mouse X position
+  y: number; // Mouse Y position
+  button: 0 | 1 | 2 | 3 | 4; // Active mouse button
+}
+```
+
 ### `useGesture(gesture, callback, options?)`
 
 Hook for gesture event handling that delegates to one of the low-level gesture hooks.
@@ -588,32 +686,6 @@ npm run dev
 npm run lint
 ```
 
-## Project Status
-
-### High-level Gesture Hook
-
-- ✅ **`useGesture`** – high-level API for gesture handling
-  Supported gestures:
-  - `tap` – single tap / click
-  - `doubletap` – quick double tap
-  - `press` – press and hold
-  - `swipe` – directional swipe
-  - `drag` – track movement of finger or mouse
-  - `pinch` – two-finger pinch / zoom
-
-### Pointer / Mouse Hooks (Unified)
-
-- 🚧 **`usePointer`** – unified hook for MouseEvent, PointerEvent, and TouchEvent  
-  Supported events:
-  - `pointerdown`, `pointermove`, `pointerup`, `pointerenter`, `pointerleave`, `pointercancel`  
-    Filter by pointer type: `mouse` | `touch` | `pen`  
-    Callback returns unified data e.g.: `x`, `y`, `button`, `type`, `isPrimary`
-
-- 🚧 **`useMouse`** – alias for `usePointer` filtered to mouse only  
-  Supported events:
-  - `mousemove`, `mousedown`, `mouseup`, `click`, `dblclick`  
-    Buttons: `left`, `right`, `middle`
-
 ## License
 
 See [LICENSE](./LICENSE) file for details.

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-import { RefObject } from 'react';
-
 export declare interface CombinationActiveKey {
     pressedAt: number;
     releasedAt?: number;
@@ -61,7 +59,7 @@ export declare interface DragOptions {
     eventStopImmediatePropagation: boolean;
     threshold: number;
     container: {
-        current: HTMLElement | null;
+        current: EventTarget | null;
     };
     raf: boolean;
 }
@@ -107,7 +105,50 @@ export declare interface KeyOptions {
     eventStopImmediatePropagation: boolean;
     sequenceThreshold: number;
     combinationThreshold: number;
-    container: RefObject<HTMLElement | null>;
+    container: {
+        current: EventTarget | null;
+    };
+}
+
+export declare type MouseButton = (typeof MouseButtons)[keyof typeof MouseButtons];
+
+export declare const MouseButtons: {
+    readonly Left: 0;
+    readonly Middle: 1;
+    readonly Right: 2;
+    readonly Fourth: 3;
+    readonly Fifth: 4;
+};
+
+export declare interface MouseData {
+    x: number;
+    y: number;
+}
+
+export declare type MouseEventType = (typeof MouseEventTypes)[keyof typeof MouseEventTypes];
+
+export declare const MouseEventTypes: {
+    readonly Click: "click";
+    readonly ContextMenu: "contextmenu";
+    readonly DoubleClick: "dblclick";
+    readonly Down: "mousedown";
+    readonly Enter: "mouseenter";
+    readonly Leave: "mouseleave";
+    readonly Move: "mousemove";
+    readonly Out: "mouseout";
+    readonly Over: "mouseover";
+    readonly Up: "mouseup";
+};
+
+export declare interface MouseOptions {
+    eventType: MouseEventType[];
+    eventButtons: MouseButton[];
+    eventCapture: boolean;
+    eventOnce: boolean;
+    eventStopImmediatePropagation: boolean;
+    container: {
+        current: EventTarget | null;
+    };
 }
 
 export declare interface PinchData {
@@ -132,7 +173,7 @@ export declare interface PinchOptions {
     eventStopImmediatePropagation: boolean;
     threshold: number;
     container: {
-        current: HTMLElement | null;
+        current: EventTarget | null;
     };
     raf: boolean;
 }
@@ -144,6 +185,43 @@ export declare interface PinchState {
     active: boolean;
 }
 
+export declare interface PointerData {
+    x: number;
+    y: number;
+}
+
+export declare type PointerEventPointerType = (typeof PointerEventPointerTypes)[keyof typeof PointerEventPointerTypes];
+
+export declare const PointerEventPointerTypes: {
+    readonly Touch: "touch";
+    readonly Mouse: "mouse";
+    readonly Pen: "pen";
+};
+
+export declare type PointerEventType = (typeof PointerEventTypes)[keyof typeof PointerEventTypes];
+
+export declare const PointerEventTypes: {
+    readonly Move: "pointermove";
+    readonly Enter: "pointerenter";
+    readonly Leave: "pointerleave";
+    readonly Up: "pointerup";
+    readonly Down: "pointerdown";
+    readonly Over: "pointerover";
+    readonly Out: "pointerout";
+    readonly Cancel: "pointercancel";
+};
+
+export declare interface PointerOptions {
+    eventType: PointerEventType[];
+    eventPointerTypes: PointerEventPointerType[];
+    eventCapture: boolean;
+    eventOnce: boolean;
+    eventStopImmediatePropagation: boolean;
+    container: {
+        current: EventTarget | null;
+    };
+}
+
 export declare interface PressData {
     x: number;
     y: number;
@@ -211,7 +289,7 @@ export declare interface SwipeOptions {
     threshold: number;
     velocity: number;
     container: {
-        current: HTMLElement | null;
+        current: EventTarget | null;
     };
 }
 
@@ -362,12 +440,24 @@ export declare type UseKeyOptions = Partial<KeyOptions>;
 
 export declare type UseKeySchema = KeyEvent;
 
+export declare const useMouse: (mouseCallback: UseMouseCallback, options?: UseMouseOptions) => void;
+
+export declare type UseMouseCallback = ((event: MouseEvent, type: MouseEventType, button: MouseButton, data: MouseData, ...properties: unknown[]) => void) | ((event: MouseEvent, type: MouseEventType, button: MouseButton, data: MouseData, ...properties: unknown[]) => boolean);
+
+export declare type UseMouseOptions = Partial<MouseOptions>;
+
 export declare const usePinch: (pinchCallback: UsePinchCallback, options?: UsePinchOptions) => void;
 
 export declare type UsePinchCallback = ((event: PointerEvent, data: PinchData) => boolean) | ((event: PointerEvent, data: PinchData) => void);
 
 export declare type UsePinchOptions = Partial<PinchOptions>;
 
+export declare const usePointer: (pointerCallback: UsePointerCallback, options?: UsePointerOptions) => void;
+
+export declare type UsePointerCallback = ((event: PointerEvent, type: PointerEventType, data: PointerData, ...properties: unknown[]) => void) | ((event: PointerEvent, type: PointerEventType, data: PointerData, ...properties: unknown[]) => boolean);
+
+export declare type UsePointerOptions = Partial<PointerOptions>;
+
 export declare const usePress: (pressCallback: UsePressCallback, options?: UsePressOptions) => void;
 
 export declare type UsePressCallback = ((event: PointerEvent, data: PressData) => void) | ((event: PointerEvent, data: PressData) => boolean);
@@ -390,7 +480,7 @@ export declare type UseTapOptions = Partial<TapOptions>;
 
 export declare const useWheel: (wheelCallback: UseWheelCallback, options?: UseWheelOptions) => void;
 
-export declare type UseWheelCallback = ((event: WheelEvent, delta: WheelData, ...properties: unknown[]) => void) | ((event: WheelEvent, delta: WheelData, ...properties: unknown[]) => boolean);
+export declare type UseWheelCallback = ((event: WheelEvent, data: WheelData, ...properties: unknown[]) => void) | ((event: WheelEvent, data: WheelData, ...properties: unknown[]) => boolean);
 
 export declare type UseWheelOptions = Partial<WheelOptions>;
 
@@ -407,7 +497,7 @@ export declare interface WheelOptions {
     eventOnce: boolean;
     eventStopImmediatePropagation: boolean;
     container: {
-        current: HTMLElement | null;
+        current: EventTarget | null;
     };
     raf: boolean;
 }

package/dist/index.js

@@ -1,38 +1,48 @@
-import { default as o } from "./use-double-tap/use-double-tap.js";
+import { default as r } from "./use-double-tap/use-double-tap.js";
 import { DoubleTapEventPointerTypes as s } from "./use-double-tap/use-double-tap.types.js";
 import { default as f } from "./use-drag/use-drag.js";
-import { DragEventPointerTypes as u } from "./use-drag/use-drag.types.js";
-import { default as x } from "./use-gesture/use-gesture.js";
+import { DragEventPointerTypes as a } from "./use-drag/use-drag.types.js";
+import { default as m } from "./use-gesture/use-gesture.js";
 import { GestureTypes as i } from "./use-gesture/use-gesture.types.js";
-import { default as T } from "./use-key/use-key.js";
-import { KeyEventTypes as P } from "./use-key/use-key.types.js";
-import { default as v } from "./use-pinch/use-pinch.js";
-import { PinchEventPointerTypes as D } from "./use-pinch/use-pinch.types.js";
-import { default as h } from "./use-press/use-press.js";
-import { PressEventPointerTypes as S } from "./use-press/use-press.types.js";
-import { default as g } from "./use-swipe/use-swipe.js";
-import { SwipeDirections as K, SwipeEventPointerTypes as W } from "./use-swipe/use-swipe.types.js";
-import { default as k } from "./use-tap/use-tap.js";
-import { TapEventPointerTypes as z } from "./use-tap/use-tap.types.js";
-import { default as B } from "./use-wheel/use-wheel.js";
+import { default as l } from "./use-key/use-key.js";
+import { KeyEventTypes as y } from "./use-key/use-key.types.js";
+import { default as v } from "./use-mouse/use-mouse.js";
+import { MouseButtons as D, MouseEventTypes as c } from "./use-mouse/use-mouse.types.js";
+import { default as w } from "./use-pinch/use-pinch.js";
+import { PinchEventPointerTypes as S } from "./use-pinch/use-pinch.types.js";
+import { default as g } from "./use-pointer/use-pointer.js";
+import { PointerEventPointerTypes as K, PointerEventTypes as B } from "./use-pointer/use-pointer.types.js";
+import { default as j } from "./use-press/use-press.js";
+import { PressEventPointerTypes as q } from "./use-press/use-press.types.js";
+import { default as A } from "./use-swipe/use-swipe.js";
+import { SwipeDirections as F, SwipeEventPointerTypes as H } from "./use-swipe/use-swipe.types.js";
+import { default as J } from "./use-tap/use-tap.js";
+import { TapEventPointerTypes as N } from "./use-tap/use-tap.types.js";
+import { default as Q } from "./use-wheel/use-wheel.js";
 export {
   s as DoubleTapEventPointerTypes,
-  u as DragEventPointerTypes,
+  a as DragEventPointerTypes,
   i as GestureTypes,
-  P as KeyEventTypes,
-  D as PinchEventPointerTypes,
-  S as PressEventPointerTypes,
-  K as SwipeDirections,
-  W as SwipeEventPointerTypes,
-  z as TapEventPointerTypes,
-  o as useDoubleTap,
+  y as KeyEventTypes,
+  D as MouseButtons,
+  c as MouseEventTypes,
+  S as PinchEventPointerTypes,
+  K as PointerEventPointerTypes,
+  B as PointerEventTypes,
+  q as PressEventPointerTypes,
+  F as SwipeDirections,
+  H as SwipeEventPointerTypes,
+  N as TapEventPointerTypes,
+  r as useDoubleTap,
   f as useDrag,
-  x as useGesture,
-  T as useKey,
-  v as usePinch,
-  h as usePress,
-  g as useSwipe,
-  k as useTap,
-  B as useWheel
+  m as useGesture,
+  l as useKey,
+  v as useMouse,
+  w as usePinch,
+  g as usePointer,
+  j as usePress,
+  A as useSwipe,
+  J as useTap,
+  Q as useWheel
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;"}

package/dist/use-double-tap/event-guards.js

@@ -0,0 +1,7 @@
+const n = (e, r) => !(!e.isPrimary || !r.eventPointerTypes.includes(
+  e.pointerType
+));
+export {
+  n as shouldHandleEvent
+};
+//# sourceMappingURL=event-guards.js.map

package/dist/use-double-tap/event-guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-guards.js","sources":["../../src/use-double-tap/event-guards.ts"],"sourcesContent":["import { DoubleTapEventPointerType } from \"./use-double-tap.types\";\n\n/**\n * Determines whether a pointer event should be handled based on event options.\n *\n * @param {PointerEvent} event - The pointer event to evaluate\n * @param {Object} options - Event handling options\n * @param {DoubleTapEventPointerType[]} options.eventPointerTypes - Allowed pointer types for the event\n * @returns {boolean} True if the event should be handled, false otherwise\n *\n * @example\n * const shouldHandle = shouldHandleEvent(event, {\n *   eventPointerTypes: [DoubleTapEventPointerTypes.Touch]\n * });\n */\nexport const shouldHandleEvent = (\n  event: PointerEvent,\n  options: {\n    eventPointerTypes: DoubleTapEventPointerType[];\n  },\n) => {\n  if (!event.isPrimary) {\n    return false;\n  }\n  if (\n    !options.eventPointerTypes.includes(\n      event.pointerType as DoubleTapEventPointerType,\n    )\n  ) {\n    return false;\n  }\n\n  return true;\n};\n"],"names":["shouldHandleEvent","event","options"],"mappings":"AAeO,MAAMA,IAAoB,CAC/BC,GACAC,MAII,GAACD,EAAM,aAIT,CAACC,EAAQ,kBAAkB;AAAA,EACzBD,EAAM;AAAA;"}

package/dist/use-double-tap/use-double-tap.js

@@ -1,27 +1,33 @@
-import { useRef as c, useCallback as g, useEffect as x } from "react";
+import { useRef as c, useCallback as x, useEffect as E } from "react";
+import { DoubleTapEventPointerTypes as l } from "./use-double-tap.types.js";
 import { invokeDoubleTapAction as X } from "./invoke-double-tap-action.js";
-const Y = {
-  eventPointerTypes: ["touch", "mouse", "pen"],
+import { shouldHandleEvent as Y } from "./event-guards.js";
+const C = {
+  eventPointerTypes: [
+    l.Touch,
+    l.Mouse,
+    l.Pen
+  ],
   eventCapture: !1,
   eventOnce: !1,
   eventStopImmediatePropagation: !1,
   delay: 300,
   threshold: 8,
   container: { current: null }
-}, R = (i, h = {}) => {
+}, w = (a, T = {}) => {
   const {
-    eventPointerTypes: l,
+    eventPointerTypes: i,
     eventCapture: u,
-    eventOnce: a,
-    eventStopImmediatePropagation: s,
-    delay: p,
-    threshold: f,
+    eventOnce: s,
+    eventStopImmediatePropagation: p,
+    delay: f,
+    threshold: m,
     container: d
-  } = { ...Y, ...h }, m = c(null), r = c(null), t = c(null), y = g(
+  } = { ...C, ...T }, h = c(null), r = c(null), t = c(null), y = x(
     (e) => {
-      if (!e.isPrimary || !l.includes(
-        e.pointerType
-      ))
+      if (!Y(e, {
+        eventPointerTypes: i
+      }))
         return;
       const n = Date.now();
       if (!t.current) {
@@ -32,15 +38,15 @@ const Y = {
         };
         return;
       }
-      const o = n - t.current.time, P = e.clientX - t.current.x, T = e.clientY - t.current.y;
-      if (o <= p && Math.hypot(P, T) <= f) {
-        const b = {
+      const o = n - t.current.time, P = e.clientX - t.current.x, b = e.clientY - t.current.y;
+      if (o <= f && Math.hypot(P, b) <= m) {
+        const g = {
           x: e.clientX,
           y: e.clientY
         };
-        X(e, b, i, {
-          stopImmediate: s,
-          once: a,
+        X(e, g, a, {
+          stopImmediate: p,
+          once: s,
           onOnce: () => r.current?.abort()
         }), t.current = null;
         return;
@@ -53,17 +59,17 @@ const Y = {
     },
     [
       i,
+      s,
       p,
       f,
-      l,
-      a,
-      s
+      m,
+      a
     ]
   );
-  x(() => {
-    m.current = d?.current ?? globalThis, r.current = new AbortController();
+  E(() => {
+    h.current = d?.current ?? globalThis, r.current = new AbortController();
     const { signal: e } = r.current, n = (o) => o instanceof PointerEvent && y(o);
-    return m.current.addEventListener("pointerup", n, {
+    return h.current.addEventListener("pointerup", n, {
       capture: u,
       signal: e
     }), () => {
@@ -72,6 +78,6 @@ const Y = {
   }, [d, u, y]);
 };
 export {
-  R as default
+  w as default
 };
 //# sourceMappingURL=use-double-tap.js.map

package/dist/use-double-tap/use-double-tap.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-double-tap.js","sources":["../../src/use-double-tap/use-double-tap.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from \"react\";\nimport {\n  DoubleTapOptions,\n  UseDoubleTapCallback,\n  UseDoubleTapOptions,\n  DoubleTapEventPointerType,\n  DoubleTapData,\n} from \"./use-double-tap.types\";\nimport { invokeDoubleTapAction } from \"./invoke-double-tap-action\";\n\nconst defaultOptions: DoubleTapOptions = {\n  eventPointerTypes: [\"touch\", \"mouse\", \"pen\"],\n  eventCapture: false,\n  eventOnce: false,\n  eventStopImmediatePropagation: false,\n  delay: 300,\n  threshold: 8,\n  container: { current: null },\n};\n\nconst useDoubleTap = (\n  doubleTapCallback: UseDoubleTapCallback,\n  options: UseDoubleTapOptions = {},\n) => {\n  const {\n    eventPointerTypes,\n    eventCapture,\n    eventOnce,\n    eventStopImmediatePropagation,\n    delay,\n    threshold,\n    container,\n  } = { ...defaultOptions, ...options };\n\n  const targetReference = useRef<EventTarget | null>(null);\n  const abortControllerReference = useRef<AbortController | null>(null);\n\n  const lastTapReference = useRef<{\n    time: number;\n    x: number;\n    y: number;\n  } | null>(null);\n\n  const handlePointerUp = useCallback(\n    (event: PointerEvent) => {\n      if (!event.isPrimary) {\n        return;\n      }\n      if (\n        !eventPointerTypes.includes(\n          event.pointerType as DoubleTapEventPointerType,\n        )\n      ) {\n        return;\n      }\n\n      const now = Date.now();\n\n      if (!lastTapReference.current) {\n        lastTapReference.current = {\n          time: now,\n          x: event.clientX,\n          y: event.clientY,\n        };\n        return;\n      }\n\n      const deltaTime = now - lastTapReference.current.time;\n      const deltaX = event.clientX - lastTapReference.current.x;\n      const deltaY = event.clientY - lastTapReference.current.y;\n\n      if (deltaTime <= delay && Math.hypot(deltaX, deltaY) <= threshold) {\n        const data: DoubleTapData = {\n          x: event.clientX,\n          y: event.clientY,\n        };\n\n        invokeDoubleTapAction(event, data, doubleTapCallback, {\n          stopImmediate: eventStopImmediatePropagation,\n          once: eventOnce,\n          onOnce: () => abortControllerReference.current?.abort(),\n        });\n\n        lastTapReference.current = null;\n        return;\n      }\n\n      lastTapReference.current = {\n        time: now,\n        x: event.clientX,\n        y: event.clientY,\n      };\n    },\n    [\n      doubleTapCallback,\n      delay,\n      threshold,\n      eventPointerTypes,\n      eventOnce,\n      eventStopImmediatePropagation,\n    ],\n  );\n\n  useEffect(() => {\n    targetReference.current = container?.current ?? globalThis;\n    abortControllerReference.current = new AbortController();\n    const { signal } = abortControllerReference.current;\n\n    const pointerUpListener = (event: Event) =>\n      event instanceof PointerEvent && handlePointerUp(event);\n\n    targetReference.current.addEventListener(\"pointerup\", pointerUpListener, {\n      capture: eventCapture,\n      signal,\n    });\n\n    return () => {\n      abortControllerReference.current?.abort();\n      lastTapReference.current = null;\n    };\n  }, [container, eventCapture, handlePointerUp]);\n};\n\nexport default useDoubleTap;\n"],"names":["defaultOptions","useDoubleTap","doubleTapCallback","options","eventPointerTypes","eventCapture","eventOnce","eventStopImmediatePropagation","delay","threshold","container","targetReference","useRef","abortControllerReference","lastTapReference","handlePointerUp","useCallback","event","now","deltaTime","deltaX","deltaY","data","invokeDoubleTapAction","useEffect","signal","pointerUpListener"],"mappings":";;AAUA,MAAMA,IAAmC;AAAA,EACvC,mBAAmB,CAAC,SAAS,SAAS,KAAK;AAAA,EAC3C,cAAc;AAAA,EACd,WAAW;AAAA,EACX,+BAA+B;AAAA,EAC/B,OAAO;AAAA,EACP,WAAW;AAAA,EACX,WAAW,EAAE,SAAS,KAAA;AACxB,GAEMC,IAAe,CACnBC,GACAC,IAA+B,OAC5B;AACH,QAAM;AAAA,IACJ,mBAAAC;AAAA,IACA,cAAAC;AAAA,IACA,WAAAC;AAAA,IACA,+BAAAC;AAAA,IACA,OAAAC;AAAA,IACA,WAAAC;AAAA,IACA,WAAAC;AAAA,EAAA,IACE,EAAE,GAAGV,GAAgB,GAAGG,EAAA,GAEtBQ,IAAkBC,EAA2B,IAAI,GACjDC,IAA2BD,EAA+B,IAAI,GAE9DE,IAAmBF,EAIf,IAAI,GAERG,IAAkBC;AAAA,IACtB,CAACC,MAAwB;AAIvB,UAHI,CAACA,EAAM,aAIT,CAACb,EAAkB;AAAA,QACjBa,EAAM;AAAA,MAAA;AAGR;AAGF,YAAMC,IAAM,KAAK,IAAA;AAEjB,UAAI,CAACJ,EAAiB,SAAS;AAC7B,QAAAA,EAAiB,UAAU;AAAA,UACzB,MAAMI;AAAA,UACN,GAAGD,EAAM;AAAA,UACT,GAAGA,EAAM;AAAA,QAAA;AAEX;AAAA,MACF;AAEA,YAAME,IAAYD,IAAMJ,EAAiB,QAAQ,MAC3CM,IAASH,EAAM,UAAUH,EAAiB,QAAQ,GAClDO,IAASJ,EAAM,UAAUH,EAAiB,QAAQ;AAExD,UAAIK,KAAaX,KAAS,KAAK,MAAMY,GAAQC,CAAM,KAAKZ,GAAW;AACjE,cAAMa,IAAsB;AAAA,UAC1B,GAAGL,EAAM;AAAA,UACT,GAAGA,EAAM;AAAA,QAAA;AAGX,QAAAM,EAAsBN,GAAOK,GAAMpB,GAAmB;AAAA,UACpD,eAAeK;AAAA,UACf,MAAMD;AAAA,UACN,QAAQ,MAAMO,EAAyB,SAAS,MAAA;AAAA,QAAM,CACvD,GAEDC,EAAiB,UAAU;AAC3B;AAAA,MACF;AAEA,MAAAA,EAAiB,UAAU;AAAA,QACzB,MAAMI;AAAA,QACN,GAAGD,EAAM;AAAA,QACT,GAAGA,EAAM;AAAA,MAAA;AAAA,IAEb;AAAA,IACA;AAAA,MACEf;AAAA,MACAM;AAAA,MACAC;AAAA,MACAL;AAAA,MACAE;AAAA,MACAC;AAAA,IAAA;AAAA,EACF;AAGF,EAAAiB,EAAU,MAAM;AACd,IAAAb,EAAgB,UAAUD,GAAW,WAAW,YAChDG,EAAyB,UAAU,IAAI,gBAAA;AACvC,UAAM,EAAE,QAAAY,MAAWZ,EAAyB,SAEtCa,IAAoB,CAACT,MACzBA,aAAiB,gBAAgBF,EAAgBE,CAAK;AAExD,WAAAN,EAAgB,QAAQ,iBAAiB,aAAae,GAAmB;AAAA,MACvE,SAASrB;AAAA,MACT,QAAAoB;AAAA,IAAA,CACD,GAEM,MAAM;AACX,MAAAZ,EAAyB,SAAS,MAAA,GAClCC,EAAiB,UAAU;AAAA,IAC7B;AAAA,EACF,GAAG,CAACJ,GAAWL,GAAcU,CAAe,CAAC;AAC/C;"}
+{"version":3,"file":"use-double-tap.js","sources":["../../src/use-double-tap/use-double-tap.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from \"react\";\nimport {\n  DoubleTapData,\n  DoubleTapOptions,\n  DoubleTapEventPointerTypes,\n  UseDoubleTapCallback,\n  UseDoubleTapOptions,\n} from \"./use-double-tap.types\";\nimport { invokeDoubleTapAction } from \"./invoke-double-tap-action\";\nimport { shouldHandleEvent } from \"./event-guards\";\n\nconst defaultOptions: DoubleTapOptions = {\n  eventPointerTypes: [\n    DoubleTapEventPointerTypes.Touch,\n    DoubleTapEventPointerTypes.Mouse,\n    DoubleTapEventPointerTypes.Pen,\n  ],\n  eventCapture: false,\n  eventOnce: false,\n  eventStopImmediatePropagation: false,\n  delay: 300,\n  threshold: 8,\n  container: { current: null },\n};\n\nconst useDoubleTap = (\n  doubleTapCallback: UseDoubleTapCallback,\n  options: UseDoubleTapOptions = {},\n) => {\n  const {\n    eventPointerTypes,\n    eventCapture,\n    eventOnce,\n    eventStopImmediatePropagation,\n    delay,\n    threshold,\n    container,\n  } = { ...defaultOptions, ...options };\n\n  const targetReference = useRef<EventTarget | null>(null);\n  const abortControllerReference = useRef<AbortController | null>(null);\n\n  const lastTapReference = useRef<{\n    time: number;\n    x: number;\n    y: number;\n  } | null>(null);\n\n  const handlePointerUp = useCallback(\n    (event: PointerEvent) => {\n      if (\n        !shouldHandleEvent(event, {\n          eventPointerTypes,\n        })\n      ) {\n        return;\n      }\n\n      const now = Date.now();\n\n      if (!lastTapReference.current) {\n        lastTapReference.current = {\n          time: now,\n          x: event.clientX,\n          y: event.clientY,\n        };\n        return;\n      }\n\n      const deltaTime = now - lastTapReference.current.time;\n      const deltaX = event.clientX - lastTapReference.current.x;\n      const deltaY = event.clientY - lastTapReference.current.y;\n\n      if (deltaTime <= delay && Math.hypot(deltaX, deltaY) <= threshold) {\n        const data: DoubleTapData = {\n          x: event.clientX,\n          y: event.clientY,\n        };\n\n        invokeDoubleTapAction(event, data, doubleTapCallback, {\n          stopImmediate: eventStopImmediatePropagation,\n          once: eventOnce,\n          onOnce: () => abortControllerReference.current?.abort(),\n        });\n\n        lastTapReference.current = null;\n        return;\n      }\n\n      lastTapReference.current = {\n        time: now,\n        x: event.clientX,\n        y: event.clientY,\n      };\n    },\n    [\n      eventPointerTypes,\n      eventOnce,\n      eventStopImmediatePropagation,\n      delay,\n      threshold,\n      doubleTapCallback,\n    ],\n  );\n\n  useEffect(() => {\n    targetReference.current = container?.current ?? globalThis;\n    abortControllerReference.current = new AbortController();\n    const { signal } = abortControllerReference.current;\n\n    const pointerUpListener = (event: Event) =>\n      event instanceof PointerEvent && handlePointerUp(event);\n\n    targetReference.current.addEventListener(\"pointerup\", pointerUpListener, {\n      capture: eventCapture,\n      signal,\n    });\n\n    return () => {\n      abortControllerReference.current?.abort();\n      lastTapReference.current = null;\n    };\n  }, [container, eventCapture, handlePointerUp]);\n};\n\nexport default useDoubleTap;\n"],"names":["defaultOptions","DoubleTapEventPointerTypes","useDoubleTap","doubleTapCallback","options","eventPointerTypes","eventCapture","eventOnce","eventStopImmediatePropagation","delay","threshold","container","targetReference","useRef","abortControllerReference","lastTapReference","handlePointerUp","useCallback","event","shouldHandleEvent","now","deltaTime","deltaX","deltaY","data","invokeDoubleTapAction","useEffect","signal","pointerUpListener"],"mappings":";;;;AAWA,MAAMA,IAAmC;AAAA,EACvC,mBAAmB;AAAA,IACjBC,EAA2B;AAAA,IAC3BA,EAA2B;AAAA,IAC3BA,EAA2B;AAAA,EAAA;AAAA,EAE7B,cAAc;AAAA,EACd,WAAW;AAAA,EACX,+BAA+B;AAAA,EAC/B,OAAO;AAAA,EACP,WAAW;AAAA,EACX,WAAW,EAAE,SAAS,KAAA;AACxB,GAEMC,IAAe,CACnBC,GACAC,IAA+B,OAC5B;AACH,QAAM;AAAA,IACJ,mBAAAC;AAAA,IACA,cAAAC;AAAA,IACA,WAAAC;AAAA,IACA,+BAAAC;AAAA,IACA,OAAAC;AAAA,IACA,WAAAC;AAAA,IACA,WAAAC;AAAA,EAAA,IACE,EAAE,GAAGX,GAAgB,GAAGI,EAAA,GAEtBQ,IAAkBC,EAA2B,IAAI,GACjDC,IAA2BD,EAA+B,IAAI,GAE9DE,IAAmBF,EAIf,IAAI,GAERG,IAAkBC;AAAA,IACtB,CAACC,MAAwB;AACvB,UACE,CAACC,EAAkBD,GAAO;AAAA,QACxB,mBAAAb;AAAA,MAAA,CACD;AAED;AAGF,YAAMe,IAAM,KAAK,IAAA;AAEjB,UAAI,CAACL,EAAiB,SAAS;AAC7B,QAAAA,EAAiB,UAAU;AAAA,UACzB,MAAMK;AAAA,UACN,GAAGF,EAAM;AAAA,UACT,GAAGA,EAAM;AAAA,QAAA;AAEX;AAAA,MACF;AAEA,YAAMG,IAAYD,IAAML,EAAiB,QAAQ,MAC3CO,IAASJ,EAAM,UAAUH,EAAiB,QAAQ,GAClDQ,IAASL,EAAM,UAAUH,EAAiB,QAAQ;AAExD,UAAIM,KAAaZ,KAAS,KAAK,MAAMa,GAAQC,CAAM,KAAKb,GAAW;AACjE,cAAMc,IAAsB;AAAA,UAC1B,GAAGN,EAAM;AAAA,UACT,GAAGA,EAAM;AAAA,QAAA;AAGX,QAAAO,EAAsBP,GAAOM,GAAMrB,GAAmB;AAAA,UACpD,eAAeK;AAAA,UACf,MAAMD;AAAA,UACN,QAAQ,MAAMO,EAAyB,SAAS,MAAA;AAAA,QAAM,CACvD,GAEDC,EAAiB,UAAU;AAC3B;AAAA,MACF;AAEA,MAAAA,EAAiB,UAAU;AAAA,QACzB,MAAMK;AAAA,QACN,GAAGF,EAAM;AAAA,QACT,GAAGA,EAAM;AAAA,MAAA;AAAA,IAEb;AAAA,IACA;AAAA,MACEb;AAAA,MACAE;AAAA,MACAC;AAAA,MACAC;AAAA,MACAC;AAAA,MACAP;AAAA,IAAA;AAAA,EACF;AAGF,EAAAuB,EAAU,MAAM;AACd,IAAAd,EAAgB,UAAUD,GAAW,WAAW,YAChDG,EAAyB,UAAU,IAAI,gBAAA;AACvC,UAAM,EAAE,QAAAa,MAAWb,EAAyB,SAEtCc,IAAoB,CAACV,MACzBA,aAAiB,gBAAgBF,EAAgBE,CAAK;AAExD,WAAAN,EAAgB,QAAQ,iBAAiB,aAAagB,GAAmB;AAAA,MACvE,SAAStB;AAAA,MACT,QAAAqB;AAAA,IAAA,CACD,GAEM,MAAM;AACX,MAAAb,EAAyB,SAAS,MAAA,GAClCC,EAAiB,UAAU;AAAA,IAC7B;AAAA,EACF,GAAG,CAACJ,GAAWL,GAAcU,CAAe,CAAC;AAC/C;"}

package/dist/use-drag/event-guards.js

@@ -0,0 +1,7 @@
+const n = (e, r) => !(!e.isPrimary || !r.eventPointerTypes.includes(
+  e.pointerType
+));
+export {
+  n as shouldHandleEvent
+};
+//# sourceMappingURL=event-guards.js.map

package/dist/use-drag/event-guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-guards.js","sources":["../../src/use-drag/event-guards.ts"],"sourcesContent":["import { DragEventPointerType } from \"./use-drag.types\";\n\n/**\n * Determines whether a pointer event should be handled based on event options.\n *\n * @param {PointerEvent} event - The pointer event to evaluate\n * @param {Object} options - Event handling options\n * @param {DragEventPointerType[]} options.eventPointerTypes - Allowed pointer types for the event\n * @returns {boolean} True if the event should be handled, false otherwise\n *\n * @example\n * const shouldHandle = shouldHandleEvent(event, {\n *   eventPointerTypes: [DragEventPointerTypes.Touch]\n * });\n */\nexport const shouldHandleEvent = (\n  event: PointerEvent,\n  options: {\n    eventPointerTypes: DragEventPointerType[];\n  },\n) => {\n  if (!event.isPrimary) {\n    return false;\n  }\n  if (\n    !options.eventPointerTypes.includes(\n      event.pointerType as DragEventPointerType,\n    )\n  ) {\n    return false;\n  }\n\n  return true;\n};\n"],"names":["shouldHandleEvent","event","options"],"mappings":"AAeO,MAAMA,IAAoB,CAC/BC,GACAC,MAII,GAACD,EAAM,aAIT,CAACC,EAAQ,kBAAkB;AAAA,EACzBD,EAAM;AAAA;"}