@rootnative/impulse 0.0.0-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog
+
+All notable changes to `@rootnative/impulse` are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Pre-`1.0.0`, breaking changes may land in minor versions and are called out under their release.
+
+## [Unreleased]
+
+Nothing is published. This section holds the scaffold as it is built; the first release note is written when Milestone 1's graduation gate is met and `0.0.1` is cut.
+
+### Added
+
+- **`useDrag`** — the second intent hook, and the first continuous one. Shared values `x` and `y` that follow the finger on the UI thread and accumulate across gestures, `bounds` with an `elastic` coefficient, `onDragStart` / `onDragEnd` on the JS thread, and `onBegin` / `onUpdate` / `onFinalize` as worklets. Returns values and no style, and starts no animation: `onDragEnd` carries `velocity` and `settled` — the nearest in-bounds point — and the consumer springs it home. Reachable as `@rootnative/impulse/drag`.
+- **`useDrag`'s threshold is directional on a single axis and radial on both.** `axis: 'x'` maps to `activeOffsetX`, so a horizontal drag inside a vertical scroll view leaves the scroll alone until the finger commits sideways; `axis: 'both'` maps to `minDistance`. The default of 10 points is Impulse's — a bare `Gesture.Pan()` activates almost immediately, which is what makes a drag steal a scroll. `failOffset` is available for the stricter case and unset by default. The number has not been measured on hardware.
+- **`useDrag` does not jump by the threshold when it activates.** The finger has already travelled that distance when RNGH reports the start, and it stays in `translationX` for the rest of the gesture, so the offset is subtracted once at the start. Without that, the view leaps the threshold the moment the drag wins.
+- **`onDragEnd` is guarded on `success`.** RNGH calls `onEnd` for a cancelled gesture too. A cancelled drag never released and carries no velocity worth seeding a spring with, so it reaches `onFinalize` and not `onDragEnd`.
+- **Public types `DragAxis`, `DragBounds`, and `DragEvent`.**
+- **`example/screens/DragScreen.tsx`**, wired into the gallery. It carries Milestone 1's gate — a horizontal drag inside a vertical scroller — plus a two-axis drag that declares `blocks` against that scroller, and it springs both home from `settled` to show where Impulse stops and the consumer starts.
+- **`useTap`** — the first intent hook, and the pattern the rest follow. An intent-shaped payload (`{ x, y, absolute, pointers }`) instead of RNGH's flat event, `onTap` on the JS thread with Impulse owning the `runOnJS` boundary, `onBegin` / `onFinalize` as worklets, and an `isActive` shared value for a pressed state that needs no re-render. Reachable as `@rootnative/impulse/tap`.
+- **Activation criteria are Impulse's decision, not the platform's.** `maxDuration` restates RNGH's 500ms so the value cannot move underneath us in an RNGH release; `maxDistance` defaults to 10 points, which RNGH does **not** do — it defers to the platform there, so the same tap is accepted on one operating system and rejected on the other. Neither number has been measured on hardware.
+- **`useStableRecord`** — the record counterpart of `useStableList`. `hitSlop` is the first option a consumer writes as an object literal, so it is the first that would rebuild the gesture every render. Compared shallowly, an inline `hitSlop` no longer changes gesture identity.
+- **Public types `IntentResult`, `Point`, and `HitSlop`.** `IntentResult` is the `{ gesture, ref, isActive }` shape every intent hook returns. `HitSlop` is derived from RNGH's own method signature rather than copied, for the same reason `GestureReference` is.
+- **A Reanimated mock in `jest-setup.cjs`**, carrying only what Impulse's surface touches plus the two members RNGH's own `GestureDetector` needs. The stock `react-native-reanimated/mock` is not used because its `useSharedValue` returns a fresh object per render, which would make every hook's `isActive` silently dead. `useTap.test.tsx` pins that identity so the mock cannot regress to it unnoticed.
+- **`react-native-reanimated` added to the shipped preset's `transformIgnorePatterns`.** Impulse now imports it, so a consumer's Jest run needs it transformed.
+- **`example/screens/TapScreen.tsx`**, wired into the gallery. It exists for the two things Jest cannot check: whether the pressed state tracks the finger, and whether the 10-point distance default feels right.
+
+- **`useGestures`** — the composition surface, with all three modes (`race`, `simultaneous`, `exclusive`) and nesting. Composition is a flat list plus the relation that holds over it, so precedence reads left to right rather than inside out, and a composed result is itself a valid member. Tests assert the RNGH relation each mode produces after `prepare()`, not the class it constructs, because "who waits for whom" is what a consumer depends on.
+- **`alongside` / `blocks` / `deferTo` resolution.** The three coexistence options resolve to RNGH's three external-gesture relations in one module, `src/relations/`, so the choice is made once. All three may be set at once; they are independent relations, not a choice of one. Naming the same gesture in two of them is contradictory, so it warns in development and still applies both — Impulse cannot know which one was meant.
+- **`useRawGesture`** — the mechanism-level escape hatch. It takes a builder and a dependency list and returns a gesture with Impulse's memoisation, relation handling, and `ref` applied, for a recognizer the intent hooks do not model.
+- **Gesture identity is stable by construction.** A gesture is built once, inside the shared memoisation helper, and relations are applied in the same place — so "configured once" is tied to "built once" rather than to consumer discipline. `useLatestCallback` keeps a JS-thread callback out of the dependency list; a worklet callback stays a direct dependency, because a worklet is captured as written. `useStableList` compares coexistence options by content, so an inline `deferTo: [scrollRef]` does not rebuild the gesture it configures. `src/__tests__/gestureIdentity.test.tsx` pins all of it, including the asymmetry.
+- **`@rootnative/impulse/compose` and `@rootnative/impulse/raw`** — per-hook subpaths, so an app that uses one does not ship the set.
+- **Public type `AttachableGesture`** — a gesture `<GestureDetector>` accepts, single or composed. RNGH spells this inline in its props and exports no name for it, so a compile-time assertion pins ours to theirs.
+- **Repository scaffold.** pnpm 10 workspace, Turborepo, TypeScript 5 strict mode, ESLint flat config, Prettier, and Jest 29. `build`, `dev`, `typecheck`, `test`, `lint`, and `format` run from the root and are green.
+- **`@rootnative/impulse/gesture-handler`** — the RNGH interop subpath. Pure re-exports of RNGH's primitives under their original names, so an app that needs a mechanism Impulse does not model still has `@rootnative/impulse` as its only gesture import. A test asserts every symbol is re-exported **by reference**, not through a wrapper, and it is written against RNGH's own export list so a symbol added upstream is covered without an edit.
+- **`GestureDetector`** re-exported from the root entry. Every hook's result is handed to it.
+- **Public types** — `CoexistenceOptions` (`alongside` / `blocks` / `deferTo`), `ComposeMode`, `GestureReference`, `GestureReferences`.
+- **`@rootnative/impulse/jest-preset`** and `@rootnative/impulse/jest-setup`. The preset layers RNGH's own `jestSetup` onto `@react-native/jest-preset` and widens `transformIgnorePatterns` for this package's ESM bundle. Workspace-internal tests run through the same preset that ships, so a missing mock fails here before it fails for a consumer.
+- **`scripts/check-versions.mjs`** — the release-consistency guard. It verifies that exactly one public package exists, that the CHANGELOG has a section for the current version, that the link footer resolves, that the status lines in both READMEs are current, and that no `v`-prefixed version string reaches a published surface.
+- **`example/`** — Expo SDK 57 app for manual validation. It carries the navigator shell and no intent screens yet; a screen is added with each intent, and a device pass is a release requirement.
+
+### Notes
+
+- **The package ships ESM only.** CJS with code splitting defeats the Reanimated Babel plugin and ships worklets that crash on native — that defect cost `@rootnative/components` two releases. See the comment in `tsup.config.ts` before changing the format.
+- **`useTap` and `useDrag` are the intents implemented.** `useSwipe`, `usePinch`, and the rest are designed but not written. Milestone 1's code is now complete; its graduation gate is a device pass that has not happened, so every activation-criteria default in this release is a design intention rather than a measurement.
+- **A pan that fails before it activates cannot be tested in Jest.** RNGH's mock fills every gesture's state sequence from `[BEGAN, ACTIVE, END]`, so it injects an ACTIVE event before any FAILED it is given and the drag always starts. The threshold's real effect is checked on the example screen.
+- **A relation cannot name a component ref without a cast.** RNGH types a relation target as `RefObject<ComponentType | undefined | null>` — a ref to a component *type*, which is not what `ref={}` produces — so a real `ScrollView` ref does not typecheck. Impulse's `GestureReference` mirrors RNGH's type exactly, so the mismatch is visible rather than absorbed.
+- **`useGestures` does not take coexistence options**, and that is a limitation rather than a choice. RNGH's three external-gesture relations are methods on a single gesture, and a composed gesture does not have them. Set `alongside` / `blocks` / `deferTo` on the member hooks instead.
+- **Impulse does not yet warn when a hook mounts with no `<GestureHandlerRootView>` above it.** RNGH's root-view context is not exported from its package entry, and reaching it would mean a deep import into `lib/commonjs/`, which pins one module format and breaks under the others.
+
+[unreleased]: https://github.com/rootnative/impulse/commits/main

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RootNative
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+<!--
+  Absolute URL, not a relative path: this README is the npm package page, and
+  npm does not resolve repository-relative image paths.
+-->
+<img src="https://raw.githubusercontent.com/rootnative/impulse/main/assets/brand/impulse-mark.png" alt="" width="88" height="88" />
+
+# @rootnative/impulse
+
+[![npm](https://img.shields.io/npm/v/@rootnative/impulse.svg)](https://www.npmjs.com/package/@rootnative/impulse)
+[![Gesture Handler 2](https://img.shields.io/badge/gesture--handler-2.x-6B4FBB)](https://docs.swmansion.com/react-native-gesture-handler/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+
+Declarative gesture primitives for React Native, built as a thin wrapper around [`react-native-gesture-handler`](https://docs.swmansion.com/react-native-gesture-handler/). A gesture is written as an intent, not assembled from a builder chain.
+
+> **Status:** `0.0.0-alpha.0` — pre-release, not published. What ships today is the composition and coexistence core — `useGestures`, `useRawGesture`, and the `alongside` / `blocks` / `deferTo` options — plus `useTap`, the first intent hook, and the `@rootnative/impulse/gesture-handler` interop subpath. Every other intent hook is **not implemented**. See the [CHANGELOG](https://github.com/rootnative/impulse/blob/main/packages/core/CHANGELOG.md).
+
+## Install
+
+```sh
+pnpm add @rootnative/impulse react-native-gesture-handler react-native-reanimated
+```
+
+Then follow the [gesture-handler install guide](https://docs.swmansion.com/react-native-gesture-handler/docs/fundamentals/installation) and the [Reanimated install guide](https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/installation) to enable their Babel plugins.
+
+**Peer dependencies:** `react >=19.2.3`, `react-native >=0.83.0 <0.87.0`, `react-native-gesture-handler >=2.28.0 <3.0.0`, `react-native-reanimated >=4.5.0 <4.6.0`, `react-native-worklets >=0.10.0 <0.11.0`.
+
+Wrap your app in `<GestureHandlerRootView>`. Without it a gesture never fires, and it fails silently — nothing happens and nothing is logged.
+
+## Impulse or `@rootnative/inertia-gestures`?
+
+Both build on gesture-handler, and both ship a `useDrag`, a `usePan`, and a `useSwipe`. They answer different questions, and the peer list is the quickest way to tell them apart.
+
+| | `@rootnative/impulse` | `@rootnative/inertia-gestures` |
+| --- | --- | --- |
+| Animation library required | No | Yes — `@rootnative/inertia` is a mandatory peer |
+| `useDrag` gives you | `gesture`, `ref`, and shared values | an `animatedStyle` `transform` fragment, plus `dragX` / `dragY` |
+| Bounds and spring-back | Not included — Impulse starts no animation | Included |
+
+Reach for **`-gestures`** when you want a Motion primitive to follow a finger and spring back, and you are already using Inertia. Reach for **Impulse** when you want the gesture itself — to drive your own values, to compose recognizers, or in an app that has no animation library at all.
+
+Neither is a replacement for the other, and `-gestures` is not deprecated.
+
+## What ships today
+
+### `useTap` — the first intent
+
+One hook, one intent. The callback name states its thread: `onTap` runs on the JS thread and may set React state directly, because Impulse owns the `runOnJS` boundary. `onBegin` and `onFinalize` are worklets.
+
+```tsx
+import { GestureDetector, useTap } from '@rootnative/impulse'
+import Animated, { useAnimatedStyle } from 'react-native-reanimated'
+
+const tap = useTap({
+  onTap: (event) => select(event.x, event.y),
+})
+
+// `isActive` is a shared value, so a pressed state costs no re-render.
+const style = useAnimatedStyle(() => ({
+  opacity: tap.isActive.value ? 0.55 : 1,
+}))
+
+return (
+  <GestureDetector gesture={tap.gesture}>
+    <Animated.View style={style} />
+  </GestureDetector>
+)
+```
+
+The payload is shaped by intent rather than passed through: `{ x, y, absolute: { x, y }, pointers }`. RNGH's flat `absoluteX` / `absoluteY` never reach you.
+
+**Activation criteria**, and both are Impulse's decision:
+
+| Option | Default | Note |
+| --- | --- | --- |
+| `maxDuration` | `500` ms | RNGH's own default, restated so it cannot move underneath you in an RNGH release. |
+| `maxDistance` | `10` points | **Not** RNGH's behaviour. RNGH defers the slop to the platform, so the same tap is accepted on one operating system and rejected on the other. |
+| `pointers` | `1` | Raise it for a two-finger tap. |
+
+Neither default has been measured on hardware yet.
+
+**Accessibility.** A tap gesture is invisible to a screen reader and unreachable from a keyboard, and this hook does not fix that. Whatever the tap does must also be reachable another way — the same action on a `<Pressable>`, or `accessibilityActions` on the view. A tap-only affordance is a bug, not a trade-off.
+
+**Web.** A single-finger tap behaves as it does on native. `pointers` above 1 is unreliable, because a mouse reports one pointer and touch emulation varies by browser.
+
+### `useGestures` — composition
+
+Composition is **data, not nesting**. One flat list plus the relation that holds over it, and the result is itself a member, so precedence reads left to right instead of inside out.
+
+```tsx
+import { GestureDetector, useGestures } from '@rootnative/impulse'
+
+// tap and double-tap race; the winner runs alongside the drag
+const { gesture } = useGestures(
+  [useGestures([tap, double], { mode: 'race' }), drag],
+  { mode: 'simultaneous' },
+)
+
+return (
+  <GestureDetector gesture={gesture}>
+    <View />
+  </GestureDetector>
+)
+```
+
+`mode` is `'race'` (first to activate wins), `'simultaneous'` (each recognizes independently), or `'exclusive'` (a later member activates only after every earlier one fails).
+
+### `alongside` / `blocks` / `deferTo` — coexistence
+
+RNGH exposes three external-gesture relations whose names describe the mechanism and give no hint which one a case wants. These name the outcome, and each maps to exactly one of them.
+
+```tsx
+useRawGesture(build, deps, { alongside: pinchRef }) // both recognize at once
+useRawGesture(build, deps, { blocks: listRef })     // this gesture wins
+useRawGesture(build, deps, { deferTo: scrollRef })  // the other one wins
+```
+
+All three may be set at once — they are independent relations, not a choice of one. Naming the same gesture in two of them warns in development.
+
+### `useRawGesture` — the escape hatch
+
+For a recognizer the intent hooks will not model. You own the dependency list, the thread, and the payload; Impulse still owns gesture identity, relation resolution, and a `ref` other hooks can name.
+
+```tsx
+import { useRawGesture } from '@rootnative/impulse'
+import { Directions, Gesture } from '@rootnative/impulse/gesture-handler'
+
+const fling = useRawGesture(
+  () => Gesture.Fling().direction(Directions.RIGHT).onEnd(onFling),
+  [onFling],
+  { deferTo: scrollRef },
+)
+```
+
+### The rest
+
+- **`GestureDetector`**, re-exported from the root entry. Every hook's result is handed to it, so reaching for it is not a reason to add a second gesture import to an app.
+- **`@rootnative/impulse/gesture-handler`** — RNGH's own primitives, re-exported under their original names by reference. It keeps `@rootnative/impulse` the only gesture import in an app.
+- **Subpaths** — `@rootnative/impulse/tap`, `@rootnative/impulse/compose`, and `@rootnative/impulse/raw`, so an app that uses one hook does not ship the set.
+- **Types** — `AttachableGesture`, `CoexistenceOptions`, `ComposeMode`, `GestureReference`, `GestureReferences`, `HitSlop`, `IntentResult`, `Point`, and per-intent `TapEvent` / `UseTapOptions` / `UseTapResult`.
+- **`@rootnative/impulse/jest-preset`** — one-line Jest wiring, layered on `@react-native/jest-preset`.
+
+## Gesture identity is stable by construction
+
+A gesture whose shape changed is re-attached by `<GestureDetector>`, and a re-attach mid-drag drops the drag. An inline callback or an inline `deferTo: [ref]` is enough to cause it. Impulse builds every gesture once and configures it in the same place, routes JS-thread callbacks through a latest-value ref so they are never gesture dependencies, and compares options written as literals — a `deferTo: [ref]` array, a `hitSlop: { horizontal: 12 }` object — by content rather than by identity.
+
+Worklet callbacks are the deliberate exception: a worklet is captured as written and serialized to the UI thread, so it stays a direct dependency and changing it does rebuild the gesture. That asymmetry is why the callback name states its thread.
+
+## What does not ship yet
+
+Every intent hook except `useTap` — `useDoubleTap`, `useLongPress`, `useDrag`, `usePan`, `useSwipe`, `usePinch`, `useRotate`, `useHover`, `useEdgeSwipe`. They are designed and the design is locked; none of them is written.
+
+Two further limits today:
+
+- **`useGestures` does not take coexistence options.** RNGH's three relations are methods on a single gesture, and a composed gesture does not have them. Set them on the member hooks instead.
+- **No warning when `<GestureHandlerRootView>` is missing.** Its absence is silent — the gesture simply never fires — and RNGH does not export the context that would let Impulse detect it.
+
+## Testing
+
+```js
+// jest.config.js
+module.exports = {
+  preset: require.resolve('@rootnative/impulse/jest-preset'),
+}
+```
+
+The preset also needs `@react-native/jest-preset` as a devDependency at the version matching your `react-native`. React Native 0.86 moved its Jest preset into that package and declares it as an optional peer, so no package manager installs it for you.
+
+## Documentation
+
+The docs site is not built yet. Until it is, the [repository README](https://github.com/rootnative/impulse) carries the design principles, the boundary with `@rootnative/inertia`, and the roadmap.
+
+## Licence
+
+MIT © RootNative. See [LICENSE](./LICENSE).

package/dist/chunk-5BMRKYVY.js

@@ -0,0 +1,39 @@
+import { useRef, useInsertionEffect, useCallback } from 'react';
+
+// src/internal/useLatestCallback.ts
+function useLatestCallback(callback) {
+  const latest = useRef(callback);
+  useInsertionEffect(() => {
+    latest.current = callback;
+  });
+  return useCallback((...args) => latest.current?.(...args), []);
+}
+function sameEntries(a, b) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  const left = a;
+  const right = b;
+  const leftKeys = Object.keys(left);
+  if (leftKeys.length !== Object.keys(right).length) {
+    return false;
+  }
+  for (const key of leftKeys) {
+    if (!Object.is(left[key], right[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function useStableRecord(value) {
+  const held = useRef(value);
+  if (!sameEntries(held.current, value)) {
+    held.current = value;
+  }
+  return held.current;
+}
+
+export { useLatestCallback, useStableRecord };

package/dist/chunk-F4RHM4ZK.js

@@ -0,0 +1,77 @@
+import { useStableList, isDevBuild, warnOnce } from './chunk-ZX7WNICB.js';
+import { useRef, useMemo } from 'react';
+
+// src/relations/index.ts
+var RELATIONS = [
+  ["alongside", "simultaneousWithExternalGesture"],
+  ["blocks", "blocksExternalGesture"],
+  ["deferTo", "requireExternalGestureToFail"]
+];
+function applyRelations(gesture, relations, hookName) {
+  warnOnConflictingRelations(relations, hookName);
+  for (const [option, method] of RELATIONS) {
+    const references = relations[option];
+    if (references.length > 0) {
+      gesture[method](...references);
+    }
+  }
+}
+function warnOnConflictingRelations(relations, hookName) {
+  if (!isDevBuild()) {
+    return;
+  }
+  const namedBy = /* @__PURE__ */ new Map();
+  for (const [option] of RELATIONS) {
+    for (const reference of relations[option]) {
+      const options = namedBy.get(reference);
+      if (options) {
+        options.push(option);
+      } else {
+        namedBy.set(reference, [option]);
+      }
+    }
+  }
+  for (const options of namedBy.values()) {
+    if (options.length > 1) {
+      const listed = options.map((option) => `\`${option}\``).join(" and ");
+      warnOnce(
+        `relations:conflict:${hookName}:${options.join("+")}`,
+        `${hookName} names the same gesture in ${listed}. Those are independent relations, not a choice of one, so both are applied and they contradict each other. Keep the one that describes the outcome you want: \`alongside\` for both recognizing at once, \`blocks\` for this gesture winning, \`deferTo\` for the other one winning.`
+      );
+    }
+  }
+}
+
+// src/internal/useGestureMemo.ts
+function useGestureMemo(hookName, build, deps, options) {
+  const alongside = useStableList(options?.alongside);
+  const blocks = useStableList(options?.blocks);
+  const deferTo = useStableList(options?.deferTo);
+  const testId = options?.testId;
+  const ref = useRef(void 0);
+  const gesture = useMemo(
+    () => {
+      const built = build();
+      const base = built;
+      base.withRef(ref);
+      if (testId !== void 0) {
+        base.withTestId(testId);
+      }
+      applyRelations(base, { alongside, blocks, deferTo }, hookName);
+      return built;
+    },
+    // `build` is deliberately absent: it is written inline at every call
+    // site, so its identity changes every render and including it would
+    // rebuild the gesture every render — the exact defect this helper
+    // exists to prevent. `deps` is what the caller declares instead, which
+    // is the same contract `useMemo` itself has. The lint rule cannot see
+    // through a forwarded dependency list, and the spread is what makes the
+    // array one flat list rather than a nested one; its length is fixed per
+    // call site, which is what React requires.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...deps, alongside, blocks, deferTo, testId, hookName]
+  );
+  return useMemo(() => ({ gesture, ref }), [gesture]);
+}
+
+export { useGestureMemo };

package/dist/chunk-FR242SUF.js

@@ -0,0 +1,174 @@
+import { useStableRecord, useLatestCallback } from './chunk-5BMRKYVY.js';
+import { useGestureMemo } from './chunk-F4RHM4ZK.js';
+import { useMemo } from 'react';
+import { Gesture } from 'react-native-gesture-handler';
+import { useSharedValue, runOnJS } from 'react-native-reanimated';
+
+var DEFAULT_THRESHOLD = 10;
+function resist(value, min, max, elastic) {
+  "worklet";
+  if (min !== void 0 && value < min) {
+    return min + (value - min) * elastic;
+  }
+  if (max !== void 0 && value > max) {
+    return max + (value - max) * elastic;
+  }
+  return value;
+}
+function clamp(value, min, max) {
+  "worklet";
+  if (min !== void 0 && value < min) {
+    return min;
+  }
+  if (max !== void 0 && value > max) {
+    return max;
+  }
+  return value;
+}
+function useDrag(options = {}) {
+  const {
+    axis = "both",
+    threshold = DEFAULT_THRESHOLD,
+    failOffset,
+    elastic = 0,
+    pointers,
+    enabled,
+    onDragStart,
+    onDragEnd,
+    onBegin,
+    onUpdate,
+    onFinalize
+  } = options;
+  const x = useSharedValue(options.initial?.x ?? 0);
+  const y = useSharedValue(options.initial?.y ?? 0);
+  const isActive = useSharedValue(false);
+  const startX = useSharedValue(0);
+  const startY = useSharedValue(0);
+  const bounds = useStableRecord(options.bounds);
+  const hitSlop = useStableRecord(options.hitSlop);
+  const left = bounds?.left;
+  const right = bounds?.right;
+  const top = bounds?.top;
+  const bottom = bounds?.bottom;
+  const movesX = axis !== "y";
+  const movesY = axis !== "x";
+  const handleDragStart = useLatestCallback(onDragStart);
+  const handleDragEnd = useLatestCallback(onDragEnd);
+  const hasDragStart = onDragStart !== void 0;
+  const hasDragEnd = onDragEnd !== void 0;
+  const built = useGestureMemo(
+    "useDrag",
+    () => {
+      const toDragEvent = (event) => {
+        "worklet";
+        const position = { x: x.value, y: y.value };
+        return {
+          position,
+          translation: { x: event.translationX, y: event.translationY },
+          velocity: { x: event.velocityX, y: event.velocityY },
+          absolute: { x: event.absoluteX, y: event.absoluteY },
+          settled: {
+            x: clamp(position.x, left, right),
+            y: clamp(position.y, top, bottom)
+          },
+          pointers: event.numberOfPointers
+        };
+      };
+      const pan = Gesture.Pan().onBegin((event) => {
+        "worklet";
+        onBegin?.(toDragEvent(event));
+      }).onStart((event) => {
+        "worklet";
+        startX.value = x.value - event.translationX;
+        startY.value = y.value - event.translationY;
+        isActive.value = true;
+        if (hasDragStart) {
+          runOnJS(handleDragStart)(toDragEvent(event));
+        }
+      }).onUpdate((event) => {
+        "worklet";
+        if (movesX) {
+          x.value = resist(
+            startX.value + event.translationX,
+            left,
+            right,
+            elastic
+          );
+        }
+        if (movesY) {
+          y.value = resist(
+            startY.value + event.translationY,
+            top,
+            bottom,
+            elastic
+          );
+        }
+        onUpdate?.(toDragEvent(event));
+      }).onEnd((event, success) => {
+        "worklet";
+        if (success && hasDragEnd) {
+          runOnJS(handleDragEnd)(toDragEvent(event));
+        }
+      }).onFinalize((event, success) => {
+        "worklet";
+        isActive.value = false;
+        onFinalize?.(toDragEvent(event), success);
+      });
+      if (axis === "x") {
+        pan.activeOffsetX([-threshold, threshold]);
+      } else if (axis === "y") {
+        pan.activeOffsetY([-threshold, threshold]);
+      } else {
+        pan.minDistance(threshold);
+      }
+      if (failOffset !== void 0) {
+        if (axis === "x") {
+          pan.failOffsetY([-failOffset, failOffset]);
+        } else if (axis === "y") {
+          pan.failOffsetX([-failOffset, failOffset]);
+        }
+      }
+      if (pointers !== void 0) {
+        pan.minPointers(pointers).maxPointers(pointers);
+      }
+      if (hitSlop !== void 0) {
+        pan.hitSlop(hitSlop);
+      }
+      if (enabled !== void 0) {
+        pan.enabled(enabled);
+      }
+      return pan;
+    },
+    [
+      axis,
+      threshold,
+      failOffset,
+      left,
+      right,
+      top,
+      bottom,
+      elastic,
+      pointers,
+      hitSlop,
+      enabled,
+      movesX,
+      movesY,
+      hasDragStart,
+      hasDragEnd,
+      handleDragStart,
+      handleDragEnd,
+      x,
+      y,
+      startX,
+      startY,
+      isActive,
+      onBegin,
+      onUpdate,
+      onFinalize
+    ],
+    options
+  );
+  return useMemo(() => ({ ...built, x, y, isActive }), [built, x, y, isActive]);
+}
+
+export { useDrag };

package/dist/chunk-IG5RXCYR.js

@@ -0,0 +1,74 @@
+import { useStableRecord, useLatestCallback } from './chunk-5BMRKYVY.js';
+import { useGestureMemo } from './chunk-F4RHM4ZK.js';
+import { useMemo } from 'react';
+import { Gesture } from 'react-native-gesture-handler';
+import { useSharedValue, runOnJS } from 'react-native-reanimated';
+
+var DEFAULT_MAX_DURATION = 500;
+var DEFAULT_MAX_DISTANCE = 10;
+function toTapEvent(event) {
+  "worklet";
+  return {
+    x: event.x,
+    y: event.y,
+    absolute: { x: event.absoluteX, y: event.absoluteY },
+    pointers: event.numberOfPointers
+  };
+}
+function useTap(options = {}) {
+  const {
+    pointers = 1,
+    maxDuration = DEFAULT_MAX_DURATION,
+    maxDistance = DEFAULT_MAX_DISTANCE,
+    enabled,
+    onTap,
+    onBegin,
+    onFinalize
+  } = options;
+  const isActive = useSharedValue(false);
+  const hitSlop = useStableRecord(options.hitSlop);
+  const handleTap = useLatestCallback(onTap);
+  const hasTapHandler = onTap !== void 0;
+  const built = useGestureMemo(
+    "useTap",
+    () => {
+      const tap = Gesture.Tap().numberOfTaps(1).minPointers(pointers).maxDuration(maxDuration).maxDistance(maxDistance).onBegin((event) => {
+        "worklet";
+        isActive.value = true;
+        onBegin?.(toTapEvent(event));
+      }).onEnd((event, success) => {
+        "worklet";
+        if (success && hasTapHandler) {
+          runOnJS(handleTap)(toTapEvent(event));
+        }
+      }).onFinalize((event, success) => {
+        "worklet";
+        isActive.value = false;
+        onFinalize?.(toTapEvent(event), success);
+      });
+      if (hitSlop !== void 0) {
+        tap.hitSlop(hitSlop);
+      }
+      if (enabled !== void 0) {
+        tap.enabled(enabled);
+      }
+      return tap;
+    },
+    [
+      pointers,
+      maxDuration,
+      maxDistance,
+      hitSlop,
+      enabled,
+      hasTapHandler,
+      handleTap,
+      isActive,
+      onBegin,
+      onFinalize
+    ],
+    options
+  );
+  return useMemo(() => ({ ...built, isActive }), [built, isActive]);
+}
+
+export { useTap };

package/dist/chunk-LM645QQT.js

@@ -0,0 +1,37 @@
+import { useStableList, warnOnce } from './chunk-ZX7WNICB.js';
+import { useMemo } from 'react';
+import { Gesture } from 'react-native-gesture-handler';
+
+function useGestures(members, options) {
+  const { mode } = options;
+  const gestures = useStableList(members.map(memberGesture));
+  const gesture = useMemo(() => compose(mode, gestures), [mode, gestures]);
+  return useMemo(() => ({ gesture }), [gesture]);
+}
+function memberGesture(member) {
+  return "gesture" in member ? member.gesture : member;
+}
+function compose(mode, gestures) {
+  if (gestures.length === 0) {
+    warnOnce(
+      "compose:empty",
+      "useGestures was given an empty list. The composition recognizes nothing, so the `<GestureDetector>` holding it is inert. Build the list conditionally around the hook call rather than passing no members."
+    );
+  }
+  switch (mode) {
+    case "race":
+      return Gesture.Race(...gestures);
+    case "simultaneous":
+      return Gesture.Simultaneous(...gestures);
+    case "exclusive":
+      return Gesture.Exclusive(...gestures);
+    default:
+      warnOnce(
+        `compose:mode:${String(mode)}`,
+        `useGestures received an unknown mode ${JSON.stringify(mode)}. Falling back to \`race\`. Valid modes are \`race\`, \`simultaneous\`, and \`exclusive\`.`
+      );
+      return Gesture.Race(...gestures);
+  }
+}
+
+export { useGestures };

package/dist/chunk-PMR25UCT.js

@@ -0,0 +1,8 @@
+import { useGestureMemo } from './chunk-F4RHM4ZK.js';
+
+// src/raw/useRawGesture.ts
+function useRawGesture(build, deps, options) {
+  return useGestureMemo("useRawGesture", build, deps, options);
+}
+
+export { useRawGesture };