@rootnative/impulse 0.0.0-alpha.0

package/dist/types-Ch2HM3aP.d.ts

@@ -0,0 +1,142 @@
+import { RefObject, ComponentType } from 'react';
+import { GestureType, ComposedGesture } from 'react-native-gesture-handler';
+import { SharedValue } from 'react-native-reanimated';
+
+/**
+ * A gesture that an Impulse gesture can be placed in a relation with.
+ *
+ * The value is either a ref returned by another Impulse hook (`drag.ref`), a
+ * ref on a component that owns a gesture — a `ScrollView`, say — or a raw
+ * RNGH gesture object.
+ *
+ * RNGH models this as `GestureRef` and does **not** export it, so the union
+ * is written out here. It is RNGH's own minus the numeric form: RNGH accepts
+ * a handler tag as a number for its legacy API, and the three relation
+ * methods reject it. `AssertRelationArgument` below is what catches an
+ * upstream change to the shape.
+ */
+type GestureReference = GestureType | RefObject<GestureType | undefined> | RefObject<ComponentType | undefined | null>;
+/**
+ * A gesture that can be handed to `<GestureDetector>`: a single recognizer,
+ * or a composition of them.
+ *
+ * RNGH spells this inline in `GestureDetector`'s props and exports no name
+ * for it, so Impulse names it — every hook result's `gesture` has this type,
+ * and so does every member `useGestures` accepts.
+ */
+type AttachableGesture = GestureType | ComposedGesture;
+/**
+ * Extra touchable area around a view, in points. A number widens every edge;
+ * an object widens the edges it names.
+ *
+ * Derived from RNGH's own method signature rather than copied, for the same
+ * reason `GestureReference` is: RNGH does not export the type from its package
+ * entry, and a hand-written copy is one that absorbs an upstream change
+ * without a word.
+ */
+type HitSlop = Parameters<GestureType['hitSlop']>[0];
+/** One reference, or several. Every coexistence option accepts both. */
+type GestureReferences = GestureReference | GestureReference[];
+/**
+ * How an Impulse gesture coexists with a gesture it does not own — most often
+ * a scroll view it lives inside.
+ *
+ * RNGH exposes this as three methods whose names describe the mechanism
+ * (`simultaneousWithExternalGesture`, `blocksExternalGesture`,
+ * `requireExternalGestureToFail`) and give no hint about which one a given
+ * case wants. These three name the outcome instead. Each maps to exactly one
+ * RNGH relation, and they are not interchangeable — picking the wrong one is
+ * the single thing consumers get wrong most often.
+ *
+ * All three may be set at once. They are independent relations, not a choice
+ * of one.
+ */
+interface CoexistenceOptions {
+    /**
+     * Both gestures recognize at the same time. Neither waits for the other.
+     * Maps to `simultaneousWithExternalGesture`.
+     *
+     * Use it when the two gestures read different things from the same touch —
+     * a pinch and a pan on one image, say.
+     */
+    alongside?: GestureReferences;
+    /**
+     * This gesture wins. The named gesture cannot activate until this one has
+     * failed. Maps to `blocksExternalGesture`.
+     *
+     * Use it when this gesture is the foreground affordance — a bottom sheet
+     * that must take the drag before the list behind it does.
+     */
+    blocks?: GestureReferences;
+    /**
+     * The named gesture wins. This one activates only after that one fails.
+     * Maps to `requireExternalGestureToFail`.
+     *
+     * Use it when this gesture is the fallback — a horizontal drag that should
+     * start only once the vertical scroll has declined the touch.
+     */
+    deferTo?: GestureReferences;
+}
+/**
+ * How the members of a `useGestures` composition relate to one another.
+ *
+ * - `race` — the first to activate wins, and the rest are cancelled.
+ * - `simultaneous` — every member recognizes independently.
+ * - `exclusive` — members are tried in order, and a later one activates only
+ *   after every earlier one has failed.
+ *
+ * Composition is a flat call carrying this mode rather than a nested builder
+ * chain, so precedence reads left to right instead of inside out.
+ */
+type ComposeMode = 'race' | 'simultaneous' | 'exclusive';
+/**
+ * A point in a gesture payload, in points.
+ *
+ * Grouped rather than spelled as two flat fields, because every payload that
+ * carries more than one point — a drag's position and its origin, a pinch's
+ * focal point — would otherwise need a prefix per pair and the consumer would
+ * pick between `absoluteX` and `focalX` from memory. That flat union is
+ * exactly what the intent payloads exist to replace.
+ */
+interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * What every intent hook returns: the gesture, a handle other hooks can name
+ * in their coexistence options, and whether the gesture is being recognized
+ * right now.
+ *
+ * Each hook extends this with the shared values its own intent produces —
+ * `drag.x`, `pinch.scale`, `rotate.angle`. The three members here are the
+ * part that is the same whatever the intent.
+ */
+interface IntentResult<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`.
+     *
+     * Prefer it over passing `other.gesture`: a gesture object is replaced when
+     * its dependencies change, and this ref is created once and read by RNGH at
+     * the moment it resolves relations, so a relation written against it keeps
+     * pointing at the live gesture.
+     *
+     * It is populated when `<GestureDetector>` mounts the gesture, not when the
+     * hook runs, so reading `.current` during the first render gives
+     * `undefined`.
+     */
+    readonly ref: RefObject<GestureType | undefined>;
+    /**
+     * `true` while the gesture is active — for a tap, while the finger is down;
+     * for a drag, while it is being dragged.
+     *
+     * A shared value, so a pressed or grabbed state can be driven on the UI
+     * thread through `useAnimatedStyle` without a re-render. Reading `.value`
+     * during render works but tells you only what was true at the last commit.
+     */
+    readonly isActive: SharedValue<boolean>;
+}
+
+export type { AttachableGesture as A, CoexistenceOptions as C, GestureReference as G, HitSlop as H, IntentResult as I, Point as P, ComposeMode as a, GestureReferences as b };

package/dist/useGestureMemo-Ccv8rB0C.d.ts

@@ -0,0 +1,38 @@
+import { RefObject } from 'react';
+import { GestureType } from 'react-native-gesture-handler';
+import { C as CoexistenceOptions } from './types-Ch2HM3aP.js';
+
+/** What every hook built on this helper accepts on top of its own options. */
+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. */
+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>;
+}
+
+export type { BuiltGesture as B, GestureMemoOptions as G };

package/jest-preset.cjs

@@ -0,0 +1,60 @@
+// Jest preset for projects consuming `@rootnative/impulse`.
+//
+// Layered on top of `@react-native/jest-preset`. It adds:
+//   - the RNGH native-module mocks Impulse's own tests run against, through
+//     `jest-setup.cjs`
+//   - `transformIgnorePatterns` widened so Jest transforms the published
+//     bundle of `@rootnative/impulse` (ESM-only, see tsup.config.ts) and
+//     `react-native-gesture-handler`, neither of which the default
+//     `react-native` pattern lets through
+//
+// Usage:
+//
+//   // jest.config.js
+//   module.exports = {
+//     preset: require.resolve('@rootnative/impulse/jest-preset'),
+//   }
+//
+// To allowlist more packages for transformation, extend
+// `transformIgnorePatterns` in your own config — Jest merges over the preset.
+
+// `@react-native/jest-preset` is deliberately **not** a peer dependency of
+// `@rootnative/impulse`. React Native pins it to an exact version (RN 0.86.3
+// requires exactly `@react-native/jest-preset@0.86.3`), so any range declared
+// here would advertise versions that cannot install, and an exact pin would
+// break on every RN patch. The version relationship belongs to
+// `react-native`, which already declares it.
+//
+// Resolve the package directly rather than through the
+// `react-native/jest-preset` shim. RN 0.86 moved the preset into its own
+// package and left the old path as a shim that re-exports it — but it
+// declares the new package as an **optional** peer, and no package manager
+// installs an optional peer. On RN 0.86 the shim therefore throws a migration
+// error for any consumer who has not installed it by hand. Requiring it here
+// means the failure names this package's requirement instead.
+let rnPreset
+try {
+  rnPreset = require('@react-native/jest-preset')
+} catch (error) {
+  if (error.code === 'MODULE_NOT_FOUND') {
+    throw new Error(
+      '[impulse] `@rootnative/impulse/jest-preset` needs `@react-native/jest-preset`.\n' +
+        'React Native 0.86 moved its Jest preset into that package and declares\n' +
+        'it as an optional peer, so it is not installed for you. Add it as a\n' +
+        'devDependency at the version that matches your react-native:\n\n' +
+        '  npm install --save-dev @react-native/jest-preset\n',
+    )
+  }
+  throw error
+}
+
+module.exports = {
+  ...rnPreset,
+  setupFiles: [
+    ...(rnPreset.setupFiles ?? []),
+    require.resolve('./jest-setup.cjs'),
+  ],
+  transformIgnorePatterns: [
+    'node_modules/(?!(react-native|@react-native|@react-native-community|@rootnative/impulse|react-native-gesture-handler|react-native-reanimated|react-native-worklets)/)',
+  ],
+}

package/jest-setup.cjs

@@ -0,0 +1,56 @@
+// Impulse's Jest setup. Loaded automatically by
+// `@rootnative/impulse/jest-preset`, or addable to a hand-rolled config
+// through `setupFiles`.
+//
+// The mock surface is deliberately thin. Impulse drives its tests with RNGH's
+// own `fireGestureHandler` / `getByGestureTestId`, which need RNGH's real
+// gesture objects and its own native-module mocks — not a hand-rolled
+// chainable builder. So this file delegates to the setup RNGH ships and adds
+// nothing that RNGH already covers.
+//
+// `react-native-gesture-handler/jestSetup` mocks:
+//   - `RNGestureHandlerModule`, the native module every gesture talks to
+//   - `GestureButtons` and `Pressable`, the components that need it
+// It leaves `Gesture.*` and `GestureDetector` real, which is what makes
+// `fireGestureHandler` able to drive a gesture through its state machine.
+require('react-native-gesture-handler/jestSetup')
+
+// Reanimated mock — the minimum Impulse's own surface touches, and no more.
+//
+// The stock `react-native-reanimated/mock` is not used, for the reason
+// Inertia hand-rolls its own: its `useSharedValue` returns a fresh object per
+// render. Every Impulse hook hands its `isActive` to a worklet captured in a
+// `useMemo`, so a shared value that loses identity means the gesture writes
+// to an object nobody reads, and `isActive` silently never updates. The test
+// in `useTap.test.tsx` pins that identity, so this mock cannot regress into
+// the stock behaviour unnoticed.
+//
+// Deliberately absent: `useAnimatedStyle`, the `Animated.*` components, and
+// the animation functions. Impulse renders none of them and starts no
+// animation — Principle 5, animation is Inertia's job. Add a member here when
+// a module in `src/` actually imports it, not before.
+//
+// What this means for tests:
+//   ✅ assert a shared value's `.value` after driving a gesture
+//   ✅ assert that a JS-thread callback fired, because `runOnJS` is identity
+//   ❌ frame-level timing is not observable — nothing schedules or animates
+jest.mock('react-native-reanimated', () => {
+  const React = require('react')
+
+  return {
+    __esModule: true,
+    useSharedValue: (initial) => {
+      const ref = React.useRef(null)
+      if (ref.current === null) {
+        ref.current = { value: initial }
+      }
+      return ref.current
+    },
+    runOnJS: (fn) => fn,
+    runOnUI: (fn) => fn,
+    isWorkletFunction: () => false,
+    // Needed by RNGH, not by Impulse. See the note above.
+    useEvent: (callback) => callback,
+    setGestureState: () => {},
+  }
+})

package/package.json

@@ -0,0 +1,115 @@
+{
+  "name": "@rootnative/impulse",
+  "version": "0.0.0-alpha.0",
+  "description": "Declarative gesture primitives for React Native, built on react-native-gesture-handler.",
+  "license": "MIT",
+  "author": "RootNative",
+  "homepage": "https://github.com/rootnative/impulse",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rootnative/impulse.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/rootnative/impulse/issues"
+  },
+  "keywords": [
+    "react-native",
+    "gesture-handler",
+    "gesture",
+    "swipe",
+    "drag",
+    "pinch",
+    "tap",
+    "expo",
+    "declarative"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "react-native": "./dist/index.js",
+  "source": "./src/index.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "react-native": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./compose": {
+      "types": "./dist/compose/index.d.ts",
+      "react-native": "./dist/compose/index.js",
+      "default": "./dist/compose/index.js"
+    },
+    "./raw": {
+      "types": "./dist/raw/index.d.ts",
+      "react-native": "./dist/raw/index.js",
+      "default": "./dist/raw/index.js"
+    },
+    "./tap": {
+      "types": "./dist/tap/index.d.ts",
+      "react-native": "./dist/tap/index.js",
+      "default": "./dist/tap/index.js"
+    },
+    "./drag": {
+      "types": "./dist/drag/index.d.ts",
+      "react-native": "./dist/drag/index.js",
+      "default": "./dist/drag/index.js"
+    },
+    "./gesture-handler": {
+      "types": "./dist/gesture-handler/index.d.ts",
+      "react-native": "./dist/gesture-handler/index.js",
+      "default": "./dist/gesture-handler/index.js"
+    },
+    "./jest-preset": "./jest-preset.cjs",
+    "./jest-setup": "./jest-setup.cjs"
+  },
+  "files": [
+    "dist",
+    "src",
+    "jest-preset.cjs",
+    "jest-setup.cjs",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "!**/__tests__",
+    "!**/*.test.*"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "prepack": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
+    "test": "jest",
+    "lint": "eslint . --max-warnings 0",
+    "clean": "rm -rf dist .turbo *.tsbuildinfo"
+  },
+  "peerDependencies": {
+    "react": ">=19.2.3 <20.0.0",
+    "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"
+  },
+  "devDependencies": {
+    "@react-native/babel-preset": "^0.86.3",
+    "@react-native/jest-preset": "^0.86.3",
+    "@testing-library/react-native": "^13.3.3",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.2.0",
+    "jest": "^29.7.0",
+    "react": "19.2.3",
+    "react-native": "0.86.3",
+    "react-native-gesture-handler": "~2.32.0",
+    "react-native-reanimated": "4.5.1",
+    "react-native-worklets": "0.10.1",
+    "react-test-renderer": "19.2.3",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/compose/index.ts

@@ -0,0 +1,7 @@
+export { useGestures } from './useGestures'
+export type {
+  GestureCarrier,
+  GestureMember,
+  GesturesResult,
+  UseGesturesOptions,
+} from './useGestures'

package/src/compose/useGestures.ts

@@ -0,0 +1,136 @@
+import { useMemo } from 'react'
+import { Gesture, type ComposedGesture } from 'react-native-gesture-handler'
+import { warnOnce } from '../internal/warnOnce'
+import { useStableList } from '../internal/useStableList'
+import { type AttachableGesture, type ComposeMode } from '../types'
+
+/**
+ * Anything carrying a gesture — every Impulse hook result, including the one
+ * `useGestures` itself returns.
+ */
+export interface GestureCarrier {
+  readonly gesture: AttachableGesture
+}
+
+/**
+ * A member of a composition: a hook result, or a bare gesture from
+ * `@rootnative/impulse/gesture-handler`.
+ */
+export type GestureMember = GestureCarrier | AttachableGesture
+
+/** What `useGestures` returns. It is itself a valid composition member. */
+export interface GesturesResult {
+  /** The composed gesture. Hand it to `<GestureDetector>`. */
+  readonly gesture: ComposedGesture
+}
+
+/** Options for {@link useGestures}. */
+export interface UseGesturesOptions {
+  /** How the members relate to one another. */
+  mode: ComposeMode
+}
+
+/**
+ * Compose gestures under one relation.
+ *
+ * ```tsx
+ * // 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>
+ * )
+ * ```
+ *
+ * Composition is **data, not nesting**. RNGH expresses the same thing as
+ * `Gesture.Simultaneous(Gesture.Race(tap, doubleTap), drag)`, which has to be
+ * read backwards to learn what wins and gains a level of nesting per
+ * relation. Here each call is one flat list plus the relation that holds over
+ * it, and the result is itself a member, so precedence reads left to right
+ * and depth is a choice rather than a consequence.
+ *
+ * The modes:
+ *
+ * - `race` — the first member to activate wins and cancels the rest. This is
+ *   what you want for mutually exclusive readings of one touch.
+ * - `simultaneous` — every member recognizes independently. A pinch and a
+ *   rotate on one image.
+ * - `exclusive` — members are tried in order, and a later one activates only
+ *   after every earlier one has failed. A tap and a double-tap, where the tap
+ *   must wait to learn whether a second one is coming.
+ *
+ * **Coexistence options are not accepted here, and that is a limitation
+ * rather than a choice.** RNGH's three external-gesture relations are methods
+ * on a single gesture; a composed gesture does not have them. Put
+ * `alongside` / `blocks` / `deferTo` on the member hooks instead — Impulse
+ * cannot apply them for you without mutating gestures another hook owns and
+ * memoised.
+ *
+ * **Accessibility.** A composition is as reachable as its members, which is
+ * to say a screen reader and a keyboard see none of it. Each member hook
+ * documents its own fallback; a composition needs the union of them.
+ *
+ * @param members - The gestures to compose, in precedence order. The order
+ *   matters for `exclusive` and is ignored by the other two modes.
+ * @param options - The relation to compose under.
+ * @returns The composed gesture, stable while the members and the mode are.
+ */
+export function useGestures(
+  members: readonly GestureMember[],
+  options: UseGesturesOptions,
+): GesturesResult {
+  const { mode } = options
+
+  // The member list is written inline at nearly every call site, so compare
+  // the gestures it resolves to rather than the array it arrived in.
+  const gestures = useStableList(members.map(memberGesture))
+
+  const gesture = useMemo(() => compose(mode, gestures), [mode, gestures])
+
+  return useMemo(() => ({ gesture }), [gesture])
+}
+
+/** Unwrap a hook result, or pass a bare gesture through. */
+function memberGesture(member: GestureMember): AttachableGesture {
+  return 'gesture' in member ? member.gesture : member
+}
+
+function compose(
+  mode: ComposeMode,
+  gestures: readonly AttachableGesture[],
+): ComposedGesture {
+  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:
+      // Unreachable from TypeScript. Reachable from JavaScript, and a
+      // misspelled mode would otherwise compose nothing and fail as "the
+      // gesture does not work".
+      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)
+  }
+}

package/src/gesture-handler/index.ts

@@ -0,0 +1,18 @@
+/**
+ * `@rootnative/impulse/gesture-handler` — the RNGH interop subpath.
+ *
+ * Impulse hides RNGH by default, and its intent hooks cover the common cases.
+ * For the rest, this subpath re-exports RNGH's own 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.
+ *
+ * These are pure re-exports and carry no Impulse behaviour. `Gesture.Pan()`
+ * reached through here is the same object as `Gesture.Pan()` reached from
+ * `react-native-gesture-handler`, which means none of Impulse's guarantees —
+ * stable gesture identity, thread-explicit callbacks, intent-shaped payloads
+ * — apply to what you build with it.
+ *
+ * `GestureDetector` is not listed here because the root entry already exports
+ * it; importing it from both paths would be two names for one thing.
+ */
+export * from 'react-native-gesture-handler'

package/src/index.ts

@@ -0,0 +1,53 @@
+/**
+ * `@rootnative/impulse` — declarative gesture primitives for React Native.
+ *
+ * This entry carries the composition and coexistence core: `useGestures` for
+ * relating gestures to one another, `useRawGesture` for building a recognizer
+ * RNGH models and Impulse does not, and the `alongside` / `blocks` /
+ * `deferTo` options both accept.
+ *
+ * `useTap` and `useDrag` are the two intent hooks, and the pattern the rest
+ * follow: an intent-shaped payload, JS-thread callbacks named for what
+ * happened, worklet phase callbacks named for when, and documented activation
+ * criteria. The remaining intents — `useSwipe`, `usePinch`, and the rest — are
+ * designed but not implemented; see the repository README for the roadmap.
+ */
+
+// Re-exported because every hook's result has to be handed to it, and
+// reaching for it is not a reason to add a second gesture import to an app.
+// The rest of RNGH stays behind `@rootnative/impulse/gesture-handler`.
+export { GestureDetector } from 'react-native-gesture-handler'
+
+export { useGestures } from './compose'
+export type {
+  GestureCarrier,
+  GestureMember,
+  GesturesResult,
+  UseGesturesOptions,
+} from './compose'
+
+export { useRawGesture } from './raw'
+export type { RawGestureResult, UseRawGestureOptions } from './raw'
+
+export { useTap } from './intents/tap'
+export type { TapEvent, UseTapOptions, UseTapResult } from './intents/tap'
+
+export { useDrag } from './intents/drag'
+export type {
+  DragAxis,
+  DragBounds,
+  DragEvent,
+  UseDragOptions,
+  UseDragResult,
+} from './intents/drag'
+
+export type {
+  AttachableGesture,
+  ComposeMode,
+  CoexistenceOptions,
+  GestureReference,
+  GestureReferences,
+  HitSlop,
+  IntentResult,
+  Point,
+} from './types'

package/src/intents/drag/index.ts

@@ -0,0 +1,8 @@
+export { useDrag } from '../useDrag'
+export type {
+  DragAxis,
+  DragBounds,
+  DragEvent,
+  UseDragOptions,
+  UseDragResult,
+} from '../useDrag'

package/src/intents/tap/index.ts

@@ -0,0 +1,2 @@
+export { useTap } from '../useTap'
+export type { TapEvent, UseTapOptions, UseTapResult } from '../useTap'