@msobiecki/react-marauders-path 1.26.0 → 1.28.0

package/README.md

@@ -2,20 +2,21 @@
 
 [![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, tap, double-tap, press, swipe, drag, and pinch events. Perfect for games, interactive applications, and input-driven interfaces.
+A lightweight, type-safe React library for handling keyboard, 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
+- 👐 **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
+  - ✋ **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
 - 🎡 **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
 
@@ -84,21 +85,23 @@ useKey(
 );
 ```
 
-### Wheel Event Hook
+### Gesture Event Hook
 
 ```typescript
-import { useWheel } from '@msobiecki/react-marauders-path';
+import { useGesture } from '@msobiecki/react-marauders-path';
 
 function MyComponent() {
-  useWheel((event, data) => {
-    console.log(`Scrolled - X: ${data.deltaX}, Y: ${data.deltaY}`);
+  useGesture('tap', (event, data) => {
+    console.log(`Tapped at X: ${data.x}, Y: ${data.y}`);
+  }, {
+    threshold: 8,
   });
 
-  return <div>Scroll to interact</div>;
+  return <div>Tap to interact</div>;
 }
 ```
 
-### Tap Event Hook
+#### Tap Event Hook
 
 ```typescript
 import { useTap } from '@msobiecki/react-marauders-path';
@@ -112,7 +115,7 @@ function MyComponent() {
 }
 ```
 
-### Double Tap Event Hook
+#### Double Tap Event Hook
 
 ```typescript
 import { useDoubleTap } from '@msobiecki/react-marauders-path';
@@ -126,7 +129,7 @@ function MyComponent() {
 }
 ```
 
-### Press Event Hook
+#### Press Event Hook
 
 ```typescript
 import { usePress } from '@msobiecki/react-marauders-path';
@@ -140,7 +143,7 @@ function MyComponent() {
 }
 ```
 
-### Swipe Event Hook
+#### Swipe Event Hook
 
 ```typescript
 import { useSwipe } from '@msobiecki/react-marauders-path';
@@ -154,7 +157,7 @@ function MyComponent() {
 }
 ```
 
-### Drag Event Hook
+#### Drag Event Hook
 
 ```typescript
 import { useDrag } from '@msobiecki/react-marauders-path';
@@ -168,7 +171,7 @@ function MyComponent() {
 }
 ```
 
-### Pinch Event Hook
+#### Pinch Event Hook
 
 ```typescript
 import { usePinch } from '@msobiecki/react-marauders-path';
@@ -182,6 +185,20 @@ function MyComponent() {
 }
 ```
 
+### Wheel Event Hook
+
+```typescript
+import { useWheel } from '@msobiecki/react-marauders-path';
+
+function MyComponent() {
+  useWheel((event, data) => {
+    console.log(`Scrolled - X: ${data.deltaX}, Y: ${data.deltaY}`);
+  });
+
+  return <div>Scroll to interact</div>;
+}
+```
+
 ## API
 
 ### `useKey(keyEvent, callback, options?)`
@@ -190,8 +207,8 @@ Hook for keyboard event handling with support for single keys, combinations, and
 
 **Parameters:**
 
-- `keyEvent: string | string[]` - Single key, combination, or sequence to listen
-- `callback: (event: KeyboardEvent, key: string) => void | boolean` - Called when key event occurs
+- `keyEvent: string | string[]` - Single key, key combination, or key sequence to listen for
+- `callback: (event: KeyboardEvent, key: string) => void | boolean` - Called when a key event occurs
 - `options?: UseKeyOptions` - Optional configuration
 
 **Options:**
@@ -209,46 +226,42 @@ interface UseKeyOptions {
 }
 ```
 
-### `useWheel(callback, options?)`
+### `useGesture(gesture, callback, options?)`
 
-Hook for handling mouse wheel events with support for different delta modes and options.
+Hook for gesture event handling that delegates to one of the low-level gesture hooks.
 
 **Parameters:**
 
-- `callback: (event: WheelEvent, data: WheelData) => void | boolean` - Called when wheel event occurs
-- `options?: UseWheelOptions` - Optional configuration
+- `gesture: "tap" | "doubletap" | "press" | "swipe" | "drag" | "pinch"` - Gesture to bind (must stay the same between renders)
+- `callback` - Callback type is inferred from `gesture`
+- `options?` - Options type is inferred from `gesture`
 
-**Options:**
+**Swipe-only option:**
 
-```typescript
-interface UseWheelOptions {
-  eventPassive?: boolean; // Default: true
-  eventCapture?: boolean; // Default: false
-  eventOnce?: boolean; // Default: false
-  eventStopImmediatePropagation?: boolean; // Default: false
-  container?: RefObject<HTMLElement>; // Default: window
-  raf?: boolean; // Default: false - Use requestAnimationFrame for batching
-}
-```
+- `direction?: SwipeDirection` - Optional direction for `useGesture("swipe", ...)`; defaults to `"both"`
 
-**Wheel Data:**
+**Example:**
 
 ```typescript
-interface WheelData {
-  deltaX: number; // Delta X value
-  deltaY: number; // Delta Y value
-  deltaZ: number; // Delta Z value
-  deltaMode: number; // Delta mode value
-}
+useGesture(
+  "swipe",
+  (event, direction, data) => {
+    console.log(direction, data.velocity);
+  },
+  {
+    direction: "horizontal",
+    threshold: 40,
+  },
+);
 ```
 
-### `useTap(callback, options?)`
+#### `useTap(callback, options?)`
 
 Hook for handling single tap/click interactions.
 
 **Parameters:**
 
-- `callback: (event: PointerEvent, data: TapData) => void | boolean` - Called when tap gesture is recognized
+- `callback: (event: PointerEvent, data: TapData) => void | boolean` - Called when a tap gesture is recognized
 - `options?: UseTapOptions` - Optional configuration
 
 **Options:**
@@ -274,13 +287,13 @@ interface TapData {
 }
 ```
 
-### `useDoubleTap(callback, options?)`
+#### `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
+- `callback: (event: PointerEvent, data: DoubleTapData) => void | boolean` - Called when a double tap is recognized
 - `options?: UseDoubleTapOptions` - Optional configuration
 
 **Options:**
@@ -306,13 +319,13 @@ interface DoubleTapData {
 }
 ```
 
-### `usePress(callback, options?)`
+#### `usePress(callback, options?)`
 
 Hook for handling press-and-hold interactions.
 
 **Parameters:**
 
-- `callback: (event: PointerEvent, data: PressData) => void | boolean` - Called when press delay completes
+- `callback: (event: PointerEvent, data: PressData) => void | boolean` - Called when a press delay completes
 - `options?: UsePressOptions` - Optional configuration
 
 **Options:**
@@ -338,13 +351,13 @@ interface PressData {
 }
 ```
 
-### `useSwipe(swipe, callback, options?)`
+#### `useSwipe(swipe, callback, options?)`
 
 Hook for handling touch swipe gestures with configurable distance and velocity thresholds.
 
 **Parameters:**
 
-- `swipe: left | right | up | down | horizontal | vertical | both` - Allowed directions to listen
+- `swipe: "left" | "right" | "up" | "down" | "horizontal" | "vertical" | "both"` - Allowed directions to listen
 - `callback: (event: PointerEvent, direction: SwipeDirection, data: SwipeData) => void | boolean` - Called when a swipe event occurs
 - `options?: UseSwipeOptions` - Optional configuration
 
@@ -373,13 +386,13 @@ interface SwipeData {
 }
 ```
 
-### `useDrag(callback, options?)`
+#### `useDrag(callback, options?)`
 
 Hook for handling pointer drag gestures with configurable threshold and pointer types.
 
 **Parameters:**
 
-- `callback: (event: PointerEvent, data: DragData) => void | boolean` - Called when drag event occurs
+- `callback: (event: PointerEvent, data: DragData) => void | boolean` - Called when a drag event occurs
 - `options?: UseDragOptions` - Optional configuration
 
 **Options:**
@@ -412,13 +425,13 @@ interface DragData {
 }
 ```
 
-### `usePinch(callback, options?)`
+#### `usePinch(callback, options?)`
 
 Hook for handling two-pointer pinch gestures with distance and scale tracking.
 
 **Parameters:**
 
-- `callback: (event: PointerEvent, data: PinchData) => void | boolean` - Called when pinch event occurs
+- `callback: (event: PointerEvent, data: PinchData) => void | boolean` - Called when a pinch event occurs
 - `options?: UsePinchOptions` - Optional configuration
 
 **Options:**
@@ -446,6 +459,39 @@ interface PinchData {
 }
 ```
 
+### `useWheel(callback, options?)`
+
+Hook for handling mouse wheel events with support for different delta modes and options.
+
+**Parameters:**
+
+- `callback: (event: WheelEvent, data: WheelData) => void | boolean` - Called when a wheel event occurs
+- `options?: UseWheelOptions` - Optional configuration
+
+**Options:**
+
+```typescript
+interface UseWheelOptions {
+  eventPassive?: boolean; // Default: true
+  eventCapture?: boolean; // Default: false
+  eventOnce?: boolean; // Default: false
+  eventStopImmediatePropagation?: boolean; // Default: false
+  container?: RefObject<HTMLElement>; // Default: window
+  raf?: boolean; // Default: false - Use requestAnimationFrame for batching
+}
+```
+
+**Wheel Data:**
+
+```typescript
+interface WheelData {
+  deltaX: number; // Delta X value
+  deltaY: number; // Delta Y value
+  deltaZ: number; // Delta Z value
+  deltaMode: number; // Delta mode value
+}
+```
+
 ## Advanced Examples
 
 ### Using Options for Event Type and Propagation Control
@@ -546,14 +592,14 @@ npm run lint
 
 ### High-level Gesture Hook
 
-- 🚧 **`useGesture`** – high-level API for gesture handling  
+- ✅ **`useGesture`** – high-level API for gesture handling
   Supported gestures:
   - `tap` – single tap / click
-  - `doubleTap` – quick double tap
-  - `press` / `longPress` – press and hold
+  - `doubletap` – quick double tap
+  - `press` – press and hold
   - `swipe` – directional swipe
-  - `drag` / `pan` – track movement of finger or mouse
-  - `pinch` / `zoom` – two-finger pinch / zoom
+  - `drag` – track movement of finger or mouse
+  - `pinch` – two-finger pinch / zoom
 
 ### Pointer / Mouse Hooks (Unified)
 

package/dist/index.d.ts

@@ -75,6 +75,17 @@ export declare interface DragState {
     active: boolean;
 }
 
+export declare type GestureType = (typeof GestureTypes)[keyof typeof GestureTypes];
+
+export declare const GestureTypes: {
+    readonly Tap: "tap";
+    readonly DoubleTap: "doubletap";
+    readonly Press: "press";
+    readonly Swipe: "swipe";
+    readonly Drag: "drag";
+    readonly Pinch: "pinch";
+};
+
 export declare type Key = string;
 
 export declare type KeyChord = (Key | Key[])[];
@@ -255,6 +266,34 @@ export declare type UseDragCallback = ((event: PointerEvent, data: DragData) =>
 
 export declare type UseDragOptions = Partial<DragOptions>;
 
+export declare const useGesture: <T extends UseGestureSchema>(gesture: T, callback: UseGestureCallback<T>, options?: UseGestureOptions<T>) => void;
+
+export declare type UseGestureCallback<T extends UseGestureSchema> = UseGestureCallbackMap[T];
+
+declare interface UseGestureCallbackMap {
+    [GestureTypes.Tap]: UseTapCallback;
+    [GestureTypes.DoubleTap]: UseDoubleTapCallback;
+    [GestureTypes.Press]: UsePressCallback;
+    [GestureTypes.Swipe]: UseSwipeCallback;
+    [GestureTypes.Drag]: UseDragCallback;
+    [GestureTypes.Pinch]: UsePinchCallback;
+}
+
+export declare type UseGestureOptions<T extends UseGestureSchema> = UseGestureOptionsMap[T];
+
+declare interface UseGestureOptionsMap {
+    [GestureTypes.Tap]: UseTapOptions;
+    [GestureTypes.DoubleTap]: UseDoubleTapOptions;
+    [GestureTypes.Press]: UsePressOptions;
+    [GestureTypes.Swipe]: ({
+        direction: SwipeDirection;
+    } & UseSwipeOptions) | UseSwipeOptions;
+    [GestureTypes.Drag]: UseDragOptions;
+    [GestureTypes.Pinch]: UsePinchOptions;
+}
+
+export declare type UseGestureSchema = GestureType;
+
 /**
  * React hook for handling keyboard events with support for key sequences and combinations.
  *

package/dist/index.js

@@ -1,34 +1,38 @@
 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 { 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 m } from "./use-key/use-key.js";
-import { KeyEventTypes as i } from "./use-key/use-key.types.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";
+import { default as x } 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";
 export {
-  p as DoubleTapEventPointerTypes,
+  s as DoubleTapEventPointerTypes,
   u as DragEventPointerTypes,
-  i as KeyEventTypes,
-  y as PinchEventPointerTypes,
-  D as PressEventPointerTypes,
-  S as SwipeDirections,
-  b as SwipeEventPointerTypes,
-  j as TapEventPointerTypes,
+  i as GestureTypes,
+  P as KeyEventTypes,
+  D as PinchEventPointerTypes,
+  S as PressEventPointerTypes,
+  K as SwipeDirections,
+  W as SwipeEventPointerTypes,
+  z 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
+  x as useGesture,
+  T as useKey,
+  v as usePinch,
+  h as usePress,
+  g as useSwipe,
+  k as useTap,
+  B 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-gesture/use-gesture.js

@@ -0,0 +1,43 @@
+import { useRef as n } from "react";
+import i from "../use-tap/use-tap.js";
+import p from "../use-double-tap/use-double-tap.js";
+import c from "../use-press/use-press.js";
+import m from "../use-swipe/use-swipe.js";
+import { SwipeDirections as a } from "../use-swipe/use-swipe.types.js";
+import f from "../use-drag/use-drag.js";
+import G from "../use-pinch/use-pinch.js";
+const l = (e, s) => {
+  i(e, s);
+}, w = (e, s) => {
+  p(e, s);
+}, d = (e, s) => {
+  c(e, s);
+}, h = (e, s) => {
+  const { direction: t = a.Both, ...r } = s;
+  m(t, e, r);
+}, b = (e, s) => {
+  f(e, s);
+}, g = (e, s) => {
+  G(e, s);
+}, D = {
+  tap: l,
+  doubletap: w,
+  press: d,
+  swipe: h,
+  drag: b,
+  pinch: g
+}, E = (e, s, t = {}) => {
+  const r = n(null);
+  r.current === null && (r.current = e);
+  const o = r.current;
+  if (e !== o)
+    throw new Error(
+      "useGesture does not support changing gesture type between renders."
+    );
+  const u = D[o];
+  u(s, t);
+};
+export {
+  E as default
+};
+//# sourceMappingURL=use-gesture.js.map

package/dist/use-gesture/use-gesture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-gesture.js","sources":["../../src/use-gesture/use-gesture.ts"],"sourcesContent":["import { useRef } from \"react\";\n\nimport { useTap } from \"../use-tap\";\nimport { useDoubleTap } from \"../use-double-tap\";\nimport { usePress } from \"../use-press\";\nimport { SwipeDirections, useSwipe, UseSwipeSchema } from \"../use-swipe\";\nimport { useDrag } from \"../use-drag\";\nimport { usePinch } from \"../use-pinch\";\n\nimport {\n  UseGestureSchema,\n  UseGestureCallback,\n  UseGestureOptions,\n} from \"./use-gesture.types\";\n\nconst useGestureTap = (\n  callback: UseGestureCallback<\"tap\">,\n  options: UseGestureOptions<\"tap\">,\n) => {\n  useTap(callback, options);\n};\n\nconst useGestureDoubleTap = (\n  callback: UseGestureCallback<\"doubletap\">,\n  options: UseGestureOptions<\"doubletap\">,\n) => {\n  useDoubleTap(callback, options);\n};\n\nconst useGesturePress = (\n  callback: UseGestureCallback<\"press\">,\n  options: UseGestureOptions<\"press\">,\n) => {\n  usePress(callback, options);\n};\n\nconst useGestureSwipe = (\n  callback: UseGestureCallback<\"swipe\">,\n  options: UseGestureOptions<\"swipe\">,\n) => {\n  const { direction = SwipeDirections.Both, ...swipeOptions } =\n    options as UseGestureOptions<\"swipe\"> & {\n      direction?: UseSwipeSchema;\n    };\n\n  useSwipe(direction, callback, swipeOptions);\n};\n\nconst useGestureDrag = (\n  callback: UseGestureCallback<\"drag\">,\n  options: UseGestureOptions<\"drag\">,\n) => {\n  useDrag(callback, options);\n};\n\nconst useGesturePinch = (\n  callback: UseGestureCallback<\"pinch\">,\n  options: UseGestureOptions<\"pinch\">,\n) => {\n  usePinch(callback, options);\n};\n\nconst useGestureMap = {\n  tap: useGestureTap,\n  doubletap: useGestureDoubleTap,\n  press: useGesturePress,\n  swipe: useGestureSwipe,\n  drag: useGestureDrag,\n  pinch: useGesturePinch,\n} as const;\n\nconst useGesture = <T extends UseGestureSchema>(\n  gesture: T,\n  callback: UseGestureCallback<T>,\n  options: UseGestureOptions<T> = {} as UseGestureOptions<T>,\n): void => {\n  const initialGestureReference = useRef<T | null>(null);\n\n  if (initialGestureReference.current === null) {\n    initialGestureReference.current = gesture;\n  }\n\n  const stableGesture = initialGestureReference.current;\n\n  if (gesture !== stableGesture) {\n    throw new Error(\n      \"useGesture does not support changing gesture type between renders.\",\n    );\n  }\n\n  const useSelectedGestureHook = useGestureMap[stableGesture] as (\n    callback: UseGestureCallback<T>,\n    options: UseGestureOptions<T>,\n  ) => void;\n\n  useSelectedGestureHook(callback, options);\n};\n\nexport default useGesture;\n"],"names":["useGestureTap","callback","options","useTap","useGestureDoubleTap","useDoubleTap","useGesturePress","usePress","useGestureSwipe","direction","SwipeDirections","swipeOptions","useSwipe","useGestureDrag","useDrag","useGesturePinch","usePinch","useGestureMap","useGesture","gesture","initialGestureReference","useRef","stableGesture","useSelectedGestureHook"],"mappings":";;;;;;;;AAeA,MAAMA,IAAgB,CACpBC,GACAC,MACG;AACH,EAAAC,EAAOF,GAAUC,CAAO;AAC1B,GAEME,IAAsB,CAC1BH,GACAC,MACG;AACH,EAAAG,EAAaJ,GAAUC,CAAO;AAChC,GAEMI,IAAkB,CACtBL,GACAC,MACG;AACH,EAAAK,EAASN,GAAUC,CAAO;AAC5B,GAEMM,IAAkB,CACtBP,GACAC,MACG;AACH,QAAM,EAAE,WAAAO,IAAYC,EAAgB,MAAM,GAAGC,MAC3CT;AAIF,EAAAU,EAASH,GAAWR,GAAUU,CAAY;AAC5C,GAEME,IAAiB,CACrBZ,GACAC,MACG;AACH,EAAAY,EAAQb,GAAUC,CAAO;AAC3B,GAEMa,IAAkB,CACtBd,GACAC,MACG;AACH,EAAAc,EAASf,GAAUC,CAAO;AAC5B,GAEMe,IAAgB;AAAA,EACpB,KAAKjB;AAAA,EACL,WAAWI;AAAA,EACX,OAAOE;AAAA,EACP,OAAOE;AAAA,EACP,MAAMK;AAAA,EACN,OAAOE;AACT,GAEMG,IAAa,CACjBC,GACAlB,GACAC,IAAgC,CAAA,MACvB;AACT,QAAMkB,IAA0BC,EAAiB,IAAI;AAErD,EAAID,EAAwB,YAAY,SACtCA,EAAwB,UAAUD;AAGpC,QAAMG,IAAgBF,EAAwB;AAE9C,MAAID,MAAYG;AACd,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAIJ,QAAMC,IAAyBN,EAAcK,CAAa;AAK1D,EAAAC,EAAuBtB,GAAUC,CAAO;AAC1C;"}

package/dist/use-gesture/use-gesture.types.js

@@ -0,0 +1,12 @@
+const e = {
+  Tap: "tap",
+  DoubleTap: "doubletap",
+  Press: "press",
+  Swipe: "swipe",
+  Drag: "drag",
+  Pinch: "pinch"
+};
+export {
+  e as GestureTypes
+};
+//# sourceMappingURL=use-gesture.types.js.map

package/dist/use-gesture/use-gesture.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-gesture.types.js","sources":["../../src/use-gesture/use-gesture.types.ts"],"sourcesContent":["import { UseDoubleTapCallback, UseDoubleTapOptions } from \"../use-double-tap\";\nimport { UseDragCallback, UseDragOptions } from \"../use-drag\";\nimport { UsePinchCallback, UsePinchOptions } from \"../use-pinch\";\nimport { UsePressCallback, UsePressOptions } from \"../use-press\";\nimport {\n  SwipeDirection,\n  UseSwipeCallback,\n  UseSwipeOptions,\n} from \"../use-swipe\";\nimport { UseTapCallback, UseTapOptions } from \"../use-tap\";\n\nexport const GestureTypes = {\n  Tap: \"tap\",\n  DoubleTap: \"doubletap\",\n  Press: \"press\",\n  Swipe: \"swipe\",\n  Drag: \"drag\",\n  Pinch: \"pinch\",\n} as const;\n\nexport type GestureType = (typeof GestureTypes)[keyof typeof GestureTypes];\n\nexport type UseGestureSchema = GestureType;\n\ninterface UseGestureCallbackMap {\n  [GestureTypes.Tap]: UseTapCallback;\n  [GestureTypes.DoubleTap]: UseDoubleTapCallback;\n  [GestureTypes.Press]: UsePressCallback;\n  [GestureTypes.Swipe]: UseSwipeCallback;\n  [GestureTypes.Drag]: UseDragCallback;\n  [GestureTypes.Pinch]: UsePinchCallback;\n}\n\ninterface UseGestureOptionsMap {\n  [GestureTypes.Tap]: UseTapOptions;\n  [GestureTypes.DoubleTap]: UseDoubleTapOptions;\n  [GestureTypes.Press]: UsePressOptions;\n  [GestureTypes.Swipe]:\n    | ({ direction: SwipeDirection } & UseSwipeOptions)\n    | UseSwipeOptions;\n  [GestureTypes.Drag]: UseDragOptions;\n  [GestureTypes.Pinch]: UsePinchOptions;\n}\n\nexport type UseGestureCallback<T extends UseGestureSchema> =\n  UseGestureCallbackMap[T];\n\nexport type UseGestureOptions<T extends UseGestureSchema> =\n  UseGestureOptionsMap[T];\n"],"names":["GestureTypes"],"mappings":"AAWO,MAAMA,IAAe;AAAA,EAC1B,KAAK;AAAA,EACL,WAAW;AAAA,EACX,OAAO;AAAA,EACP,OAAO;AAAA,EACP,MAAM;AAAA,EACN,OAAO;AACT;"}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@msobiecki/react-marauders-path",
-  "version": "1.26.0",
+  "version": "1.28.0",
   "private": false,
-  "description": "A lightweight, type-safe React library for handling keyboard, wheel, swipe, drag, and pinch events. Perfect for games, interactive applications, and input-driven interfaces.",
+  "description": "A lightweight, type-safe React library for handling keyboard and pointer events in a unified way.",
   "keywords": [
     "react",
     "pointer",