@rootnative/impulse 0.0.0-alpha.0 → 0.0.0-alpha.1

package/dist/chunk-YZHAQ4XK.js

@@ -0,0 +1,136 @@
+import { useStableRecord, useLatestCallback, buildIntentResult } from './chunk-2UZTAWUQ.js';
+import { useGestureMemo } from './chunk-NYDDZD4G.js';
+import { useMemo } from 'react';
+import { Gesture } from 'react-native-gesture-handler';
+import { useSharedValue } from 'react-native-reanimated';
+import { scheduleOnRN } from 'react-native-worklets';
+
+var DEGREES_PER_RADIAN = 180 / Math.PI;
+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 useRotate(options = {}) {
+  const {
+    initial = 0,
+    min,
+    max,
+    elastic = 0,
+    enabled,
+    onRotateStart,
+    onRotateEnd,
+    onBegin,
+    onUpdate,
+    onFinalize
+  } = options;
+  const angle = useSharedValue(initial);
+  const anchor = useSharedValue({ x: 0, y: 0 });
+  const isActive = useSharedValue(false);
+  const startAngle = useSharedValue(initial);
+  const hitSlop = useStableRecord(options.hitSlop);
+  const handleRotateStart = useLatestCallback(onRotateStart);
+  const handleRotateEnd = useLatestCallback(onRotateEnd);
+  const hasRotateStart = onRotateStart !== void 0;
+  const hasRotateEnd = onRotateEnd !== void 0;
+  const built = useGestureMemo(
+    "useRotate",
+    () => {
+      const toRotateEvent = (event) => {
+        "worklet";
+        return {
+          angle: angle.value,
+          gestureAngle: event.rotation * DEGREES_PER_RADIAN,
+          anchor: anchor.value,
+          velocity: event.velocity * DEGREES_PER_RADIAN,
+          settled: clamp(angle.value, min, max),
+          pointers: event.numberOfPointers
+        };
+      };
+      const trackAnchor = (event) => {
+        "worklet";
+        anchor.value = { x: event.anchorX, y: event.anchorY };
+      };
+      const rotation = Gesture.Rotation().onBegin((event) => {
+        "worklet";
+        onBegin?.(toRotateEvent(event));
+      }).onStart((event) => {
+        "worklet";
+        startAngle.value = angle.value - event.rotation * DEGREES_PER_RADIAN;
+        trackAnchor(event);
+        isActive.value = true;
+        if (hasRotateStart) {
+          scheduleOnRN(handleRotateStart, toRotateEvent(event));
+        }
+      }).onUpdate((event) => {
+        "worklet";
+        trackAnchor(event);
+        angle.value = resist(
+          startAngle.value + event.rotation * DEGREES_PER_RADIAN,
+          min,
+          max,
+          elastic
+        );
+        onUpdate?.(toRotateEvent(event));
+      }).onEnd((event, success) => {
+        "worklet";
+        if (hasRotateEnd) {
+          scheduleOnRN(handleRotateEnd, toRotateEvent(event), {
+            cancelled: !success
+          });
+        }
+      }).onFinalize((event, success) => {
+        "worklet";
+        isActive.value = false;
+        onFinalize?.(toRotateEvent(event), success);
+      });
+      if (hitSlop !== void 0) {
+        rotation.hitSlop(hitSlop);
+      }
+      if (enabled !== void 0) {
+        rotation.enabled(enabled);
+      }
+      return rotation;
+    },
+    [
+      min,
+      max,
+      elastic,
+      hitSlop,
+      enabled,
+      hasRotateStart,
+      hasRotateEnd,
+      handleRotateStart,
+      handleRotateEnd,
+      angle,
+      anchor,
+      startAngle,
+      isActive,
+      onBegin,
+      onUpdate,
+      onFinalize
+    ],
+    options
+  );
+  return useMemo(
+    () => buildIntentResult(built, { angle, anchor, isActive }),
+    [built, angle, anchor, isActive]
+  );
+}
+
+export { useRotate };

package/dist/compose/index.d.ts

@@ -1,5 +1,5 @@
 import { ComposedGesture } from 'react-native-gesture-handler';
-import { A as AttachableGesture, a as ComposeMode } from '../types-Ch2HM3aP.js';
+import { A as AttachableGesture, a as ComposeMode } from '../types-ChGKY28a.js';
 import 'react';
 import 'react-native-reanimated';
 

package/dist/double-tap/index.d.ts

@@ -0,0 +1,184 @@
+import { TapGesture } from 'react-native-gesture-handler';
+import { G as GestureMemoOptions } from '../useGestureMemo-BRW1EKcJ.js';
+import { T as TapEvent } from '../tapEvent-KSSojt_l.js';
+import { H as HitSlop, I as IntentEndInfo, c as IntentResult } from '../types-ChGKY28a.js';
+import 'react';
+import 'react-native-reanimated';
+
+/** Options for {@link useDoubleTap}. */
+interface UseDoubleTapOptions extends GestureMemoOptions {
+    /**
+     * How many fingers must be down. Default `1`.
+     *
+     * The count applies to both taps — a two-finger double tap is two taps of
+     * two fingers, not a tap of two followed by a tap of one.
+     */
+    pointers?: number;
+    /**
+     * How long each tap may hold the finger down, in milliseconds. Default
+     * `500`.
+     *
+     * This is per tap, not for the pair. A finger that stays down past it fails
+     * the gesture rather than counting as the second tap.
+     */
+    maxDuration?: number;
+    /**
+     * How long the gap between the two taps may be, in milliseconds. Default
+     * `500`.
+     *
+     * **Lowering it is how a composed single tap stops feeling slow.** When a
+     * `useTap` is composed `exclusive` behind this hook, the single tap cannot
+     * report until this window has passed without a second tap, so every
+     * ordinary tap on that view waits this long. 500ms is RNGH's number and is
+     * generous; 250 to 300 is closer to what the platforms themselves use.
+     *
+     * The device sweep of 2026-09-19 found that a deliberate double tap still
+     * registers at 250, on an Android emulator and an iOS simulator. Whether
+     * the single-tap latency feels acceptable is unmeasured. See Known gaps in
+     * docs/docs/roadmap.md.
+     */
+    maxDelay?: number;
+    /**
+     * How far the finger may travel within a tap, in points. Default `10`.
+     *
+     * This does not limit how far the second tap may land from the first — RNGH
+     * measures each tap on its own.
+     */
+    maxDistance?: number;
+    /**
+     * Extra touchable area around the view, in points.
+     *
+     * Written inline as an object is fine — the gesture is not rebuilt when the
+     * contents are unchanged.
+     */
+    hitSlop?: HitSlop;
+    /**
+     * Whether the gesture is recognized at all. Default `true`.
+     *
+     * Prefer this over unmounting the `<GestureDetector>`: a disabled gesture
+     * keeps its identity and its relations, so re-enabling it does not
+     * re-attach anything.
+     */
+    enabled?: boolean;
+    /**
+     * The double tap ended. **Runs on the JS thread** — Impulse owns the
+     * `scheduleOnRN` boundary, so this is an ordinary function and may touch React
+     * state.
+     *
+     * The payload describes the second tap, which is the one the consumer means
+     * when they ask where the double tap was.
+     *
+     * It fires only for a double tap the recognizer accepted, and `cancelled`
+     * says what happened after that. `false` is the ordinary double tap. `true`
+     * means the system took the recognized double tap away — a competing
+     * gesture in a relation won it, or the app went to the background.
+     *
+     * **Check `cancelled` before you act on it.** A handler that zooms or
+     * navigates should do nothing when it is `true`. The path is rare: a single
+     * tap that was never followed by a second reaches `onFinalize` with
+     * `success: false` and never gets here.
+     */
+    onDoubleTap?: (event: TapEvent, info: IntentEndInfo) => void;
+    /**
+     * The first finger went down and the gesture is now a candidate. **This is
+     * a worklet** — mark it with the `'worklet'` directive, and do not touch
+     * React state from it.
+     *
+     * It fires once for the pair, on the first touch, not once per tap. Most of
+     * the touches that reach it are ordinary single taps that will fail this
+     * gesture, so it is a poor place to show anything the user would read as
+     * commitment.
+     */
+    onBegin?: (event: TapEvent) => void;
+    /**
+     * The gesture is over, whether both taps happened or not. **This is a
+     * worklet.**
+     *
+     * `success` is `true` when the double tap was recognized. This is the right
+     * place to clear anything `onBegin` set, because it runs on both paths.
+     */
+    onFinalize?: (event: TapEvent, success: boolean) => void;
+}
+/**
+ * What {@link useDoubleTap} returns.
+ *
+ * Its own name rather than an alias of `UseTapResult`, so the two can diverge
+ * without a breaking rename. A double tap produces no continuous value, so
+ * the gesture, the ref, and `isActive` are the whole result.
+ */
+type UseDoubleTapResult = IntentResult<TapGesture>;
+/**
+ * Recognize two taps in quick succession.
+ *
+ * ```tsx
+ * const double = useDoubleTap({ onDoubleTap: () => zoomIn() })
+ *
+ * return (
+ *   <GestureDetector gesture={double.gesture}>
+ *     <View />
+ *   </GestureDetector>
+ * )
+ * ```
+ *
+ * `onDoubleTap` runs on the JS thread and may set React state directly.
+ * `onBegin` and `onFinalize` are worklets and run on the UI thread — the name
+ * states the thread, so there is nothing to configure and no `scheduleOnRN` to
+ * write.
+ *
+ * `isActive` is a shared value that is `true` from the first finger down
+ * until the pair resolves. It is **not** a useful pressed state on its own:
+ * it is `true` for every ordinary single tap on the view as well, and those
+ * mostly end in failure. Drive a pressed state from a `useTap` composed with
+ * this one, and use `isActive` here only for something that should show while
+ * a double tap is genuinely in progress.
+ *
+ * **Pairing with a single tap.** This is the composition that makes both
+ * work, and the mode matters:
+ *
+ * ```tsx
+ * const double = useDoubleTap({ maxDelay: 250, onDoubleTap: zoomIn })
+ * const tap = useTap({ onTap: select })
+ * const { gesture } = useGestures([double, tap], { mode: 'exclusive' })
+ * ```
+ *
+ * `exclusive` tries the members in order and lets a later one activate only
+ * after every earlier one has failed, so the single tap waits to learn
+ * whether a second tap is coming. `race` does not work: a single tap
+ * recognizes on the first release and would win every time. The cost is
+ * latency — the single tap cannot report for `maxDelay` milliseconds — which
+ * is why lowering `maxDelay` is the first thing to reach for when a composed
+ * single tap feels slow.
+ *
+ * **A view that only needs a double tap does not need the composition.** Use
+ * this hook alone; there is nothing for it to wait on.
+ *
+ * **Three taps and up are not modelled.** A triple tap is rare enough that a
+ * named intent would be dead API. Build it with `useRawGesture` and
+ * `Gesture.Tap().numberOfTaps(3)`.
+ *
+ * **Activation criteria.** `maxDuration` and `maxDelay` default to 500ms, and
+ * `maxDistance` to 10 points. The distance default is Impulse's, not RNGH's,
+ * and matches `useTap` so the two agree about what counts as a tap on one
+ * view. The device sweep found that `maxDelay` works at 500ms and at 250ms.
+ * It did not test `maxDuration` or `maxDistance`, and it measured no feel.
+ *
+ * **Web.** RNGH's web implementation recognizes tap from pointer events, so a
+ * double click behaves as a double tap. The browser's own double-click
+ * handling — text selection, zoom — is not suppressed by this hook, and
+ * `pointers` above 1 is unreliable there because a mouse reports one pointer
+ * and touch emulation varies by browser.
+ *
+ * **Accessibility.** A double tap is invisible to a screen reader and
+ * unreachable from a keyboard, and it is worse than a single tap on both
+ * counts: VoiceOver and TalkBack both consume a double tap as their own
+ * activation gesture, so a screen-reader user cannot reach this at all.
+ * Whatever it does must be reachable another way — an explicit control, or
+ * `accessibilityActions` with `onAccessibilityAction` on the view the gesture
+ * is attached to. A double-tap-only affordance is a bug, not a trade-off.
+ *
+ * @param options - Activation criteria, callbacks, and the `alongside` /
+ *   `blocks` / `deferTo` coexistence options every Impulse hook accepts.
+ */
+declare function useDoubleTap(options?: UseDoubleTapOptions): UseDoubleTapResult;
+
+export { TapEvent, type UseDoubleTapOptions, type UseDoubleTapResult, useDoubleTap };

package/dist/double-tap/index.js

@@ -0,0 +1,5 @@
+export { useDoubleTap } from '../chunk-BNSFDNLA.js';
+import '../chunk-VEPUHGPN.js';
+import '../chunk-2UZTAWUQ.js';
+import '../chunk-NYDDZD4G.js';
+import '../chunk-ZX7WNICB.js';

package/dist/drag/index.d.ts

@@ -1,7 +1,7 @@
 import { PanGesture } from 'react-native-gesture-handler';
 import { SharedValue } from 'react-native-reanimated';
-import { G as GestureMemoOptions } from '../useGestureMemo-Ccv8rB0C.js';
-import { P as Point, H as HitSlop, I as IntentResult } from '../types-Ch2HM3aP.js';
+import { G as GestureMemoOptions } from '../useGestureMemo-BRW1EKcJ.js';
+import { P as Point, H as HitSlop, I as IntentEndInfo, c as IntentResult } from '../types-ChGKY28a.js';
 import 'react';
 
 /** Which way the drag is allowed to move. */
@@ -147,7 +147,7 @@ interface UseDragOptions extends GestureMemoOptions {
     enabled?: boolean;
     /**
      * The drag passed `threshold` and now owns the touch. **Runs on the JS
-     * thread** — Impulse owns the `runOnJS` boundary, so this is an ordinary
+     * thread** — Impulse owns the `scheduleOnRN` boundary, so this is an ordinary
      * function and may touch React state.
      *
      * This is the first moment the drag has definitely won. `onBegin` fires
@@ -155,17 +155,21 @@ interface UseDragOptions extends GestureMemoOptions {
      */
     onDragStart?: (event: DragEvent) => void;
     /**
-     * The finger lifted and the drag is over. **Runs on the JS thread.**
+     * The drag is over. **Runs on the JS thread.**
      *
-     * Fires only for a drag that activated and then released. A drag the system
-     * took away — a competing gesture won, or the app went to the background —
-     * reaches `onFinalize` with `success: false` and never gets here, because
-     * there was no release and so no velocity worth seeding a spring with.
+     * Fires only for a drag that activated, so a touch that never passed the
+     * threshold never reaches here on either path.
      *
-     * Read `velocity` to seed that release animation, and `settled` for where
-     * an elastic overshoot should return to.
+     * It fires for both endings, and `cancelled` says which. `false` is the
+     * finger lifting, and `velocity` then seeds the release animation. `true`
+     * is the system taking the drag away — a competing gesture won, or the app
+     * went to the background. **There was no release on that path, so the
+     * velocity describes the last movement rather than a throw.** Return the
+     * view to `settled` instead of springing it.
+     *
+     * Read `settled` on both paths for where an elastic overshoot belongs.
      */
-    onDragEnd?: (event: DragEvent) => void;
+    onDragEnd?: (event: DragEvent, info: IntentEndInfo) => void;
     /**
      * The finger went down and the gesture is now a candidate. **This is a
      * worklet** — mark it with the `'worklet'` directive, and do not touch
@@ -180,7 +184,7 @@ interface UseDragOptions extends GestureMemoOptions {
      * The drag moved. **This is a worklet**, and it runs on every frame the
      * finger moves.
      *
-     * There is no JS-thread counterpart on purpose. A per-frame `runOnJS` is a
+     * There is no JS-thread counterpart on purpose. A per-frame `scheduleOnRN` is a
      * scheduling cost paid sixty times a second for a value that is already on
      * the thread that needs it — read `x` and `y` from a `useAnimatedStyle`
      * instead, and let this callback handle what the style cannot.
@@ -248,7 +252,8 @@ interface UseDragResult extends IntentResult<PanGesture> {
  * vertical `ScrollView` leaves the scroll alone until the finger commits
  * sideways; with `'both'` it is a radial distance. Set `failOffset` as well
  * when a mostly-diagonal move should go to the other gesture rather than to
- * this one. The default has not been measured on hardware yet.
+ * this one. The default works mechanically in the device sweep, and its feel
+ * is unmeasured.
  *
  * **Coexistence.** A threshold decides who moves first; it does not decide
  * who wins a contested touch. For a drag inside a scroll view, say which one

package/dist/drag/index.js

@@ -1,4 +1,4 @@
-export { useDrag } from '../chunk-FR242SUF.js';
-import '../chunk-5BMRKYVY.js';
-import '../chunk-F4RHM4ZK.js';
+export { useDrag } from '../chunk-TGOGIZDH.js';
+import '../chunk-2UZTAWUQ.js';
+import '../chunk-NYDDZD4G.js';
 import '../chunk-ZX7WNICB.js';

package/dist/index.d.ts

@@ -1,9 +1,16 @@
 export { GestureDetector } from 'react-native-gesture-handler';
 export { GestureCarrier, GestureMember, GesturesResult, UseGesturesOptions, useGestures } from './compose/index.js';
 export { RawGestureResult, UseRawGestureOptions, useRawGesture } from './raw/index.js';
-export { TapEvent, UseTapOptions, UseTapResult, useTap } from './tap/index.js';
+export { UseTapOptions, UseTapResult, useTap } from './tap/index.js';
+export { UseDoubleTapOptions, UseDoubleTapResult, useDoubleTap } from './double-tap/index.js';
+export { LongPressEvent, UseLongPressOptions, UseLongPressResult, useLongPress } from './long-press/index.js';
 export { DragAxis, DragBounds, DragEvent, UseDragOptions, UseDragResult, useDrag } from './drag/index.js';
-export { A as AttachableGesture, C as CoexistenceOptions, a as ComposeMode, G as GestureReference, b as GestureReferences, H as HitSlop, I as IntentResult, P as Point } from './types-Ch2HM3aP.js';
+export { PanAxis, PanEvent, UsePanOptions, UsePanResult, usePan } from './pan/index.js';
+export { CommittedSwipeEvent, SwipeDirection, SwipeEvent, UseSwipeOptions, UseSwipeResult, useSwipe } from './swipe/index.js';
+export { PinchEvent, UsePinchOptions, UsePinchResult, usePinch } from './pinch/index.js';
+export { RotateEvent, UseRotateOptions, UseRotateResult, useRotate } from './rotate/index.js';
+export { A as AttachableGesture, C as CoexistenceOptions, a as ComposeMode, G as GestureReference, b as GestureReferences, H as HitSlop, I as IntentEndInfo, c as IntentResult, P as Point } from './types-ChGKY28a.js';
+export { T as TapEvent } from './tapEvent-KSSojt_l.js';
 import 'react';
-import './useGestureMemo-Ccv8rB0C.js';
+import './useGestureMemo-BRW1EKcJ.js';
 import 'react-native-reanimated';

package/dist/index.js

@@ -1,8 +1,15 @@
+export { useSwipe } from './chunk-MWCIEVTA.js';
+export { usePinch } from './chunk-DXXGWG4Q.js';
+export { useRotate } from './chunk-YZHAQ4XK.js';
 export { useGestures } from './chunk-LM645QQT.js';
-export { useRawGesture } from './chunk-PMR25UCT.js';
-export { useTap } from './chunk-IG5RXCYR.js';
-export { useDrag } from './chunk-FR242SUF.js';
-import './chunk-5BMRKYVY.js';
-import './chunk-F4RHM4ZK.js';
+export { useRawGesture } from './chunk-HGBCIL6X.js';
+export { useTap } from './chunk-IH7SQ5X6.js';
+export { useDoubleTap } from './chunk-BNSFDNLA.js';
+import './chunk-VEPUHGPN.js';
+export { useLongPress } from './chunk-HI5PHDJY.js';
+export { useDrag } from './chunk-TGOGIZDH.js';
+export { usePan } from './chunk-PGOQSKEJ.js';
+import './chunk-2UZTAWUQ.js';
+import './chunk-NYDDZD4G.js';
 import './chunk-ZX7WNICB.js';
 export { GestureDetector } from 'react-native-gesture-handler';

package/dist/long-press/index.d.ts

@@ -0,0 +1,219 @@
+import { LongPressGesture } from 'react-native-gesture-handler';
+import { G as GestureMemoOptions } from '../useGestureMemo-BRW1EKcJ.js';
+import { P as Point, H as HitSlop, I as IntentEndInfo, c as IntentResult } from '../types-ChGKY28a.js';
+import 'react';
+import 'react-native-reanimated';
+
+/** The intent-shaped payload a {@link useLongPress} callback receives. */
+interface LongPressEvent {
+    /** X of the press, in points, relative to the view the gesture is attached to. */
+    readonly x: number;
+    /** Y of the press, in points, relative to the view the gesture is attached to. */
+    readonly y: number;
+    /**
+     * The same point relative to the window.
+     *
+     * Prefer it over `x` / `y` when the view itself is being transformed by the
+     * gesture — a press on a view that is mid-animation reports a moving `x`.
+     */
+    readonly absolute: Point;
+    /**
+     * How long the finger has been down, in milliseconds.
+     *
+     * At `onLongPress` this is roughly `minDuration`, because that is the
+     * moment the press was recognized. At `onLongPressEnd` it is the whole hold
+     * — which is the number a hold-to-record affordance wants, and the reason
+     * this field is in the payload rather than derived by the consumer from two
+     * timestamps.
+     */
+    readonly duration: number;
+    /** How many fingers are down. */
+    readonly pointers: number;
+}
+/** Options for {@link useLongPress}. */
+interface UseLongPressOptions extends GestureMemoOptions {
+    /**
+     * How long the finger must stay down before the press is recognized, in
+     * milliseconds. Default `500`.
+     *
+     * Lower it for an affordance the user is expected to discover; raise it for
+     * one that must not fire by accident. Below roughly 200ms it stops being
+     * distinguishable from a tap that was held a moment too long.
+     */
+    minDuration?: number;
+    /**
+     * How far the finger may travel, in points. Default `10`.
+     *
+     * **What this bounds is platform-dependent, and the split is verified.**
+     * RNGH documents it as bounding the wait only: "if the finger travels
+     * further than the defined distance and the handler hasn't yet activated,
+     * it will fail". Its web implementation does not match that — it checks the
+     * distance on every pointer move and *cancels* a press that is already
+     * active.
+     *
+     * So on web the finger may not travel past this once the press is
+     * recognized, and hold-then-drag needs this raised explicitly rather than
+     * relying on the documented behaviour. Native is unverified.
+     */
+    maxDistance?: number;
+    /**
+     * Exactly how many fingers must be down. Unset by default, which leaves
+     * RNGH's own behaviour in place.
+     *
+     * Setting it fixes the count exactly rather than setting a minimum.
+     */
+    pointers?: number;
+    /**
+     * Extra touchable area around the view, in points.
+     *
+     * Written inline as an object is fine — the gesture is not rebuilt when the
+     * contents are unchanged.
+     */
+    hitSlop?: HitSlop;
+    /**
+     * Whether the gesture is recognized at all. Default `true`.
+     *
+     * Prefer this over unmounting the `<GestureDetector>`: a disabled gesture
+     * keeps its identity and its relations, so re-enabling it does not
+     * re-attach anything.
+     */
+    enabled?: boolean;
+    /**
+     * The press was held long enough and is now recognized. **Runs on the JS
+     * thread** — Impulse owns the `scheduleOnRN` boundary, so this is an ordinary
+     * function and may touch React state.
+     *
+     * **The finger is still down when this fires.** That is the point: a
+     * context menu opens under a finger that has not lifted, which is what
+     * makes a long press feel like a long press rather than like a slow tap.
+     * Fire the haptic here.
+     */
+    onLongPress?: (event: LongPressEvent) => void;
+    /**
+     * A recognized press ended. **Runs on the JS thread.**
+     *
+     * Always preceded by `onLongPress`, because a touch that never became a
+     * long press never reaches here on either path.
+     *
+     * It fires for both endings, and `cancelled` says which. `false` is the
+     * finger lifting. `true` is the system taking the press away — a competing
+     * gesture won, the app went to the background, or the finger moved past
+     * `maxDistance` while still down. Read it before you treat the press as
+     * completed: a hold-to-record affordance stops the recording on both paths
+     * but keeps the take only on the first.
+     *
+     * `duration` carries the whole hold, which is what that affordance stops
+     * on.
+     */
+    onLongPressEnd?: (event: LongPressEvent, info: IntentEndInfo) => void;
+    /**
+     * The finger went down and the gesture is now a candidate. **This is a
+     * worklet** — mark it with the `'worklet'` directive, and do not touch
+     * React state from it.
+     *
+     * It fires on every touch, including the ordinary taps that will never
+     * become a long press. Use it to show a candidate state, and undo that
+     * state in `onFinalize`.
+     */
+    onBegin?: (event: LongPressEvent) => void;
+    /**
+     * The gesture is over, whether it was recognized or not. **This is a
+     * worklet.**
+     *
+     * `success` is `true` when the press was recognized and ended normally.
+     * This is the right place to clear anything `onBegin` set, because it runs
+     * on both paths.
+     */
+    onFinalize?: (event: LongPressEvent, success: boolean) => void;
+}
+/**
+ * What {@link useLongPress} returns.
+ *
+ * An alias rather than an extending interface, because a long press produces
+ * no continuous value of its own — the duration is in the payload, not in a
+ * shared value, because nothing on the UI thread can read a clock per frame
+ * without Impulse starting an animation to drive it.
+ */
+type UseLongPressResult = IntentResult<LongPressGesture>;
+/**
+ * Recognize a press held past a duration.
+ *
+ * ```tsx
+ * const hold = useLongPress({ minDuration: 400, onLongPress: openMenu })
+ *
+ * return (
+ *   <GestureDetector gesture={hold.gesture}>
+ *     <View />
+ *   </GestureDetector>
+ * )
+ * ```
+ *
+ * `onLongPress` runs on the JS thread and may set React state directly, and
+ * it fires **while the finger is still down** — that is the moment a context
+ * menu should open and a haptic should fire. `onLongPressEnd` runs on the JS
+ * thread too, when the finger lifts. `onBegin` and `onFinalize` are worklets
+ * and run on the UI thread — the name states the thread, so there is nothing
+ * to configure and no `scheduleOnRN` to write.
+ *
+ * `isActive` is a shared value that is `true` from the moment the press is
+ * recognized until the finger lifts — **not** from the moment the finger goes
+ * down. It is the held state, not a pressed state: every ordinary tap on the
+ * view would set a finger-down flag, and almost none of them are this
+ * gesture. Drive a pressed state from a `useTap` instead, and use this for
+ * whatever should show only while the press is genuinely being held.
+ *
+ * **Pairing with a tap.** A tap and a long press on one view race, and the
+ * race resolves itself: a tap that is held too long fails, and a press
+ * released too early never activates.
+ *
+ * ```tsx
+ * useGestures([useLongPress({ onLongPress: openMenu }), tap], { mode: 'race' })
+ * ```
+ *
+ * **Hold, then drag.** RNGH has no "activate after this one activates"
+ * relation, so this is two gestures and a gate rather than one option. Run
+ * them `alongside` each other and let the drag read a flag the press sets:
+ *
+ * ```tsx
+ * const hold = useLongPress({ alongside: dragRef })
+ * const drag = useDrag({
+ *   alongside: hold.ref,
+ *   onUpdate: () => {
+ *     'worklet'
+ *     // ignore the movement until the press has been held
+ *   },
+ * })
+ * ```
+ *
+ * `hold.isActive` is the flag, and it is a shared value precisely so the
+ * drag's worklets can read it without a round trip to the JS thread. Raise
+ * the drag's `threshold` as well, or the drag activates before the press ever
+ * does — and raise this hook's `maxDistance`, or the press is cancelled by
+ * the drag's own movement on web.
+ *
+ * **Activation criteria.** `minDuration` defaults to 500ms and `maxDistance`
+ * to 10 points, and both are RNGH's own numbers restated. What `maxDistance`
+ * bounds differs by platform: RNGH documents it as bounding the wait only,
+ * but its web implementation cancels a press that is already active once the
+ * finger travels past it. Raise it explicitly rather than relying on travel
+ * being free after recognition.
+ *
+ * **Web.** RNGH recognizes long press from pointer events, so a held mouse
+ * button works. The browser's own context menu is not suppressed by this
+ * hook, so a long press with the right button — or a held touch on some
+ * browsers — can open both. Suppress it on the view if that matters.
+ *
+ * **Accessibility.** A long press is invisible to a screen reader and
+ * unreachable from a keyboard, and this hook does not fix that. It has the
+ * best fallback of any gesture in the library, so use it: React Native's
+ * `<Pressable>` takes `onLongPress` directly and is reachable by every
+ * assistive technology, and `accessibilityActions` with
+ * `onAccessibilityAction` names the same action explicitly. A long-press-only
+ * affordance is a bug, not a trade-off.
+ *
+ * @param options - Activation criteria, callbacks, and the `alongside` /
+ *   `blocks` / `deferTo` coexistence options every Impulse hook accepts.
+ */
+declare function useLongPress(options?: UseLongPressOptions): UseLongPressResult;
+
+export { type LongPressEvent, type UseLongPressOptions, type UseLongPressResult, useLongPress };