@rootnative/impulse 0.0.0-alpha.0

package/src/intents/useTap.ts

@@ -0,0 +1,285 @@
+import { useMemo } from 'react'
+import {
+  Gesture,
+  type GestureStateChangeEvent,
+  type TapGesture,
+  type TapGestureHandlerEventPayload,
+} from 'react-native-gesture-handler'
+import { runOnJS, useSharedValue } from 'react-native-reanimated'
+import {
+  useGestureMemo,
+  type GestureMemoOptions,
+} from '../internal/useGestureMemo'
+import { useLatestCallback } from '../internal/useLatestCallback'
+import { useStableRecord } from '../internal/useStableRecord'
+import { type HitSlop, type IntentResult, type Point } from '../types'
+
+/**
+ * Maximum time the finger may stay down and still count as a tap, in
+ * milliseconds.
+ *
+ * This is RNGH's own default, restated rather than inherited so the value is
+ * visible at the call site's documentation and cannot move underneath Impulse
+ * in an RNGH release.
+ */
+const DEFAULT_MAX_DURATION = 500
+
+/**
+ * Maximum distance the finger may travel and still count as a tap, in points.
+ *
+ * Set explicitly, and this one is **not** RNGH's default: RNGH leaves the
+ * slop to the platform, so the same tap is accepted on one operating system
+ * and rejected on the other. A fixed number is the behaviour a consumer can
+ * reason about. 10 points is roughly a finger's own jitter while pressing.
+ *
+ * **This number is a design intention, not a measurement.** No hardware pass
+ * has happened. See Known gaps in CLAUDE.md.
+ */
+const DEFAULT_MAX_DISTANCE = 10
+
+/** The intent-shaped payload a {@link useTap} callback receives. */
+export interface TapEvent {
+  /** X of the tap, in points, relative to the view the gesture is attached to. */
+  readonly x: number
+  /** Y of the tap, 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 tap on a view that is mid-animation reports a moving `x`.
+   */
+  readonly absolute: Point
+  /** How many fingers were down when the tap was recognized. */
+  readonly pointers: number
+}
+
+/** Options for {@link useTap}. */
+export interface UseTapOptions extends GestureMemoOptions {
+  /**
+   * How many fingers must be down. Default `1`.
+   *
+   * A two-finger tap is a common "undo" or "zoom out" affordance, and it is
+   * the same intent with a different pointer count rather than a separate
+   * one.
+   */
+  pointers?: number
+  /**
+   * How long the finger may stay down, in milliseconds. Default `500`.
+   *
+   * Past this the gesture fails rather than firing, which is what leaves the
+   * touch available to a `useLongPress` racing against it.
+   */
+  maxDuration?: number
+  /**
+   * How far the finger may travel, in points. Default `10`.
+   *
+   * Raising it makes the tap more forgiving and makes it harder for a drag in
+   * the same view to win the touch.
+   */
+  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 tap happened. **Runs on the JS thread** — Impulse owns the
+   * `runOnJS` boundary, so this is an ordinary function and may touch React
+   * state.
+   *
+   * It fires only for a successful tap. A touch that moved too far or stayed
+   * down too long reaches `onFinalize` with `success: false` instead.
+   */
+  onTap?: (event: TapEvent) => 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.
+   *
+   * Being a candidate is not the same as winning: in a race with a
+   * long press or a drag, this fires and the gesture may still fail. Use it
+   * to show a pressed state, and undo that state in `onFinalize`.
+   */
+  onBegin?: (event: TapEvent) => void
+  /**
+   * The gesture is over, whether it was recognized or not. **This is a
+   * worklet.**
+   *
+   * `success` is `true` when the 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 useTap} returns.
+ *
+ * An alias rather than an extending interface, because a tap produces no
+ * continuous value of its own: the gesture, the ref, and `isActive` are the
+ * whole result. An intent that does produce one — a drag's `x`, a pinch's
+ * `scale` — extends {@link IntentResult} instead.
+ */
+export type UseTapResult = IntentResult<TapGesture>
+
+/**
+ * Shape RNGH's flat state-change event into the tap payload.
+ *
+ * A worklet, because every caller is one. Keeping the normalizer out of the
+ * gesture callbacks means the four call sites cannot disagree about which
+ * RNGH field means what — which is the defect the intent payload exists to
+ * remove.
+ */
+function toTapEvent(
+  event: GestureStateChangeEvent<TapGestureHandlerEventPayload>,
+): TapEvent {
+  'worklet'
+  return {
+    x: event.x,
+    y: event.y,
+    absolute: { x: event.absoluteX, y: event.absoluteY },
+    pointers: event.numberOfPointers,
+  }
+}
+
+/**
+ * Recognize a single tap.
+ *
+ * ```tsx
+ * const tap = useTap({ onTap: () => select(item.id) })
+ *
+ * return (
+ *   <GestureDetector gesture={tap.gesture}>
+ *     <View />
+ *   </GestureDetector>
+ * )
+ * ```
+ *
+ * `onTap` 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 `runOnJS` to write.
+ *
+ * `isActive` is a shared value that is `true` while the finger is down. Drive
+ * a pressed state from it without a re-render:
+ *
+ * ```tsx
+ * const tap = useTap({ onTap: select })
+ * const style = useAnimatedStyle(() => ({ opacity: tap.isActive.value ? 0.6 : 1 }))
+ * ```
+ *
+ * **Activation criteria.** `maxDuration` defaults to 500ms and `maxDistance`
+ * to 10 points. The distance default is Impulse's, not RNGH's: RNGH defers to
+ * the platform there, so the same tap is accepted on one operating system and
+ * rejected on the other. Neither default has been measured on hardware yet.
+ *
+ * **Racing a double tap.** A single tap and a double tap on one view is a
+ * composition, not an option — `useGestures([tap, double], { mode: 'race' })`.
+ * Do not reach for `maxDelay` to build it by hand.
+ *
+ * **Web.** RNGH's web implementation recognizes tap from pointer events, and
+ * `pointers` above 1 is unreliable there because a mouse reports one pointer
+ * and touch emulation varies by browser. A single-finger tap behaves the same
+ * as on native.
+ *
+ * **Accessibility.** A tap gesture is invisible to a screen reader and
+ * unreachable from a keyboard. This hook does not fix that, and it cannot.
+ * Whatever the tap does must also be reachable another way: put the same
+ * action on a `<Pressable>`, or declare it with `accessibilityActions` and
+ * `onAccessibilityAction` on the view the gesture is attached to. A 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.
+ */
+export function useTap(options: UseTapOptions = {}): UseTapResult {
+  const {
+    pointers = 1,
+    maxDuration = DEFAULT_MAX_DURATION,
+    maxDistance = DEFAULT_MAX_DISTANCE,
+    enabled,
+    onTap,
+    onBegin,
+    onFinalize,
+  } = options
+
+  const isActive = useSharedValue(false)
+  // `hitSlop` is the one option a consumer writes as an object literal, so it
+  // is the one that would rebuild the gesture every render if taken as-is.
+  const hitSlop = useStableRecord(options.hitSlop)
+  // JS-thread callback: reached through a stable identity so it is never a
+  // gesture dependency. The worklet callbacks below stay direct dependencies,
+  // because a worklet is captured as written.
+  const handleTap = useLatestCallback(onTap)
+  // Attaching a handler is not the same as calling it: RNGH decides which
+  // thread a gesture's callbacks run on by inspecting the ones it was given,
+  // so the gesture does have to change when `onTap` appears or disappears.
+  // This is a boolean, so it changes only when that is actually true.
+  const hasTapHandler = onTap !== undefined
+
+  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)
+        })
+
+      // Applied conditionally rather than with a default, so an option the
+      // consumer did not set leaves RNGH's own default in place instead of
+      // Impulse overwriting it with a guess.
+      if (hitSlop !== undefined) {
+        tap.hitSlop(hitSlop)
+      }
+      if (enabled !== undefined) {
+        tap.enabled(enabled)
+      }
+      return tap
+    },
+    [
+      pointers,
+      maxDuration,
+      maxDistance,
+      hitSlop,
+      enabled,
+      hasTapHandler,
+      handleTap,
+      isActive,
+      onBegin,
+      onFinalize,
+    ],
+    options,
+  )
+
+  // Memoised for the same reason `useGestureMemo` memoises its own result: a
+  // consumer may put the whole hook result in a dependency list, and a fresh
+  // object every render would make that dependency useless. `isActive` is
+  // stable for the life of the hook, so `built` is the only real input.
+  return useMemo(() => ({ ...built, isActive }), [built, isActive])
+}

package/src/internal/useGestureMemo.ts

@@ -0,0 +1,110 @@
+import { useMemo, useRef, type DependencyList, type RefObject } from 'react'
+import { type GestureType } from 'react-native-gesture-handler'
+import { applyRelations } from '../relations'
+import { type CoexistenceOptions } from '../types'
+import { useStableList } from './useStableList'
+
+/** What every hook built on this helper accepts on top of its own options. */
+export interface GestureMemoOptions extends CoexistenceOptions {
+  /**
+   * A test id for RNGH's `getByGestureTestId`, forwarded to `withTestId`.
+   *
+   * Impulse's own tests mostly inspect the gesture object directly, which is
+   * more precise. This is here for consumers driving their gestures through
+   * `fireGestureHandler`, which needs a way to find them.
+   */
+  testId?: string
+}
+
+/** The two members every Impulse gesture hook returns, whatever else it adds. */
+export interface BuiltGesture<G extends GestureType> {
+  /** The configured gesture. Hand it to `<GestureDetector>`. */
+  readonly gesture: G
+  /**
+   * A handle on this gesture for another hook's `alongside` / `blocks` /
+   * `deferTo`.
+   *
+   * Passing `other.gesture` to a relation also works — RNGH accepts a gesture
+   * object — but it captures *that* object, and a gesture is replaced when
+   * its own dependencies change. The ref is created once and never replaced,
+   * and RNGH reads it when it resolves relations rather than when the
+   * relation is declared, so a relation written against `other.ref` keeps
+   * pointing at the live gesture. Prefer it.
+   *
+   * The ref is populated when `<GestureDetector>` mounts the gesture, not
+   * when the hook runs. Reading `.current` during render gives `undefined`
+   * on the first pass.
+   */
+  readonly ref: RefObject<GestureType | undefined>
+}
+
+/**
+ * Build a gesture once, configure it, and keep it until its dependencies
+ * actually change.
+ *
+ * Every Impulse hook goes through here rather than hand-rolling `useMemo`
+ * plus relation wiring. Two reasons, both about defects that are invisible
+ * at the call site:
+ *
+ * 1. **Gesture identity is a correctness property, not an optimization.** A
+ *    gesture whose shape changed is re-attached by `<GestureDetector>`, and
+ *    a re-attach in the middle of a drag drops the drag. Concentrating the
+ *    memoisation here means a new hook cannot forget it.
+ * 2. **Relations must be applied exactly once per gesture object.** RNGH's
+ *    relation methods append to the gesture's config, so a second call adds
+ *    the same reference again. Applying them inside the same `useMemo` that
+ *    builds the gesture ties "applied once" to "built once".
+ *
+ * @param hookName - The public hook this is building for, used in dev
+ *   warnings so the message names something the consumer wrote.
+ * @param build - Constructs the bare gesture. Called only when `deps` change.
+ *   Do not apply relations here; this helper owns them.
+ * @param deps - What the built gesture depends on. Worklet callbacks belong
+ *   here, because a worklet is captured as written. JS-thread callbacks do
+ *   not — route those through `useLatestCallback` first.
+ * @param options - Coexistence options and `testId`.
+ */
+export function useGestureMemo<G extends GestureType>(
+  hookName: string,
+  build: () => G,
+  deps: DependencyList,
+  options?: GestureMemoOptions,
+): BuiltGesture<G> {
+  const alongside = useStableList(options?.alongside)
+  const blocks = useStableList(options?.blocks)
+  const deferTo = useStableList(options?.deferTo)
+  const testId = options?.testId
+  const ref = useRef<GestureType | undefined>(undefined)
+
+  const gesture = useMemo(
+    () => {
+      const built = build()
+      // `built` stays typed as `G` so the caller keeps its concrete gesture
+      // type; the configuration below only needs the base surface, and
+      // calling these through the narrowed type avoids resolving a method on
+      // a union of `this`-returning signatures.
+      const base: GestureType = built
+      base.withRef(ref)
+      if (testId !== undefined) {
+        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],
+  )
+
+  // The result object is memoised too, so a consumer can put the whole hook
+  // result in a dependency list — `useGestures` does exactly that with its
+  // members.
+  return useMemo(() => ({ gesture, ref }), [gesture])
+}

package/src/internal/useLatestCallback.ts

@@ -0,0 +1,64 @@
+import { useCallback, useInsertionEffect, useRef } from 'react'
+
+/**
+ * Give a JS-thread callback a stable identity that never changes, while
+ * always calling the newest version passed in.
+ *
+ * This is the mechanism behind Impulse's "stable by construction" guarantee.
+ * A gesture object must not be rebuilt during a render, because
+ * `<GestureDetector>` re-attaches a gesture whose shape changed — and a
+ * re-attach mid-drag drops the drag. An inline callback is enough to trigger
+ * that:
+ *
+ * ```tsx
+ * // Without this hook, `onTap` is a new function every render, so the
+ * // gesture's `useMemo` invalidates every render, so the gesture re-attaches
+ * // every render.
+ * useTap({ onTap: () => select(item.id) })
+ * ```
+ *
+ * Routing the callback through here makes the gesture independent of it: the
+ * identity the gesture captures is created once and never replaced, and the
+ * body it forwards to is swapped underneath. `@rootnative/inertia` shipped
+ * this exact defect in `-gestures` and fixed it in `0.0.10`; here it is the
+ * architecture rather than a fix, and a test pins gesture identity across an
+ * inline-callback re-render.
+ *
+ * **This is for JS-thread callbacks only.** A worklet must stay a direct
+ * dependency of the gesture's `useMemo`, because a worklet is captured as
+ * written: swapping its body through a ref would leave the UI thread running
+ * the version it was serialized with, silently. That asymmetry is why
+ * Impulse splits callbacks by name — `onBegin` / `onUpdate` / `onEnd` are
+ * worklets, `onTap` / `onSwipe` / `onLongPress` are not.
+ *
+ * The returned function is stable, so it is never a useful dependency. A
+ * caller that needs the gesture to change when the callback *appears or
+ * disappears* — attaching a handler is not the same as calling it — should
+ * put `options.onTap !== undefined` in its dependency list, which is a
+ * boolean and changes only when that is actually true.
+ *
+ * @param callback - The callback to forward to, or `undefined` when the
+ *   consumer passed none.
+ * @returns A function whose identity never changes. Calling it invokes the
+ *   callback from the most recent commit, or does nothing and returns
+ *   `undefined` when there is none.
+ */
+export function useLatestCallback<Args extends readonly unknown[], Result>(
+  callback: ((...args: Args) => Result) | undefined,
+): (...args: Args) => Result | undefined {
+  const latest = useRef(callback)
+
+  // `useInsertionEffect` rather than an assignment during render or a layout
+  // effect. Assigning during render publishes a callback from a render React
+  // may abandon, which under a concurrent re-render means a gesture calling a
+  // version of the callback that never committed. This effect runs at commit,
+  // before every layout effect, so the swap is complete before anything the
+  // consumer could have wired up can fire — and a gesture cannot fire earlier
+  // than that, because it is driven by native touches on a mounted view.
+  useInsertionEffect(() => {
+    latest.current = callback
+  })
+
+  // Empty dependency list on purpose: this identity is the whole point.
+  return useCallback((...args: Args) => latest.current?.(...args), [])
+}

package/src/internal/useStableList.ts

@@ -0,0 +1,62 @@
+import { useRef } from 'react'
+
+const EMPTY: readonly never[] = []
+
+/** Element-wise identity comparison. `Object.is` so `NaN` is not a surprise. */
+function sameContents<T>(a: readonly T[], b: readonly T[]): boolean {
+  if (a === b) {
+    return true
+  }
+  if (a.length !== b.length) {
+    return false
+  }
+  for (let index = 0; index < a.length; index += 1) {
+    if (!Object.is(a[index], b[index])) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * Normalize "one value or several" to an array whose identity changes only
+ * when its contents do.
+ *
+ * Every coexistence option takes a reference or an array of them, and the
+ * array is almost always written inline:
+ *
+ * ```tsx
+ * useDrag({ axis: 'y', deferTo: [scrollRef, pagerRef] })
+ * ```
+ *
+ * That literal is a new array on every render. Used directly as a gesture
+ * dependency it would rebuild the gesture every render — the exact defect
+ * `useLatestCallback` exists to prevent for callbacks. Comparing the contents
+ * instead makes the dependency track what the consumer meant rather than how
+ * they spelled it.
+ *
+ * The cache is a ref written during render. That is safe here because the
+ * value is derived purely from the argument: a render React abandons can
+ * leave a stale list in the ref, and the next render compares against it by
+ * content and reaches the same answer either way.
+ *
+ * @param value - One item, several, or nothing.
+ * @returns The items as an array. The same array instance is returned on
+ *   every subsequent render whose contents match element for element.
+ */
+export function useStableList<T>(
+  value: T | readonly T[] | undefined,
+): readonly T[] {
+  const next: readonly T[] =
+    value === undefined
+      ? EMPTY
+      : Array.isArray(value)
+        ? (value as readonly T[])
+        : [value as T]
+
+  const held = useRef<readonly T[]>(EMPTY)
+  if (!sameContents(held.current, next)) {
+    held.current = next
+  }
+  return held.current
+}

package/src/internal/useStableRecord.ts

@@ -0,0 +1,72 @@
+import { useRef } from 'react'
+
+/**
+ * Shallow comparison for a plain options object. `Object.is` so `NaN` is not
+ * a surprise, and so a value swapped for an identical primitive compares
+ * equal.
+ */
+function sameEntries(a: unknown, b: unknown): boolean {
+  if (Object.is(a, b)) {
+    return true
+  }
+  if (
+    typeof a !== 'object' ||
+    typeof b !== 'object' ||
+    a === null ||
+    b === null
+  ) {
+    return false
+  }
+  const left = a as Record<string, unknown>
+  const right = b as Record<string, unknown>
+  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
+}
+
+/**
+ * Hold an options object's identity steady while its contents are unchanged.
+ *
+ * The array counterpart of {@link useStableList}, for the options that are
+ * records rather than lists — `hitSlop` is the first, and every activation
+ * criterion shaped like it will be the next. The problem is identical: the
+ * value is written inline at the call site,
+ *
+ * ```tsx
+ * useTap({ hitSlop: { horizontal: 12 }, onTap: select })
+ * ```
+ *
+ * so it is a new object on every render. Used directly as a gesture
+ * dependency it rebuilds the gesture every render, `<GestureDetector>`
+ * re-attaches it, and a re-attach mid-press drops the press. Comparing the
+ * contents makes the dependency track what the consumer meant rather than how
+ * they spelled it.
+ *
+ * A shallow comparison is enough because every option this is used for is one
+ * level deep. It is not a general deep-equal, and it must not become one: a
+ * deep walk on every render of every gesture is a cost paid on the render path
+ * to save a cost paid only when a gesture is rebuilt.
+ *
+ * The cache is a ref written during render, which is safe for the same reason
+ * it is in `useStableList`: the value is derived purely from the argument, so
+ * a render React abandons leaves a stale entry that the next render compares
+ * against by content and reaches the same answer either way.
+ *
+ * @param value - The options object, a primitive, or nothing.
+ * @returns The same instance on every render whose contents match key for
+ *   key.
+ */
+export function useStableRecord<T>(value: T): T {
+  const held = useRef<T>(value)
+  if (!sameEntries(held.current, value)) {
+    held.current = value
+  }
+  return held.current
+}

package/src/internal/warnOnce.ts

@@ -0,0 +1,60 @@
+/**
+ * Dev-only warnings, emitted at most once per key.
+ *
+ * A gesture that misbehaves gives the consumer almost nothing to go on — the
+ * failure is "nothing happened", on a device, with no stack. Impulse's answer
+ * is to say the specific thing that is wrong at the moment it can still be
+ * detected. The warning has to be cheap enough to leave in every hook, hence
+ * the key: a hook that re-renders sixty times a second must not print sixty
+ * times a second.
+ *
+ * The key is the deduplication unit, so it names the *condition*, not the
+ * call site. Two components making the same mistake warn once between them —
+ * deliberately: the message names the fix, and repeating it per instance
+ * buries it.
+ */
+
+// `__DEV__` is defined by Metro on every platform that can run RNGH, and both
+// RNGH and Reanimated read it bare. It is not a language global though, so a
+// bundler that does not define it would throw a `ReferenceError` on a bare
+// read; `typeof` is safe against that. The declaration lives here because the
+// package's tsconfig sets `types: []`, so no ambient React Native types are
+// in scope.
+declare const __DEV__: boolean
+
+const warned = new Set<string>()
+
+/**
+ * Whether this is a development build. `false` when `__DEV__` is undefined,
+ * so a bundler that does not define it gets silence rather than a crash.
+ */
+export function isDevBuild(): boolean {
+  return typeof __DEV__ !== 'undefined' && __DEV__
+}
+
+/**
+ * Warn once for `key`, in development builds only.
+ *
+ * @param key - The condition being reported. Reused keys warn once in total.
+ * @param message - What is wrong and what to do about it. Write the fix into
+ *   the message; a warning the reader has to interpret is a warning they
+ *   ignore.
+ */
+export function warnOnce(key: string, message: string): void {
+  if (!isDevBuild() || warned.has(key)) {
+    return
+  }
+  warned.add(key)
+  console.warn(`[impulse] ${message}`)
+}
+
+/**
+ * Forget every key already warned about.
+ *
+ * For tests only. Deduplication is process-wide, so without this the second
+ * test asserting a given warning would see nothing and pass for the wrong
+ * reason.
+ */
+export function resetWarnings(): void {
+  warned.clear()
+}

package/src/raw/index.ts

@@ -0,0 +1,2 @@
+export { useRawGesture } from './useRawGesture'
+export type { RawGestureResult, UseRawGestureOptions } from './useRawGesture'