@msobiecki/react-marauders-path 1.24.3 → 1.26.0

package/README.md

@@ -2,17 +2,20 @@
 
 [![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, swipe, drag, and pinch events. Perfect for games, interactive applications, and input-driven interfaces.
+A lightweight, type-safe React library for handling keyboard, wheel, tap, double-tap, press, swipe, drag, and pinch events. Perfect for games, interactive applications, and input-driven interfaces.
 
 ![react-marauders-path](./docs/images/logotype.png)
 
 ## Features
 
-- 🎮 **Keyboard Event Handling** - Detect single keys, key combinations and sequences with configurable timing thresholds
-- 🎡 **Wheel Event Handling** - Track wheel, delta values with optional `requestAnimationFrame` batching for smoother updates
-- 🖐️ **Swipe Gesture Handling** - Detect directional swipes with configurable distance and velocity with pointer type filtering
-- 🖱️ **Drag Event Handling** - Track movement, delta values, duration, start/end positions with pointer type filtering and optional `requestAnimationFrame` batching for smoother updates
-- 🤏 **Pinch Gesture Handling** - Track two-finger distance, delta, and scale with pointer type filtering and optional `requestAnimationFrame` batching for smoother updates
+- 🎮 **Keyboard Event Handling** - Detect single keys, key combinations, and sequences with configurable timing thresholds
+- 🎡 **Wheel Event Handling** - Detect wheel delta values with optional `requestAnimationFrame` batching for smoother updates
+- 👆 **Tap Gesture Handling** - Detect single taps/clicks with configurable movement and duration thresholds
+- 👆👆 **Double-Tap Gesture Handling** - Detect consecutive taps/clicks with configurable timing and position thresholds
+- ✋ **Press Gesture Handling** - Detect press-and-hold interactions with configurable delay and movement thresholds
+- 🖐️ **Swipe Gesture Handling** - Detect directional swipes with configurable distance, velocity, and pointer type filtering
+- ✊ **Drag Gesture Handling** - Detect movement, deltas, duration, and start/end positions with pointer type filtering and optional `requestAnimationFrame` batching
+- 🤏 **Pinch Gesture Handling** - Detect two-finger distance, delta, and scale with pointer type filtering and optional `requestAnimationFrame` batching
 
 ## Installation
 
@@ -95,6 +98,48 @@ function MyComponent() {
 }
 ```
 
+### Tap Event Hook
+
+```typescript
+import { useTap } from '@msobiecki/react-marauders-path';
+
+function MyComponent() {
+  useTap((event, data) => {
+    console.log(`Tapped at X: ${data.x}, Y: ${data.y}`);
+  });
+
+  return <div>Tap to interact</div>;
+}
+```
+
+### Double Tap Event Hook
+
+```typescript
+import { useDoubleTap } from '@msobiecki/react-marauders-path';
+
+function MyComponent() {
+  useDoubleTap((event, data) => {
+    console.log(`Double tapped at X: ${data.x}, Y: ${data.y}`);
+  });
+
+  return <div>Double tap to interact</div>;
+}
+```
+
+### Press Event Hook
+
+```typescript
+import { usePress } from '@msobiecki/react-marauders-path';
+
+function MyComponent() {
+  usePress((event, data) => {
+    console.log(`Pressed at X: ${data.x}, Y: ${data.y}`);
+  });
+
+  return <div>Press and hold to interact</div>;
+}
+```
+
 ### Swipe Event Hook
 
 ```typescript
@@ -197,6 +242,102 @@ interface WheelData {
 }
 ```
 
+### `useTap(callback, options?)`
+
+Hook for handling single tap/click interactions.
+
+**Parameters:**
+
+- `callback: (event: PointerEvent, data: TapData) => void | boolean` - Called when tap gesture is recognized
+- `options?: UseTapOptions` - Optional configuration
+
+**Options:**
+
+```typescript
+interface UseTapOptions {
+  eventPointerTypes?: Array<"touch" | "mouse" | "pen">; // Default: ["touch", "mouse", "pen"]
+  eventCapture?: boolean; // Default: false
+  eventOnce?: boolean; // Default: false
+  eventStopImmediatePropagation?: boolean; // Default: false
+  threshold?: number; // Default: 8 (px) - Maximum movement allowed between pointerdown and pointerup
+  maxDuration?: number; // Default: 250 (ms) - Maximum tap duration
+  container?: RefObject<HTMLElement>; // Default: window
+}
+```
+
+**Tap Data:**
+
+```typescript
+interface TapData {
+  x: number; // Tap pointerup X
+  y: number; // Tap pointerup Y
+}
+```
+
+### `useDoubleTap(callback, options?)`
+
+Hook for handling double-tap / double-click interactions.
+
+**Parameters:**
+
+- `callback: (event: PointerEvent, data: DoubleTapData) => void | boolean` - Called when double tap is recognized
+- `options?: UseDoubleTapOptions` - Optional configuration
+
+**Options:**
+
+```typescript
+interface UseDoubleTapOptions {
+  eventPointerTypes?: Array<"touch" | "mouse" | "pen">; // Default: ["touch", "mouse", "pen"]
+  eventCapture?: boolean; // Default: false
+  eventOnce?: boolean; // Default: false
+  eventStopImmediatePropagation?: boolean; // Default: false
+  delay?: number; // Default: 300 (ms) - Maximum interval between taps
+  threshold?: number; // Default: 8 (px) - Maximum distance between two tap positions
+  container?: RefObject<HTMLElement>; // Default: window
+}
+```
+
+**Double Tap Data:**
+
+```typescript
+interface DoubleTapData {
+  x: number; // Tap pointerup X
+  y: number; // Tap pointerup Y
+}
+```
+
+### `usePress(callback, options?)`
+
+Hook for handling press-and-hold interactions.
+
+**Parameters:**
+
+- `callback: (event: PointerEvent, data: PressData) => void | boolean` - Called when press delay completes
+- `options?: UsePressOptions` - Optional configuration
+
+**Options:**
+
+```typescript
+interface UsePressOptions {
+  eventPointerTypes?: Array<"touch" | "mouse" | "pen">; // Default: ["touch", "mouse", "pen"]
+  eventCapture?: boolean; // Default: false
+  eventOnce?: boolean; // Default: false
+  eventStopImmediatePropagation?: boolean; // Default: false
+  delay?: number; // Default: 500 (ms) - Press-and-hold duration required
+  threshold?: number; // Default: 8 (px) - Maximum movement allowed while holding
+  container?: RefObject<HTMLElement>; // Default: window
+}
+```
+
+**Press Data:**
+
+```typescript
+interface PressData {
+  x: number; // Pointerdown X at press start
+  y: number; // Pointerdown Y at press start
+}
+```
+
 ### `useSwipe(swipe, callback, options?)`
 
 Hook for handling touch swipe gestures with configurable distance and velocity thresholds.
@@ -414,12 +555,6 @@ npm run lint
   - `drag` / `pan` – track movement of finger or mouse
   - `pinch` / `zoom` – two-finger pinch / zoom
 
-### Low-level Gesture Hooks
-
-- 🚧 **`useTap`** – single tap / click
-- 🚧 **`useDoubleTap`** – quick double tap
-- 🚧 **`usePress`** – press and hold (longPress)
-
 ### Pointer / Mouse Hooks (Unified)
 
 - 🚧 **`usePointer`** – unified hook for MouseEvent, PointerEvent, and TouchEvent  

package/dist/index.d.ts

@@ -9,6 +9,31 @@ export declare interface CombinationState {
     activeKeys: Map<Key, CombinationActiveKey>;
 }
 
+export declare interface DoubleTapData {
+    x: number;
+    y: number;
+}
+
+export declare type DoubleTapEventPointerType = (typeof DoubleTapEventPointerTypes)[keyof typeof DoubleTapEventPointerTypes];
+
+export declare const DoubleTapEventPointerTypes: {
+    readonly Touch: "touch";
+    readonly Mouse: "mouse";
+    readonly Pen: "pen";
+};
+
+export declare interface DoubleTapOptions {
+    eventPointerTypes: DoubleTapEventPointerType[];
+    eventCapture: boolean;
+    eventOnce: boolean;
+    eventStopImmediatePropagation: boolean;
+    delay: number;
+    threshold: number;
+    container: {
+        current: EventTarget | null;
+    };
+}
+
 export declare interface DragData {
     deltaX: number;
     deltaY: number;
@@ -108,6 +133,31 @@ export declare interface PinchState {
     active: boolean;
 }
 
+export declare interface PressData {
+    x: number;
+    y: number;
+}
+
+export declare type PressEventPointerType = (typeof PressEventPointerTypes)[keyof typeof PressEventPointerTypes];
+
+export declare const PressEventPointerTypes: {
+    readonly Touch: "touch";
+    readonly Mouse: "mouse";
+    readonly Pen: "pen";
+};
+
+export declare interface PressOptions {
+    eventPointerTypes: PressEventPointerType[];
+    eventCapture: boolean;
+    eventOnce: boolean;
+    eventStopImmediatePropagation: boolean;
+    delay: number;
+    threshold: number;
+    container: {
+        current: EventTarget | null;
+    };
+}
+
 export declare interface SequenceState {
     key: Key;
     chord: KeyChord;
@@ -161,6 +211,44 @@ export declare interface SwipeState {
     active: boolean;
 }
 
+export declare interface TapData {
+    x: number;
+    y: number;
+}
+
+export declare type TapEventPointerType = (typeof TapEventPointerTypes)[keyof typeof TapEventPointerTypes];
+
+export declare const TapEventPointerTypes: {
+    readonly Touch: "touch";
+    readonly Mouse: "mouse";
+    readonly Pen: "pen";
+};
+
+export declare interface TapOptions {
+    eventPointerTypes: TapEventPointerType[];
+    eventCapture: boolean;
+    eventOnce: boolean;
+    eventStopImmediatePropagation: boolean;
+    threshold: number;
+    maxDuration: number;
+    container: {
+        current: EventTarget | null;
+    };
+}
+
+export declare interface TapState {
+    startX: number;
+    startY: number;
+    startTime: number;
+    active: boolean;
+}
+
+export declare const useDoubleTap: (doubleTapCallback: UseDoubleTapCallback, options?: UseDoubleTapOptions) => void;
+
+export declare type UseDoubleTapCallback = ((event: PointerEvent, data: DoubleTapData) => boolean) | ((event: PointerEvent, data: DoubleTapData) => void);
+
+export declare type UseDoubleTapOptions = Partial<DoubleTapOptions>;
+
 export declare const useDrag: (dragCallback: UseDragCallback, options?: UseDragOptions) => void;
 
 export declare type UseDragCallback = ((event: PointerEvent, data: DragData) => boolean) | ((event: PointerEvent, data: DragData) => void);
@@ -241,6 +329,12 @@ export declare type UsePinchCallback = ((event: PointerEvent, data: PinchData) =
 
 export declare type UsePinchOptions = Partial<PinchOptions>;
 
+export declare const usePress: (pressCallback: UsePressCallback, options?: UsePressOptions) => void;
+
+export declare type UsePressCallback = ((event: PointerEvent, data: PressData) => void) | ((event: PointerEvent, data: PressData) => boolean);
+
+export declare type UsePressOptions = Partial<PressOptions>;
+
 export declare const useSwipe: (swipe: UseSwipeSchema, swipeCallback: UseSwipeCallback, options?: UseSwipeOptions) => void;
 
 export declare type UseSwipeCallback = ((event: PointerEvent, direction: SwipeDirection, data: SwipeData, ...properties: unknown[]) => boolean) | ((event: PointerEvent, direction: SwipeDirection, data: SwipeData, ...properties: unknown[]) => void);
@@ -249,6 +343,12 @@ export declare type UseSwipeOptions = Partial<SwipeOptions>;
 
 export declare type UseSwipeSchema = SwipeDirection | SwipeDirection[];
 
+export declare const useTap: (tapCallback: UseTapCallback, options?: UseTapOptions) => void;
+
+export declare type UseTapCallback = ((event: PointerEvent, data: TapData) => boolean) | ((event: PointerEvent, data: TapData) => void);
+
+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);

package/dist/index.js

@@ -1,22 +1,34 @@
-import { default as o } from "./use-drag/use-drag.js";
-import { DragEventPointerTypes as p } from "./use-drag/use-drag.types.js";
-import { default as f } from "./use-key/use-key.js";
+import { default as o } from "./use-double-tap/use-double-tap.js";
+import { DoubleTapEventPointerTypes as p } 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 m } from "./use-key/use-key.js";
 import { KeyEventTypes as i } from "./use-key/use-key.types.js";
-import { default as u } from "./use-pinch/use-pinch.js";
-import { PinchEventPointerTypes as x } from "./use-pinch/use-pinch.types.js";
-import { default as y } from "./use-swipe/use-swipe.js";
-import { SwipeDirections as P, SwipeEventPointerTypes as v } from "./use-swipe/use-swipe.types.js";
-import { default as T } from "./use-wheel/use-wheel.js";
+import { default as T } from "./use-pinch/use-pinch.js";
+import { PinchEventPointerTypes as y } from "./use-pinch/use-pinch.types.js";
+import { default as v } from "./use-press/use-press.js";
+import { PressEventPointerTypes as D } from "./use-press/use-press.types.js";
+import { default as h } from "./use-swipe/use-swipe.js";
+import { SwipeDirections as S, SwipeEventPointerTypes as b } from "./use-swipe/use-swipe.types.js";
+import { default as K } from "./use-tap/use-tap.js";
+import { TapEventPointerTypes as j } from "./use-tap/use-tap.types.js";
+import { default as q } from "./use-wheel/use-wheel.js";
 export {
-  p as DragEventPointerTypes,
+  p as DoubleTapEventPointerTypes,
+  u as DragEventPointerTypes,
   i as KeyEventTypes,
-  x as PinchEventPointerTypes,
-  P as SwipeDirections,
-  v as SwipeEventPointerTypes,
-  o as useDrag,
-  f as useKey,
-  u as usePinch,
-  y as useSwipe,
-  T as useWheel
+  y as PinchEventPointerTypes,
+  D as PressEventPointerTypes,
+  S as SwipeDirections,
+  b as SwipeEventPointerTypes,
+  j as TapEventPointerTypes,
+  o as useDoubleTap,
+  f as useDrag,
+  m as useKey,
+  T as usePinch,
+  v as usePress,
+  h as useSwipe,
+  K 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/invoke-double-tap-action.js

@@ -0,0 +1,7 @@
+const i = (e, t, n, o) => {
+  o.stopImmediate && e.stopImmediatePropagation(), n(e, t) && e.preventDefault(), o.once && o.onOnce?.();
+};
+export {
+  i as invokeDoubleTapAction
+};
+//# sourceMappingURL=invoke-double-tap-action.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"invoke-double-tap-action.js","sources":["../../src/use-double-tap/invoke-double-tap-action.ts"],"sourcesContent":["import { DoubleTapData } from \"./use-double-tap.types\";\n\n/**\n * Invokes a double tap action callback with optional event modifications.\n *\n * Handles double tap event processing including preventing default behavior,\n * stopping immediate propagation, and managing one-time event handlers.\n *\n * @param {PointerEvent} event - The double tap event\n * @param {DoubleTapData} data - The normalized double tap data\n * @param {Function} callback - Function to invoke with (event, data). Return true to prevent default.\n * @param {Object} options - Action options\n * @param {boolean} [options.stopImmediate=false] - Whether to stop immediate propagation\n * @param {boolean} [options.once=false] - Whether this is a one-time event\n * @param {Function} [options.onOnce] - Callback to invoke when one-time event fires\n *\n * @example\n * invokeTapAction(event, data, (e, d) => {\n *   console.log(`Double tap at: ${d.x}, ${d.y}`);\n *   return true; // Prevent default\n * }, { stopImmediate: true });\n */\nexport const invokeDoubleTapAction = (\n  event: PointerEvent,\n  data: DoubleTapData,\n  callback:\n    | ((event: PointerEvent, data: DoubleTapData) => boolean)\n    | ((event: PointerEvent, data: DoubleTapData) => void),\n  options: {\n    stopImmediate?: boolean;\n    once?: boolean;\n    onOnce?: () => void;\n  },\n) => {\n  if (options.stopImmediate) {\n    event.stopImmediatePropagation();\n  }\n\n  const shouldPrevent = callback(event, data);\n  if (shouldPrevent) {\n    event.preventDefault();\n  }\n\n  if (options.once) {\n    options.onOnce?.();\n  }\n};\n"],"names":["invokeDoubleTapAction","event","data","callback","options"],"mappings":"AAsBO,MAAMA,IAAwB,CACnCC,GACAC,GACAC,GAGAC,MAKG;AACH,EAAIA,EAAQ,iBACVH,EAAM,yBAAA,GAGcE,EAASF,GAAOC,CAAI,KAExCD,EAAM,eAAA,GAGJG,EAAQ,QACVA,EAAQ,SAAA;AAEZ;"}

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

@@ -0,0 +1,77 @@
+import { useRef as c, useCallback as g, useEffect as x } from "react";
+import { invokeDoubleTapAction as X } from "./invoke-double-tap-action.js";
+const Y = {
+  eventPointerTypes: ["touch", "mouse", "pen"],
+  eventCapture: !1,
+  eventOnce: !1,
+  eventStopImmediatePropagation: !1,
+  delay: 300,
+  threshold: 8,
+  container: { current: null }
+}, R = (i, h = {}) => {
+  const {
+    eventPointerTypes: l,
+    eventCapture: u,
+    eventOnce: a,
+    eventStopImmediatePropagation: s,
+    delay: p,
+    threshold: f,
+    container: d
+  } = { ...Y, ...h }, m = c(null), r = c(null), t = c(null), y = g(
+    (e) => {
+      if (!e.isPrimary || !l.includes(
+        e.pointerType
+      ))
+        return;
+      const n = Date.now();
+      if (!t.current) {
+        t.current = {
+          time: n,
+          x: e.clientX,
+          y: e.clientY
+        };
+        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 = {
+          x: e.clientX,
+          y: e.clientY
+        };
+        X(e, b, i, {
+          stopImmediate: s,
+          once: a,
+          onOnce: () => r.current?.abort()
+        }), t.current = null;
+        return;
+      }
+      t.current = {
+        time: n,
+        x: e.clientX,
+        y: e.clientY
+      };
+    },
+    [
+      i,
+      p,
+      f,
+      l,
+      a,
+      s
+    ]
+  );
+  x(() => {
+    m.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, {
+      capture: u,
+      signal: e
+    }), () => {
+      r.current?.abort(), t.current = null;
+    };
+  }, [d, u, y]);
+};
+export {
+  R as default
+};
+//# sourceMappingURL=use-double-tap.js.map

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

@@ -0,0 +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;"}

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

@@ -0,0 +1,9 @@
+const e = {
+  Touch: "touch",
+  Mouse: "mouse",
+  Pen: "pen"
+};
+export {
+  e as DoubleTapEventPointerTypes
+};
+//# sourceMappingURL=use-double-tap.types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-double-tap.types.js","sources":["../../src/use-double-tap/use-double-tap.types.ts"],"sourcesContent":["export const DoubleTapEventPointerTypes = {\n  Touch: \"touch\",\n  Mouse: \"mouse\",\n  Pen: \"pen\",\n} as const;\n\nexport type DoubleTapEventPointerType =\n  (typeof DoubleTapEventPointerTypes)[keyof typeof DoubleTapEventPointerTypes];\n\nexport interface DoubleTapData {\n  x: number;\n  y: number;\n}\n\nexport interface DoubleTapOptions {\n  eventPointerTypes: DoubleTapEventPointerType[];\n  eventCapture: boolean;\n  eventOnce: boolean;\n  eventStopImmediatePropagation: boolean;\n  delay: number;\n  threshold: number;\n  container: { current: EventTarget | null };\n}\n\nexport type UseDoubleTapCallback =\n  | ((event: PointerEvent, data: DoubleTapData) => boolean)\n  | ((event: PointerEvent, data: DoubleTapData) => void);\n\nexport type UseDoubleTapOptions = Partial<DoubleTapOptions>;\n"],"names":["DoubleTapEventPointerTypes"],"mappings":"AAAO,MAAMA,IAA6B;AAAA,EACxC,OAAO;AAAA,EACP,OAAO;AAAA,EACP,KAAK;AACP;"}