react-native-gtkx 0.2.0-alpha.2 → 0.3.0-alpha.1

package/dist/gesture-handler-compat/detector-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector-runtime.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/detector-runtime.ts"],"names":[],"mappings":"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","sourcesContent":["// Everything a mounted `GestureDetector` has to remember between renders, in\n// a closure rather than in the component.\n//\n// This file exists because the mutable state genuinely belongs here, and the\n// React Compiler's lint rules are right to say so: a component may not read\n// or write a ref while rendering. The detector needs things that outlive a\n// render — the current configs, the child's handle, and the child's own\n// forwarded ref — and every one of them is only ever touched from a callback,\n// an effect or a GTK event. Keeping them behind functions makes that\n// structural instead of a promise.\n//\n// It holds a LIST of recognizers rather than one, because a composed gesture\n// is several recognizers on one child. The prop set the child is given is\n// fixed and stable regardless: each entry is a trampoline over whatever\n// recognizers the group currently has, so composing differently on a later\n// render changes the list inside an effect and never during a render.\nimport { widgetForHandle } from \"../components/measure\"\nimport {\n  computePointInWindow,\n  Gdk,\n  Gtk,\n  type Gtk as GtkNs,\n} from \"../gtkx/bridge/index\"\nimport type { GestureResponderEvent } from \"../responder/types\"\nimport { requestResponder } from \"../responder/use-responder\"\nimport type { PreparedGesture } from \"./composition\"\nimport { DECIDERS } from \"./deciders\"\nimport { gestureOrchestrator } from \"./orchestrator\"\nimport {\n  createRecognizer,\n  type ControllerSample,\n  type Recognizer,\n  type Rect,\n} from \"./recognizer\"\nimport { bindGestureTag, unbindGestureTag } from \"./relations\"\nimport { mintHandlerTag, type GestureKind, type GestureSpec } from \"./types\"\n\n/**\n * The props a recognizer contributes, named once.\n *\n * Fixed rather than read off a recognizer, because the trampolines have to\n * exist before there is a recognizer to read them from: the child renders and\n * registers with the responder system before the detector's own layout effect\n * has run. All three kinds contribute exactly this set.\n */\nconst HANDLER_NAMES = [\n  \"onStartShouldSetResponder\",\n  \"onMoveShouldSetResponder\",\n  \"onTouchStart\",\n  \"onTouchMove\",\n  \"onTouchEnd\",\n  \"onTouchCancel\",\n  \"onResponderGrant\",\n  \"onResponderMove\",\n  \"onResponderRelease\",\n  \"onResponderTerminate\",\n] as const\n\n/** The two responder props that answer a question rather than take an event. */\nexport const PREDICATES = new Set<string>([\n  \"onStartShouldSetResponder\",\n  \"onMoveShouldSetResponder\",\n])\n\n/** A ref in either of React's two spellings. */\ntype AnyRef =\n  ((instance: unknown) => void) | { current: unknown } | null | undefined\n\nlet warnedWithoutWidget = false\n\nconst warnNoWidget = (): void => {\n  if (warnedWithoutWidget) {\n    return\n  }\n  warnedWithoutWidget = true\n  const isProduction =\n    typeof process !== \"undefined\" && process.env.NODE_ENV === \"production\"\n  if (!isProduction) {\n    console.warn(\n      \"react-native-gtkx: `GestureDetector`'s child exposed no ref carrying a widget, so the gesture \" +\n        \"cannot measure its own view. `hitSlop`, `shouldCancelWhenOutside` and the `x`/`y` fields of \" +\n        \"every event will be wrong or ignored. Give the child a `ref` built with the platform's own \" +\n        \"measure handle, or wrap it in a `View`. See docs/api.md.\",\n    )\n  }\n}\n\ntype Mounted = {\n  /** The spec object this recognizer currently drives; rebound every render. */\n  spec: GestureSpec\n  readonly kind: GestureKind\n  readonly tag: number\n  readonly recognizer: Recognizer\n  /**\n   * The GTK controller feeding a kind the pointer stream cannot — a `Pinch`, a\n   * `Rotation`, a `Hover` or a `ForceTouch` — once the child has produced a\n   * widget to attach it to. Null for every pointer kind, and null until then:\n   * the child's ref lands before this parent's layout effect, but a child that\n   * carries no widget at all never gets one.\n   *\n   * Typed as the base controller rather than as `Gesture`, because `Hover`'s\n   * is a `GtkEventControllerMotion` and that is not a gesture at all.\n   */\n  controller: GtkNs.EventController | null\n}\n\n/**\n * `GtkGestureZoom` / `GtkGestureRotate` — `Pinch` and `Rotation`.\n *\n * The scale and the angle are taken from the SIGNAL ARGUMENTS rather than read\n * back off the controller, and that is not a style preference:\n * `gtk_gesture_zoom_get_scale_delta` returns 1 the instant the gesture stops\n * being active, so anything asked after the fact reports the gesture undoing\n * itself. The signal carries the same number GTK would have returned, at the\n * moment it is true.\n *\n * The position is `gtk_gesture_get_bounding_box_center`, whose coordinates are\n * relative to the widget the controller is attached to — which is the\n * gesture's own view, so it is already the view-local space upstream's\n * `focalX`/`anchorX` are in (`absoluteToLocal` in its web delegate). When GTK\n * has no bounding box to report, the view's centre stands in: a touchpad\n * pinch's focal point is the pointer, and a pinch with an unknown focal point\n * is still a pinch.\n */\nconst touchpadController = (\n  kind: \"pinch\" | \"rotation\",\n  widget: GtkNs.Widget,\n  channel: NonNullable<Recognizer[\"controller\"]>,\n): GtkNs.Gesture => {\n  let scale = 1\n  let rotation = 0\n  const controller: GtkNs.Gesture =\n    kind === \"pinch\" ? new Gtk.GestureZoom() : new Gtk.GestureRotate()\n\n  const sample = (): ControllerSample => {\n    let x = widget.getWidth() / 2\n    let y = widget.getHeight() / 2\n    const [known, centreX, centreY] = controller.getBoundingBoxCenter()\n    if (known) {\n      x = centreX\n      y = centreY\n    }\n    // `gtk_gesture_zoom_filter_event` only lets a touchpad pinch through at\n    // exactly two fingers, so this is a constant rather than a reading.\n    return { scale, rotation, x, y, pointers: 2 }\n  }\n\n  controller.on(\"begin\", () => {\n    scale = 1\n    rotation = 0\n    channel.begin(sample())\n  })\n  if (kind === \"pinch\") {\n    ;(controller as GtkNs.GestureZoom).on(\"scale-changed\", (value: number) => {\n      scale = value\n      channel.update(sample())\n    })\n  } else {\n    // `angle-changed` carries the current absolute angle first and the delta\n    // SINCE RECOGNITION second, which is upstream's `rotation` exactly:\n    // radians, cumulative, positive clockwise.\n    ;(controller as GtkNs.GestureRotate).on(\n      \"angle-changed\",\n      (_angle: number, delta: number) => {\n        rotation = delta\n        channel.update(sample())\n      },\n    )\n  }\n  controller.on(\"end\", () => {\n    channel.end()\n  })\n  controller.on(\"cancel\", () => {\n    channel.cancel()\n  })\n  return controller\n}\n\n/**\n * `GtkEventControllerMotion` — `Hover`.\n *\n * The plainest of the three, and the reason this gesture turned out to be\n * deliverable at all: `enter` and `motion` carry the pointer's position in the\n * WIDGET's own coordinates, which is already the space every payload field\n * wants, and `leave` carries nothing because there is nothing left to say.\n *\n * `leave` ends the gesture rather than cancelling it — upstream's\n * `onPointerMoveOut` calls `end()`, and it is right to: the pointer leaving is\n * the hover finishing normally, not something taking it away. GTK's own\n * `cancel` has no counterpart on a motion controller, so the channel's\n * `cancel` is reached only through the arbitration registry.\n *\n * Note that this is the same controller `components/pressable.tsx` attaches\n * for its `hovered` state, on possibly the same widget. Two motion controllers\n * on one widget both receive every crossing — they are observers, and neither\n * claims anything — so a `Pressable` inside a `GestureDetector` keeps its own\n * hover styling while the gesture runs.\n */\nconst hoverController = (\n  channel: NonNullable<Recognizer[\"controller\"]>,\n): GtkNs.EventController => {\n  const controller = new Gtk.EventControllerMotion()\n  controller.on(\"enter\", (x: number, y: number) => {\n    channel.begin({ x, y, pointers: 1 })\n  })\n  controller.on(\"motion\", (x: number, y: number) => {\n    channel.update({ x, y, pointers: 1 })\n  })\n  controller.on(\"leave\", () => {\n    channel.end()\n  })\n  return controller\n}\n\n/**\n * `GtkGestureStylus` — `ForceTouch`, and the one controller here that needs\n * hardware nothing in the test suite can synthesize.\n *\n * `getAxis(Gdk.AxisUse.PRESSURE)` returns `[known, value]` and may ONLY be\n * called from inside one of the four signal handlers, which is why the sample\n * is built in each of them rather than from a shared reader. GDK normalises\n * pressure to `[0, 1]`, which is already upstream's documented range for\n * `minForce`/`maxForce`, so nothing is rescaled.\n *\n * `stylusOnly` is left at GTK's default (true), so this controller sees tablet\n * tools and nothing else. A mouse dragging across the widget produces no\n * events here at all — which is the behaviour that keeps a `ForceTouch` from\n * quietly activating at force 0 on a machine with no tablet.\n */\nconst stylusController = (\n  channel: NonNullable<Recognizer[\"controller\"]>,\n): GtkNs.EventController => {\n  const controller = new Gtk.GestureStylus()\n  const pressure = (): number => {\n    const [known, value] = controller.getAxis(Gdk.AxisUse.PRESSURE)\n    // A tool with no pressure axis reports none, and 0 is the honest reading\n    // rather than a stand-in: a gesture whose `minForce` cannot be met simply\n    // never activates, which is what a device that cannot measure pressure\n    // should produce.\n    return known ? value : 0\n  }\n  controller.on(\"down\", (x: number, y: number) => {\n    channel.begin({ x, y, force: pressure(), pointers: 1 })\n  })\n  controller.on(\"motion\", (x: number, y: number) => {\n    channel.update({ x, y, force: pressure(), pointers: 1 })\n  })\n  controller.on(\"up\", () => {\n    channel.end()\n  })\n  controller.on(\"cancel\", () => {\n    channel.cancel()\n  })\n  return controller\n}\n\nexport type DetectorRuntime = {\n  /** The recognizer props to merge into the child. Stable for the mount. */\n  handlers: Record<string, (event: GestureResponderEvent) => boolean | void>\n  /** The callback ref to put on the child. Stable for the detector's life. */\n  assignHandle: (instance: unknown) => void\n  /** Called from a layout effect on every render. */\n  sync: (prepared: readonly PreparedGesture[], forwarded: AnyRef) => void\n  /** Warns once if the child turned out to carry no widget. */\n  checkWidget: () => void\n  /** Every mounted recognizer, in the order the gestures were written. */\n  gestures: () => readonly Mounted[]\n  dispose: () => void\n}\n\nexport const createDetectorRuntime = (): DetectorRuntime => {\n  let mounted: Mounted[] = []\n  let handle: unknown = null\n  let forwardedRef: AnyRef = null\n\n  const publish = (instance: unknown): void => {\n    if (typeof forwardedRef === \"function\") {\n      forwardedRef(instance)\n    } else if (forwardedRef) {\n      forwardedRef.current = instance\n    }\n  }\n\n  const boundsInWindow = (): Rect | null => {\n    const widget = widgetForHandle(handle)\n    if (!widget) {\n      return null\n    }\n    const origin = computePointInWindow(widget, 0, 0)\n    if (!origin) {\n      return null\n    }\n    return {\n      x: origin.x,\n      y: origin.y,\n      width: widget.getWidth(),\n      height: widget.getHeight(),\n    }\n  }\n\n  /**\n   * Attaches the GTK controller a non-pointer kind is fed by, and pumps it\n   * into the recognizer's controller channel.\n   *\n   * FOUR KINDS, THREE CONTROLLERS, ONE CHANNEL. `GtkGestureZoom` for `Pinch`,\n   * `GtkGestureRotate` for `Rotation`, `GtkEventControllerMotion` for `Hover`\n   * and `GtkGestureStylus` for `ForceTouch`. Everything past `channel.begin`\n   * is the same state machine every pointer kind runs on — see\n   * `ControllerChannel` in ./recognizer.\n   */\n  const attachController = (gesture: Mounted): void => {\n    const channel = gesture.recognizer.controller\n    if (channel === null || gesture.controller !== null) {\n      return\n    }\n    const widget = widgetForHandle(handle)\n    if (!widget) {\n      return\n    }\n\n    if (gesture.kind === \"pinch\" || gesture.kind === \"rotation\") {\n      gesture.controller = touchpadController(gesture.kind, widget, channel)\n    } else if (gesture.kind === \"hover\") {\n      gesture.controller = hoverController(channel)\n    } else {\n      gesture.controller = stylusController(channel)\n    }\n    widget.addController(gesture.controller)\n  }\n\n  const detachController = (gesture: Mounted): void => {\n    const controller = gesture.controller\n    if (controller === null) {\n      return\n    }\n    gesture.controller = null\n    const widget = widgetForHandle(handle)\n    widget?.removeController(controller)\n  }\n\n  const create = (spec: GestureSpec): Mounted => {\n    const tag = mintHandlerTag()\n    const gesture: Mounted = {\n      spec,\n      kind: spec.kind,\n      tag,\n      controller: null,\n      // The config is read on every event rather than captured, so a re-render\n      // that hands the detector a fresh gesture object takes effect without\n      // swapping the handler set mid-drag.\n      recognizer: createRecognizer(\n        tag,\n        DECIDERS[spec.kind],\n        () => gesture.spec.config,\n        {\n          boundsInWindow,\n          requestResponder: (): boolean => {\n            const widget = widgetForHandle(handle)\n            return widget !== null && requestResponder(widget)\n          },\n          orchestrator: gestureOrchestrator,\n        },\n      ),\n    }\n    return gesture\n  }\n\n  const handlers: Record<\n    string,\n    (event: GestureResponderEvent) => boolean | void\n  > = {}\n  for (const name of HANDLER_NAMES) {\n    handlers[name] = PREDICATES.has(name)\n      ? (event: GestureResponderEvent) => {\n          // Either recognizer saying yes is a yes, and every one of them is\n          // asked — the same rule RN's own bubbling uses when several views\n          // want the responder, and the reason a composed gesture's members\n          // all get to see the question.\n          let wanted = false\n          for (const gesture of mounted) {\n            if (gesture.recognizer.handlers[name]?.(event) === true) {\n              wanted = true\n            }\n          }\n          return wanted\n        }\n      : (event: GestureResponderEvent) => {\n          for (const gesture of mounted) {\n            gesture.recognizer.handlers[name]?.(event)\n          }\n        }\n  }\n\n  return {\n    handlers,\n\n    assignHandle: (instance: unknown) => {\n      handle = instance\n      publish(instance)\n      // No return value: React 19 reads one as a callback-ref cleanup.\n    },\n\n    sync: (prepared, forwarded) => {\n      // A composition whose SHAPE changed is a different set of gestures, so\n      // the recognizers that no longer have a counterpart are disposed and\n      // the new ones minted. Doing it here rather than during render is what\n      // keeps tag minting out of the render phase; the child's props never\n      // change, because they are trampolines over this list.\n      const next: Mounted[] = []\n      const reusable = [...mounted]\n      for (const gesture of prepared) {\n        const index = reusable.findIndex(\n          (candidate) => candidate.kind === gesture.spec.kind,\n        )\n        const existing =\n          index >= 0 ? reusable.splice(index, 1)[0]! : create(gesture.spec)\n        existing.spec = gesture.spec\n        next.push(existing)\n        // Identity for the relation maps: the spec object an app holds points\n        // at the tag this mount minted. Re-bound every render because both\n        // spellings rebuild the object, and never unbound on re-render, so a\n        // memoized gesture holding an earlier render's object still resolves.\n        bindGestureTag(gesture.spec, existing.tag)\n        gestureOrchestrator.relations.configure(existing.tag, gesture.relations)\n        // Idempotent, and attempted on every render rather than once: the\n        // child's ref lands before this effect, but a child that is not laid\n        // out yet has no widget to carry a controller. The first render that\n        // has one attaches it.\n        attachController(existing)\n      }\n      for (const dropped of reusable) {\n        unbindGestureTag(dropped.spec)\n        detachController(dropped)\n        dropped.recognizer.dispose()\n      }\n      mounted = next\n\n      // The child's ref is attached BEFORE this parent's layout effect runs,\n      // so the first `assignHandle` happened while there was nothing to\n      // forward to. Publishing again here is what gets the handle into a ref\n      // the child was given on its very first mount.\n      const changed = forwarded !== forwardedRef\n      forwardedRef = forwarded\n      if (changed && handle !== null) {\n        publish(handle)\n      }\n    },\n\n    checkWidget: () => {\n      if (widgetForHandle(handle) === null) {\n        warnNoWidget()\n      }\n    },\n\n    gestures: () => mounted,\n\n    dispose: () => {\n      for (const gesture of mounted) {\n        unbindGestureTag(gesture.spec)\n        detachController(gesture)\n        gesture.recognizer.dispose()\n      }\n      mounted = []\n    },\n  }\n}\n"]}

package/dist/gesture-handler-compat/detector.d.ts

@@ -0,0 +1,22 @@
+import { type ReactElement, type ReactNode } from "react";
+import { type AnyGestureSpec } from "./types";
+export type GestureDetectorProps = {
+    gesture: AnyGestureSpec;
+    children?: ReactNode;
+    /**
+     * Web-only upstream, and inert here — there is no text selection to
+     * suppress, no context-menu default to cancel and no CSS `touch-action` on
+     * a GTK widget. Accepted so portable source stays portable.
+     */
+    userSelect?: string;
+    enableContextMenu?: boolean;
+    touchAction?: string;
+};
+/**
+ * Not a view: exactly one child, whose props it extends.
+ *
+ * Upstream attaches a ref and subscribes the child's native view; the same
+ * idea with the platform substituted, plus the merge that keeps the child's
+ * own responder props alive.
+ */
+export declare const GestureDetector: ({ gesture, children, }: GestureDetectorProps) => ReactElement;

package/dist/gesture-handler-compat/detector.js

@@ -0,0 +1,104 @@
+// `GestureDetector` — the one piece of the RNGH surface that survives
+// upstream's own migration intact, and the only part of it that renders.
+//
+// IT ADDS NO WIDGET, for exactly the reasons `createAnimatedComponent`
+// records: an extra box changes flex layout, changes what `measureLayout` is
+// relative to, and changes which widget a parent's allocate walks. So it
+// renders its single child unchanged and reaches that child's widget through
+// the handle the child already exposes — `widgetForHandle` in
+// components/measure.ts, the seam reanimated slice 1b built for this shape.
+//
+// The gesture's events arrive through the child's OWN responder registration
+// rather than through a second one. Two `Gtk.GestureDrag` controllers on one
+// widget would report every press twice, and two `register()` calls for one
+// host would silently drop whichever came first — so the recognizer's props
+// are MERGED into the child's, and the child's own responder props keep
+// working alongside them.
+//
+// The widget is still needed, and not for events: `hitSlop`,
+// `shouldCancelWhenOutside` and the `x`/`y` fields of every payload are all
+// measured against the gesture's own view, which is not necessarily the
+// widget the event arrived on.
+//
+// Everything mutable lives in ./detector-runtime, so nothing here reads or
+// writes a ref while rendering.
+import { cloneElement, isValidElement, useLayoutEffect, useState, } from "react";
+import { prepareGestures } from "./composition";
+import { createDetectorRuntime, PREDICATES } from "./detector-runtime";
+import { isAnyGestureSpec } from "./types";
+/**
+ * Not a view: exactly one child, whose props it extends.
+ *
+ * Upstream attaches a ref and subscribes the child's native view; the same
+ * idea with the platform substituted, plus the merge that keeps the child's
+ * own responder props alive.
+ */
+export const GestureDetector = ({ gesture, children, }) => {
+    if (!gesture) {
+        throw new Error("react-native-gtkx: `GestureDetector` must have a gesture prop provided.");
+    }
+    if (!isAnyGestureSpec(gesture)) {
+        throw new Error("react-native-gtkx: `GestureDetector` was given something that is not a gesture. " +
+            "Build one with `Gesture.Pan()`, `Gesture.Tap()`, `Gesture.LongPress()`, " +
+            "`Gesture.Native()`, `Gesture.Pinch()`, `Gesture.Rotation()`, `Gesture.Fling()`, " +
+            "`Gesture.Manual()`, `Gesture.Hover()` or `Gesture.ForceTouch()` — or the hook " +
+            "spelling of any of them — or compose several with `Gesture.Race()`, " +
+            "`Gesture.Simultaneous()` or `Gesture.Exclusive()`. See docs/api.md.");
+    }
+    if (!isValidElement(children)) {
+        throw new Error("react-native-gtkx: `GestureDetector` expects exactly one element child. " +
+            "It renders no widget of its own, so there is nothing for a fragment, a string or " +
+            "several children to attach to.");
+    }
+    // One runtime, and one handler tag per recognizer in it, for as long as this
+    // detector is mounted. Upstream reassigns tags when the gesture object
+    // changes; here the object is not the identity — both spellings rebuild it
+    // every render — the mounted detector is, and ./relations is what maps an
+    // app's gesture object onto the tag that identity minted.
+    const [runtime] = useState(createDetectorRuntime);
+    // A composition is flattened to the recognizers it contains, each carrying
+    // the relations composition gave it. `Race`, `Simultaneous` and `Exclusive`
+    // do all of their work here and contribute no mechanism past this point.
+    const prepared = prepareGestures(gesture);
+    const childProps = children.props;
+    // React 19 made `ref` an ordinary prop, and reading `element.ref` warns that
+    // it did. So the child's own ref is read from its props and nowhere else —
+    // which is also where `cloneElement` will put ours back.
+    const childRef = childProps.ref;
+    // The config is read on every event rather than captured, so a re-render
+    // that hands over a fresh gesture object takes effect without swapping the
+    // handler set mid-drag.
+    useLayoutEffect(() => {
+        runtime.sync(prepared, childRef);
+    });
+    useLayoutEffect(() => runtime.dispose, [runtime]);
+    // A silent no-op is the failure this repo refuses. Checked after the child's
+    // own layout effects have run, which is where its `useImperativeHandle`
+    // publishes the handle.
+    useLayoutEffect(() => {
+        runtime.checkWidget();
+    });
+    const merged = { ref: runtime.assignHandle };
+    for (const [name, own] of Object.entries(runtime.handlers)) {
+        const childHandler = childProps[name];
+        if (!childHandler) {
+            merged[name] = own;
+            continue;
+        }
+        // The child asked for these too. Both run; for the two that answer a
+        // question, either saying yes is a yes — the same rule RN's own bubbling
+        // uses when several views want the responder.
+        merged[name] = PREDICATES.has(name)
+            ? (event) => {
+                const mine = own(event) === true;
+                const theirs = childHandler(event) === true;
+                return mine || theirs;
+            }
+            : (event) => {
+                own(event);
+                childHandler(event);
+            };
+    }
+    return cloneElement(children, merged);
+};
+//# sourceMappingURL=detector.js.map

package/dist/gesture-handler-compat/detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/detector.tsx"],"names":[],"mappings":"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","sourcesContent":["// `GestureDetector` — the one piece of the RNGH surface that survives\n// upstream's own migration intact, and the only part of it that renders.\n//\n// IT ADDS NO WIDGET, for exactly the reasons `createAnimatedComponent`\n// records: an extra box changes flex layout, changes what `measureLayout` is\n// relative to, and changes which widget a parent's allocate walks. So it\n// renders its single child unchanged and reaches that child's widget through\n// the handle the child already exposes — `widgetForHandle` in\n// components/measure.ts, the seam reanimated slice 1b built for this shape.\n//\n// The gesture's events arrive through the child's OWN responder registration\n// rather than through a second one. Two `Gtk.GestureDrag` controllers on one\n// widget would report every press twice, and two `register()` calls for one\n// host would silently drop whichever came first — so the recognizer's props\n// are MERGED into the child's, and the child's own responder props keep\n// working alongside them.\n//\n// The widget is still needed, and not for events: `hitSlop`,\n// `shouldCancelWhenOutside` and the `x`/`y` fields of every payload are all\n// measured against the gesture's own view, which is not necessarily the\n// widget the event arrived on.\n//\n// Everything mutable lives in ./detector-runtime, so nothing here reads or\n// writes a ref while rendering.\nimport {\n  cloneElement,\n  isValidElement,\n  useLayoutEffect,\n  useState,\n  type ReactElement,\n  type ReactNode,\n  type Ref,\n} from \"react\"\nimport { prepareGestures } from \"./composition\"\nimport { createDetectorRuntime, PREDICATES } from \"./detector-runtime\"\nimport { isAnyGestureSpec, type AnyGestureSpec } from \"./types\"\n\nexport type GestureDetectorProps = {\n  gesture: AnyGestureSpec\n  children?: ReactNode\n  /**\n   * Web-only upstream, and inert here — there is no text selection to\n   * suppress, no context-menu default to cancel and no CSS `touch-action` on\n   * a GTK widget. Accepted so portable source stays portable.\n   */\n  userSelect?: string\n  enableContextMenu?: boolean\n  touchAction?: string\n}\n\n/**\n * Not a view: exactly one child, whose props it extends.\n *\n * Upstream attaches a ref and subscribes the child's native view; the same\n * idea with the platform substituted, plus the merge that keeps the child's\n * own responder props alive.\n */\nexport const GestureDetector = ({\n  gesture,\n  children,\n}: GestureDetectorProps): ReactElement => {\n  if (!gesture) {\n    throw new Error(\n      \"react-native-gtkx: `GestureDetector` must have a gesture prop provided.\",\n    )\n  }\n  if (!isAnyGestureSpec(gesture)) {\n    throw new Error(\n      \"react-native-gtkx: `GestureDetector` was given something that is not a gesture. \" +\n        \"Build one with `Gesture.Pan()`, `Gesture.Tap()`, `Gesture.LongPress()`, \" +\n        \"`Gesture.Native()`, `Gesture.Pinch()`, `Gesture.Rotation()`, `Gesture.Fling()`, \" +\n        \"`Gesture.Manual()`, `Gesture.Hover()` or `Gesture.ForceTouch()` — or the hook \" +\n        \"spelling of any of them — or compose several with `Gesture.Race()`, \" +\n        \"`Gesture.Simultaneous()` or `Gesture.Exclusive()`. See docs/api.md.\",\n    )\n  }\n  if (!isValidElement(children)) {\n    throw new Error(\n      \"react-native-gtkx: `GestureDetector` expects exactly one element child. \" +\n        \"It renders no widget of its own, so there is nothing for a fragment, a string or \" +\n        \"several children to attach to.\",\n    )\n  }\n\n  // One runtime, and one handler tag per recognizer in it, for as long as this\n  // detector is mounted. Upstream reassigns tags when the gesture object\n  // changes; here the object is not the identity — both spellings rebuild it\n  // every render — the mounted detector is, and ./relations is what maps an\n  // app's gesture object onto the tag that identity minted.\n  const [runtime] = useState(createDetectorRuntime)\n\n  // A composition is flattened to the recognizers it contains, each carrying\n  // the relations composition gave it. `Race`, `Simultaneous` and `Exclusive`\n  // do all of their work here and contribute no mechanism past this point.\n  const prepared = prepareGestures(gesture)\n\n  const childProps = children.props as Record<string, unknown>\n  // React 19 made `ref` an ordinary prop, and reading `element.ref` warns that\n  // it did. So the child's own ref is read from its props and nowhere else —\n  // which is also where `cloneElement` will put ours back.\n  const childRef = childProps.ref as Ref<unknown> | undefined\n\n  // The config is read on every event rather than captured, so a re-render\n  // that hands over a fresh gesture object takes effect without swapping the\n  // handler set mid-drag.\n  useLayoutEffect(() => {\n    runtime.sync(prepared, childRef)\n  })\n\n  useLayoutEffect(() => runtime.dispose, [runtime])\n\n  // A silent no-op is the failure this repo refuses. Checked after the child's\n  // own layout effects have run, which is where its `useImperativeHandle`\n  // publishes the handle.\n  useLayoutEffect(() => {\n    runtime.checkWidget()\n  })\n\n  const merged: Record<string, unknown> = { ref: runtime.assignHandle }\n  for (const [name, own] of Object.entries(runtime.handlers)) {\n    const childHandler = childProps[name] as\n      ((event: never) => boolean | void) | undefined\n    if (!childHandler) {\n      merged[name] = own\n      continue\n    }\n    // The child asked for these too. Both run; for the two that answer a\n    // question, either saying yes is a yes — the same rule RN's own bubbling\n    // uses when several views want the responder.\n    merged[name] = PREDICATES.has(name)\n      ? (event: never) => {\n          const mine = own(event) === true\n          const theirs = childHandler(event) === true\n          return mine || theirs\n        }\n      : (event: never) => {\n          own(event)\n          childHandler(event)\n        }\n  }\n\n  return cloneElement(children, merged)\n}\n"]}

package/dist/gesture-handler-compat/fling.d.ts

@@ -0,0 +1,24 @@
+import type { RecognizerDecider } from "./recognizer";
+/** Upstream's `DEFAULT_MAX_DURATION_MS`: past this, the fling has failed. */
+export declare const DEFAULT_MAX_DURATION = 800;
+/** Upstream's `DEFAULT_MIN_VELOCITY`, in units per second. */
+export declare const DEFAULT_MIN_VELOCITY = 700;
+/** Upstream's `DEFAULT_DIRECTION`. */
+export declare const DEFAULT_DIRECTION: 1;
+/** Upstream's `DEFAULT_NUMBER_OF_TOUCHES_REQUIRED`. */
+export declare const DEFAULT_NUMBER_OF_POINTERS = 1;
+/** Upstream's `DEFAULT_ALIGNMENT_CONE`, in degrees. */
+export declare const ALIGNMENT_CONE_DEGREES = 30;
+/** cos(15°) — the axial cone. */
+export declare const AXIAL_DEVIATION_COSINE: number;
+/** cos(30°) — the diagonal cone, which is the complement of the axial one. */
+export declare const DIAGONAL_DEVIATION_COSINE: number;
+/**
+ * Whether the velocity points along any direction the config asked for.
+ *
+ * The similarity is a dot product of UNIT vectors, so it is the cosine of the
+ * angle between them, and the comparison is strict — upstream's
+ * `Vector.isSimilar` uses `>` rather than `>=`.
+ */
+export declare const isAligned: (velocityX: number, velocityY: number, direction: number) => boolean;
+export declare const flingDecider: RecognizerDecider;

package/dist/gesture-handler-compat/fling.js

@@ -0,0 +1,123 @@
+import { DIAGONAL_DIRECTIONS, DIRECTIONS } from "./types";
+/** Upstream's `DEFAULT_MAX_DURATION_MS`: past this, the fling has failed. */
+export const DEFAULT_MAX_DURATION = 800;
+/** Upstream's `DEFAULT_MIN_VELOCITY`, in units per second. */
+export const DEFAULT_MIN_VELOCITY = 700;
+/** Upstream's `DEFAULT_DIRECTION`. */
+export const DEFAULT_DIRECTION = DIRECTIONS.RIGHT;
+/** Upstream's `DEFAULT_NUMBER_OF_TOUCHES_REQUIRED`. */
+export const DEFAULT_NUMBER_OF_POINTERS = 1;
+/** Upstream's `DEFAULT_ALIGNMENT_CONE`, in degrees. */
+export const ALIGNMENT_CONE_DEGREES = 30;
+/**
+ * `coneToDeviation` from `src/web/utils.ts`: the cosine of HALF the cone, so
+ * a 30° cone accepts everything within ±15° of the axis.
+ */
+const coneToDeviation = (degrees) => Math.cos((degrees / 2) * (Math.PI / 180));
+/** cos(15°) — the axial cone. */
+export const AXIAL_DEVIATION_COSINE = coneToDeviation(ALIGNMENT_CONE_DEGREES);
+/** cos(30°) — the diagonal cone, which is the complement of the axial one. */
+export const DIAGONAL_DEVIATION_COSINE = coneToDeviation(90 - ALIGNMENT_CONE_DEGREES);
+/**
+ * Upstream's `MINIMAL_RECOGNIZABLE_MAGNITUDE`. Below it a vector has no
+ * meaningful direction, and upstream's `Vector` zeroes the unit vector rather
+ * than dividing by something near zero.
+ */
+const MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1;
+/** The unit vector each direction bit stands for, in SCREEN coordinates. */
+const DIRECTION_VECTORS = [
+    // [bit, x, y] — note that UP is negative Y, which is upstream's mapping and
+    // the screen's rather than the maths convention.
+    [DIRECTIONS.LEFT, -1, 0],
+    [DIRECTIONS.RIGHT, 1, 0],
+    [DIRECTIONS.UP, 0, -1],
+    [DIRECTIONS.DOWN, 0, 1],
+];
+const DIAGONAL_VECTORS = [
+    [DIAGONAL_DIRECTIONS.UP_RIGHT, 1, -1],
+    [DIAGONAL_DIRECTIONS.DOWN_RIGHT, 1, 1],
+    [DIAGONAL_DIRECTIONS.UP_LEFT, -1, -1],
+    [DIAGONAL_DIRECTIONS.DOWN_LEFT, -1, 1],
+];
+/**
+ * Whether the velocity points along any direction the config asked for.
+ *
+ * The similarity is a dot product of UNIT vectors, so it is the cosine of the
+ * angle between them, and the comparison is strict — upstream's
+ * `Vector.isSimilar` uses `>` rather than `>=`.
+ */
+export const isAligned = (velocityX, velocityY, direction) => {
+    const magnitude = Math.hypot(velocityX, velocityY);
+    if (magnitude <= MINIMAL_RECOGNIZABLE_MAGNITUDE) {
+        // Upstream zeroes the unit vector here, which makes every dot product 0
+        // and every alignment false. Stated directly rather than reproduced
+        // through a zeroed vector, because a division by a near-zero magnitude is
+        // the thing being avoided and this says so.
+        return false;
+    }
+    const unitX = velocityX / magnitude;
+    const unitY = velocityY / magnitude;
+    const alignedWith = (candidates, threshold) => candidates.some(([bit, x, y]) => {
+        // Every bit of the candidate must be set in the config. For an axis that
+        // is one bit; for a diagonal it is two, which is why `UP | RIGHT` opts
+        // into the diagonal and `UP` alone does not.
+        if ((bit & direction) !== bit) {
+            return false;
+        }
+        const length = Math.hypot(x, y);
+        return unitX * (x / length) + unitY * (y / length) > threshold;
+    });
+    return (alignedWith(DIRECTION_VECTORS, AXIAL_DEVIATION_COSINE) ||
+        alignedWith(DIAGONAL_VECTORS, DIAGONAL_DEVIATION_COSINE));
+};
+export const flingDecider = {
+    kind: "fling",
+    // Activating a fling is finishing it. Upstream overrides `activate()` to
+    // call `end()`; this is that, without a subclass to hang it on.
+    endsOnActivate: true,
+    /**
+     * The deadline. Unlike `Tap`'s it is not a "too slow to be a tap" rule about
+     * the press — it is the window inside which a fling has to happen at all,
+     * and it is the second of the two guards that keep a slow drag from ever
+     * qualifying.
+     */
+    timer: () => ({
+        delay: DEFAULT_MAX_DURATION,
+        elapsed: "fail",
+    }),
+    /**
+     * Never from movement. Upstream's fling has no failure predicate over
+     * travel: a pointer wandering the wrong way has simply not flung yet, and it
+     * may still turn and fling before the deadline. What fails it is the timer,
+     * or lifting without having qualified (the `onRelease` below).
+     */
+    shouldFail: () => false,
+    shouldActivate: (view, config) => {
+        // EXACT equality, in both directions, and against the high-water mark
+        // rather than the count right now — a fling is a statement about how many
+        // fingers made it.
+        if (view.maxPointerCount !==
+            (config.numberOfPointers ?? DEFAULT_NUMBER_OF_POINTERS)) {
+            return false;
+        }
+        if (Math.hypot(view.velocityX, view.velocityY) <= DEFAULT_MIN_VELOCITY) {
+            // Strict, as upstream's `magnitude > this.minVelocity` is. This is the
+            // whole difference between a fling and a drag.
+            return false;
+        }
+        return isAligned(view.velocityX, view.velocityY, config.direction ?? DEFAULT_DIRECTION);
+    },
+    /**
+     * The last chance, and then it is over.
+     *
+     * Upstream's `onUp` runs `tryEndFling()` one final time and calls `fail()`
+     * if it still does not qualify — so the release asks exactly the question a
+     * move would have asked, and the answer decides between END and FAILED. The
+     * velocity it reads is the last move's, which is upstream's too: neither
+     * platform re-measures anything at the moment a button comes up.
+     */
+    onRelease: (view, config) => flingDecider.shouldActivate(view, config)
+        ? { kind: "activate" }
+        : { kind: "fail" },
+};
+//# sourceMappingURL=fling.js.map

package/dist/gesture-handler-compat/fling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fling.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/fling.ts"],"names":[],"mappings":"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","sourcesContent":["// `Gesture.Fling()` — a directional swipe, which is a VELOCITY predicate and\n// a direction predicate over the same machine everything else runs on.\n//\n// THE THING TO GET RIGHT IS THE VELOCITY, and it is the thing a naive test\n// does not catch: a fling is not \"the pointer travelled 200px to the right\".\n// A slow drag travels exactly as far. What tells them apart is how fast the\n// pointer was going when it got there, and upstream guards it twice —\n// `minVelocity` (700 units per second) as the criterion, and `maxDurationMs`\n// (800ms) as a hard deadline that fails the gesture whatever it is doing. A\n// leisurely drag across the same distance misses both.\n//\n// Restated from `src/web/handlers/FlingGestureHandler.ts` at 3.1.0, not\n// transcribed. Four details are worth naming because each is load-bearing and\n// none of them is obvious:\n//\n//   - **the decision is made on every MOVE, not on the release.** Upstream\n//     calls `tryEndFling()` from `onPointerMove`, so a fling activates the\n//     instant the pointer is fast enough and pointed the right way, with the\n//     button still down. The release is only the last chance;\n//   - **activating IS ending.** `FlingGestureHandler.activate()` is overridden\n//     to call `this.end()` immediately, so the progression is\n//     BEGAN -> ACTIVE -> END in one synchronous breath and there is never an\n//     `onUpdate`. See `RecognizerDecider.endsOnActivate`;\n//   - **the direction is a bitmask and the diagonals come free.** A config of\n//     `Directions.UP | Directions.RIGHT` sets both bits, so the internal\n//     `UP_RIGHT` composite (5) also passes `(composite & config) === composite`\n//     and is tested — with a WIDER cone, 60° against the axes' 30°. The two\n//     cone widths tile the circle exactly: 4×30 + 4×60 = 360;\n//   - **the pointer count is compared for EQUALITY**, against the most\n//     pointers the interaction ever had at once. Upstream refuses a mismatch\n//     in both directions, so a two-finger fling is not satisfied by one finger\n//     and a one-finger fling is not satisfied by two.\n//\n// WHERE THIS PLATFORM'S VELOCITY DIFFERS FROM UPSTREAM'S, said plainly because\n// it is the number the whole gesture turns on. Upstream fits a second-degree\n// least-squares polynomial over up to 20 samples inside a 300ms horizon\n// (`VelocityTracker`) and takes the linear coefficient. This platform's\n// `velocityX`/`velocityY` are the last inter-event delta, which is what\n// `Pan().minVelocity()` has always used here and what every payload reports —\n// so `Fling` reads the same number its own event carries rather than a second,\n// better one nothing else can see. The consequence is that this fling is more\n// sensitive to a single long frame than upstream's; the 800ms deadline and the\n// alignment cone are unaffected, and docs/api.md records the difference.\nimport type {\n  RecognizerDecider,\n  RecognizerTimer,\n  RecognizerView,\n} from \"./recognizer\"\nimport { DIAGONAL_DIRECTIONS, DIRECTIONS, type RecognizerConfig } from \"./types\"\n\n/** Upstream's `DEFAULT_MAX_DURATION_MS`: past this, the fling has failed. */\nexport const DEFAULT_MAX_DURATION = 800\n\n/** Upstream's `DEFAULT_MIN_VELOCITY`, in units per second. */\nexport const DEFAULT_MIN_VELOCITY = 700\n\n/** Upstream's `DEFAULT_DIRECTION`. */\nexport const DEFAULT_DIRECTION = DIRECTIONS.RIGHT\n\n/** Upstream's `DEFAULT_NUMBER_OF_TOUCHES_REQUIRED`. */\nexport const DEFAULT_NUMBER_OF_POINTERS = 1\n\n/** Upstream's `DEFAULT_ALIGNMENT_CONE`, in degrees. */\nexport const ALIGNMENT_CONE_DEGREES = 30\n\n/**\n * `coneToDeviation` from `src/web/utils.ts`: the cosine of HALF the cone, so\n * a 30° cone accepts everything within ±15° of the axis.\n */\nconst coneToDeviation = (degrees: number): number =>\n  Math.cos((degrees / 2) * (Math.PI / 180))\n\n/** cos(15°) — the axial cone. */\nexport const AXIAL_DEVIATION_COSINE = coneToDeviation(ALIGNMENT_CONE_DEGREES)\n\n/** cos(30°) — the diagonal cone, which is the complement of the axial one. */\nexport const DIAGONAL_DEVIATION_COSINE = coneToDeviation(\n  90 - ALIGNMENT_CONE_DEGREES,\n)\n\n/**\n * Upstream's `MINIMAL_RECOGNIZABLE_MAGNITUDE`. Below it a vector has no\n * meaningful direction, and upstream's `Vector` zeroes the unit vector rather\n * than dividing by something near zero.\n */\nconst MINIMAL_RECOGNIZABLE_MAGNITUDE = 0.1\n\n/** The unit vector each direction bit stands for, in SCREEN coordinates. */\nconst DIRECTION_VECTORS: readonly (readonly [number, number, number])[] = [\n  // [bit, x, y] — note that UP is negative Y, which is upstream's mapping and\n  // the screen's rather than the maths convention.\n  [DIRECTIONS.LEFT, -1, 0],\n  [DIRECTIONS.RIGHT, 1, 0],\n  [DIRECTIONS.UP, 0, -1],\n  [DIRECTIONS.DOWN, 0, 1],\n]\n\nconst DIAGONAL_VECTORS: readonly (readonly [number, number, number])[] = [\n  [DIAGONAL_DIRECTIONS.UP_RIGHT, 1, -1],\n  [DIAGONAL_DIRECTIONS.DOWN_RIGHT, 1, 1],\n  [DIAGONAL_DIRECTIONS.UP_LEFT, -1, -1],\n  [DIAGONAL_DIRECTIONS.DOWN_LEFT, -1, 1],\n]\n\n/**\n * Whether the velocity points along any direction the config asked for.\n *\n * The similarity is a dot product of UNIT vectors, so it is the cosine of the\n * angle between them, and the comparison is strict — upstream's\n * `Vector.isSimilar` uses `>` rather than `>=`.\n */\nexport const isAligned = (\n  velocityX: number,\n  velocityY: number,\n  direction: number,\n): boolean => {\n  const magnitude = Math.hypot(velocityX, velocityY)\n  if (magnitude <= MINIMAL_RECOGNIZABLE_MAGNITUDE) {\n    // Upstream zeroes the unit vector here, which makes every dot product 0\n    // and every alignment false. Stated directly rather than reproduced\n    // through a zeroed vector, because a division by a near-zero magnitude is\n    // the thing being avoided and this says so.\n    return false\n  }\n  const unitX = velocityX / magnitude\n  const unitY = velocityY / magnitude\n\n  const alignedWith = (\n    candidates: readonly (readonly [number, number, number])[],\n    threshold: number,\n  ): boolean =>\n    candidates.some(([bit, x, y]) => {\n      // Every bit of the candidate must be set in the config. For an axis that\n      // is one bit; for a diagonal it is two, which is why `UP | RIGHT` opts\n      // into the diagonal and `UP` alone does not.\n      if ((bit & direction) !== bit) {\n        return false\n      }\n      const length = Math.hypot(x, y)\n      return unitX * (x / length) + unitY * (y / length) > threshold\n    })\n\n  return (\n    alignedWith(DIRECTION_VECTORS, AXIAL_DEVIATION_COSINE) ||\n    alignedWith(DIAGONAL_VECTORS, DIAGONAL_DEVIATION_COSINE)\n  )\n}\n\nexport const flingDecider: RecognizerDecider = {\n  kind: \"fling\",\n\n  // Activating a fling is finishing it. Upstream overrides `activate()` to\n  // call `end()`; this is that, without a subclass to hang it on.\n  endsOnActivate: true,\n\n  /**\n   * The deadline. Unlike `Tap`'s it is not a \"too slow to be a tap\" rule about\n   * the press — it is the window inside which a fling has to happen at all,\n   * and it is the second of the two guards that keep a slow drag from ever\n   * qualifying.\n   */\n  timer: (): RecognizerTimer => ({\n    delay: DEFAULT_MAX_DURATION,\n    elapsed: \"fail\",\n  }),\n\n  /**\n   * Never from movement. Upstream's fling has no failure predicate over\n   * travel: a pointer wandering the wrong way has simply not flung yet, and it\n   * may still turn and fling before the deadline. What fails it is the timer,\n   * or lifting without having qualified (the `onRelease` below).\n   */\n  shouldFail: (): boolean => false,\n\n  shouldActivate: (view: RecognizerView, config: RecognizerConfig): boolean => {\n    // EXACT equality, in both directions, and against the high-water mark\n    // rather than the count right now — a fling is a statement about how many\n    // fingers made it.\n    if (\n      view.maxPointerCount !==\n      (config.numberOfPointers ?? DEFAULT_NUMBER_OF_POINTERS)\n    ) {\n      return false\n    }\n    if (Math.hypot(view.velocityX, view.velocityY) <= DEFAULT_MIN_VELOCITY) {\n      // Strict, as upstream's `magnitude > this.minVelocity` is. This is the\n      // whole difference between a fling and a drag.\n      return false\n    }\n    return isAligned(\n      view.velocityX,\n      view.velocityY,\n      config.direction ?? DEFAULT_DIRECTION,\n    )\n  },\n\n  /**\n   * The last chance, and then it is over.\n   *\n   * Upstream's `onUp` runs `tryEndFling()` one final time and calls `fail()`\n   * if it still does not qualify — so the release asks exactly the question a\n   * move would have asked, and the answer decides between END and FAILED. The\n   * velocity it reads is the last move's, which is upstream's too: neither\n   * platform re-measures anything at the moment a button comes up.\n   */\n  onRelease: (view: RecognizerView, config: RecognizerConfig) =>\n    flingDecider.shouldActivate(view, config)\n      ? ({ kind: \"activate\" } as const)\n      : ({ kind: \"fail\" } as const),\n}\n"]}

package/dist/gesture-handler-compat/force-touch.d.ts

@@ -0,0 +1,13 @@
+import type { RecognizerDecider } from "./recognizer";
+/**
+ * Upstream's documented default for `minForce`.
+ *
+ * A DOC COMMENT rather than a constant, and that is worth flagging: the `0.2`
+ * appears only in the JSDoc on `ForceTouchGestureConfig.minForce`
+ * (`src/handlers/ForceTouchGestureHandler.ts`), and no JavaScript in upstream
+ * assigns it — the real default lives in iOS code this repo cannot read. It is
+ * reproduced because a documented default is still upstream's answer, and
+ * inventing a different one would be a silent divergence.
+ */
+export declare const DEFAULT_MIN_FORCE = 0.2;
+export declare const forceTouchDecider: RecognizerDecider;

package/dist/gesture-handler-compat/force-touch.js

@@ -0,0 +1,40 @@
+/**
+ * Upstream's documented default for `minForce`.
+ *
+ * A DOC COMMENT rather than a constant, and that is worth flagging: the `0.2`
+ * appears only in the JSDoc on `ForceTouchGestureConfig.minForce`
+ * (`src/handlers/ForceTouchGestureHandler.ts`), and no JavaScript in upstream
+ * assigns it — the real default lives in iOS code this repo cannot read. It is
+ * reproduced because a documented default is still upstream's answer, and
+ * inventing a different one would be a silent divergence.
+ */
+export const DEFAULT_MIN_FORCE = 0.2;
+export const forceTouchDecider = {
+    kind: "forceTouch",
+    // See the file header: the stylus gesture is not the pointer session, and a
+    // pressure report must not switch the native scroller off.
+    claimsResponder: false,
+    source: "stylus",
+    /**
+     * `maxForce` is a CEILING and exceeding it fails the gesture, which is
+     * upstream's documented behaviour ("If the pressure is greater, gesture
+     * fails"). Unset means no ceiling, which is upstream's shape too — there is
+     * no documented default for it.
+     */
+    shouldFail: (view, config) => config.maxForce !== undefined && view.force > config.maxForce,
+    /**
+     * Non-strict, matching every other activation threshold in this module: a
+     * value sitting exactly on the bound activates rather than misses. The
+     * asymmetry with `shouldFail`'s strict comparison above is the same one
+     * `Pan` has and is deliberate in both.
+     */
+    shouldActivate: (view, config) => view.force >= (config.minForce ?? DEFAULT_MIN_FORCE),
+    /**
+     * The ceiling keeps applying after activation, which is the same shape
+     * `LongPress`'s `maxDistance` has: pressing harder than `maxForce` is a
+     * cancellation of a gesture that was legitimately running, not a failure of
+     * one that never started.
+     */
+    shouldCancelWhileActive: (view, config) => config.maxForce !== undefined && view.force > config.maxForce,
+};
+//# sourceMappingURL=force-touch.js.map

package/dist/gesture-handler-compat/force-touch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"force-touch.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/force-touch.ts"],"names":[],"mappings":"AAoDA;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAG,CAAA;AAEpC,MAAM,CAAC,MAAM,iBAAiB,GAAsB;IAClD,IAAI,EAAE,YAAY;IAElB,4EAA4E;IAC5E,2DAA2D;IAC3D,eAAe,EAAE,KAAK;IACtB,MAAM,EAAE,QAAQ;IAEhB;;;;;OAKG;IACH,UAAU,EAAE,CAAC,IAAoB,EAAE,MAAwB,EAAW,EAAE,CACtE,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,QAAQ;IAE/D;;;;;OAKG;IACH,cAAc,EAAE,CAAC,IAAoB,EAAE,MAAwB,EAAW,EAAE,CAC1E,IAAI,CAAC,KAAK,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,iBAAiB,CAAC;IAEtD;;;;;OAKG;IACH,uBAAuB,EAAE,CACvB,IAAoB,EACpB,MAAwB,EACf,EAAE,CAAC,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,QAAQ;CAC5E,CAAA","sourcesContent":["// `Gesture.ForceTouch()` — pressure, which is the one input in this module\n// that no ordinary mouse can produce.\n//\n// READ THIS FIRST, because it is the honest label on the tin: **the pressure\n// path is the least verified thing in this module**, and how far short it\n// falls is recorded in docs/api.md rather than left to be discovered. Every\n// other recognizer here is driven end to end by injected input in the test\n// suite. This one is driven by `GtkGestureStylus`, which needs a tablet tool,\n// and what could and could not be produced for it is written down rather than\n// implied.\n//\n// UPSTREAM DOES NOT IMPLEMENT THIS OFF iOS AT ALL, which is worth stating\n// before anything else, because it means there is no web behaviour to restate\n// and the semantics below come from the documented contract rather than from a\n// running implementation:\n//\n//   - there is no `src/web/handlers/ForceTouchGestureHandler.ts`. The web\n//     `Gestures` registry has nine entries and this is not one of them, so\n//     `Gesture.ForceTouch()` under a `GestureDetector` on web throws\n//     `\"ForceTouchGestureHandler is not supported on web\"` at handler-creation\n//     time;\n//   - the LEGACY component is worse and is the failure mode this repo refuses\n//     by name: `PlatformConstants.forceTouchAvailable` is hardcoded false off\n//     iOS, so `ForceTouchGestureHandler` resolves to a `ForceTouchFallback`\n//     that logs one warning and renders its children unchanged — a component\n//     that accepts its props, mounts, and silently does nothing;\n//   - **there is no v3 hook.** `src/v3/hooks/gestures/` has nine directories\n//     and no `forceTouch`; `useForceTouchGesture` does not exist and the\n//     `SingleGesture` union omits ForceTouch entirely. Upstream dropped it\n//     from the API it is migrating to.\n//\n// So the config below is upstream's documented contract — `minForce` (docs say\n// 0.2), `maxForce` (a ceiling that FAILS the gesture), `feedbackOnActivation`\n// (haptics) — and the enforcement is this file's, because upstream's lives in\n// Swift outside its own JS tree. Where a number had to be chosen rather than\n// read, it is named here and in docs/api.md.\n//\n// WHERE THE PRESSURE COMES FROM. `GtkGestureStylus`, whose `down`/`motion`/\n// `up`/`proximity` signals carry a `getAxis(Gdk.AxisUse.PRESSURE)` returning\n// `[known, value]`, already normalised to `[0, 1]` by GDK — which is\n// upstream's documented range for `minForce`/`maxForce`, so nothing is\n// rescaled on the way in. `wl_pointer` has no pressure axis and never will;\n// the tablet protocol (`zwp_tablet_v2`) does, and a stylus is the only device\n// on this platform that can answer.\n//\n// IT NEVER TAKES THE RESPONDER, same as `Hover` and the touchpad kinds and for\n// a related reason: the stylus gesture is its own GTK sequence, not the\n// pointer session the responder lock arbitrates, and a gesture reporting\n// pressure has no business suspending the scrollers under it.\nimport type { RecognizerDecider, RecognizerView } from \"./recognizer\"\nimport type { RecognizerConfig } from \"./types\"\n\n/**\n * Upstream's documented default for `minForce`.\n *\n * A DOC COMMENT rather than a constant, and that is worth flagging: the `0.2`\n * appears only in the JSDoc on `ForceTouchGestureConfig.minForce`\n * (`src/handlers/ForceTouchGestureHandler.ts`), and no JavaScript in upstream\n * assigns it — the real default lives in iOS code this repo cannot read. It is\n * reproduced because a documented default is still upstream's answer, and\n * inventing a different one would be a silent divergence.\n */\nexport const DEFAULT_MIN_FORCE = 0.2\n\nexport const forceTouchDecider: RecognizerDecider = {\n  kind: \"forceTouch\",\n\n  // See the file header: the stylus gesture is not the pointer session, and a\n  // pressure report must not switch the native scroller off.\n  claimsResponder: false,\n  source: \"stylus\",\n\n  /**\n   * `maxForce` is a CEILING and exceeding it fails the gesture, which is\n   * upstream's documented behaviour (\"If the pressure is greater, gesture\n   * fails\"). Unset means no ceiling, which is upstream's shape too — there is\n   * no documented default for it.\n   */\n  shouldFail: (view: RecognizerView, config: RecognizerConfig): boolean =>\n    config.maxForce !== undefined && view.force > config.maxForce,\n\n  /**\n   * Non-strict, matching every other activation threshold in this module: a\n   * value sitting exactly on the bound activates rather than misses. The\n   * asymmetry with `shouldFail`'s strict comparison above is the same one\n   * `Pan` has and is deliberate in both.\n   */\n  shouldActivate: (view: RecognizerView, config: RecognizerConfig): boolean =>\n    view.force >= (config.minForce ?? DEFAULT_MIN_FORCE),\n\n  /**\n   * The ceiling keeps applying after activation, which is the same shape\n   * `LongPress`'s `maxDistance` has: pressing harder than `maxForce` is a\n   * cancellation of a gesture that was legitimately running, not a failure of\n   * one that never started.\n   */\n  shouldCancelWhileActive: (\n    view: RecognizerView,\n    config: RecognizerConfig,\n  ): boolean => config.maxForce !== undefined && view.force > config.maxForce,\n}\n"]}

package/dist/gesture-handler-compat/hooks.d.ts

@@ -0,0 +1,157 @@
+import type { AnyGestureSpec, ComposedGestureSpec, GestureEndEventPayload, GestureEventPayload, GestureHitSlop, GestureRef, GestureSpec, GestureTouchEvent, OffsetBound } from "./types";
+/**
+ * The relations, in the hook spelling's names.
+ *
+ * The same three lists the builder's three methods write, renamed and moved
+ * into the config object — `simultaneousWithExternalGesture` is
+ * `simultaneousWith`, `requireExternalGestureToFail` is `requireToFail`, and
+ * `blocksExternalGesture` is `block`. One gesture or several, because
+ * upstream accepts both and an app writing one should not have to wrap it.
+ */
+type RelationHookConfig = {
+    simultaneousWith?: GestureRef | GestureRef[];
+    requireToFail?: GestureRef | GestureRef[];
+    block?: GestureRef | GestureRef[];
+};
+/** What every hook spelling accepts, which is upstream's `CommonGestureConfig`. */
+type CommonGestureHookConfig = RelationHookConfig & {
+    enabled?: boolean;
+    hitSlop?: GestureHitSlop;
+    shouldCancelWhenOutside?: boolean;
+    manualActivation?: boolean;
+    runOnJS?: boolean;
+    testID?: string;
+    onBegin?: (event: GestureEventPayload) => void;
+    onActivate?: (event: GestureEventPayload) => void;
+    onDeactivate?: (event: GestureEndEventPayload) => void;
+    onFinalize?: (event: GestureEndEventPayload) => void;
+    onTouchesDown?: (event: GestureTouchEvent) => void;
+    onTouchesMove?: (event: GestureTouchEvent) => void;
+    onTouchesUp?: (event: GestureTouchEvent) => void;
+    onTouchesCancel?: (event: GestureTouchEvent) => void;
+};
+/** The config object `usePanGesture` accepts. */
+export type PanGestureHookConfig = CommonGestureHookConfig & {
+    activeOffsetX?: OffsetBound;
+    activeOffsetY?: OffsetBound;
+    failOffsetX?: OffsetBound;
+    failOffsetY?: OffsetBound;
+    minDistance?: number;
+    minVelocity?: number;
+    minVelocityX?: number;
+    minVelocityY?: number;
+    minPointers?: number;
+    maxPointers?: number;
+    activateAfterLongPress?: number;
+    /**
+     * Only a CONTINUOUS gesture has one. Upstream's discrete hooks omit
+     * `onUpdate` from their config type by name (`BaseDiscreteGestureConfig` is
+     * `Omit<…, "onUpdate">`), which is the same statement in the other
+     * direction.
+     */
+    onUpdate?: (event: GestureEventPayload) => void;
+};
+/** The config object `useTapGesture` accepts, in upstream's external names. */
+export type TapGestureHookConfig = CommonGestureHookConfig & {
+    numberOfTaps?: number;
+    maxDuration?: number;
+    maxDelay?: number;
+    maxDistance?: number;
+    maxDeltaX?: number;
+    maxDeltaY?: number;
+    minPointers?: number;
+};
+/** The config object `useLongPressGesture` accepts. */
+export type LongPressGestureHookConfig = CommonGestureHookConfig & {
+    minDuration?: number;
+    maxDistance?: number;
+    numberOfPointers?: number;
+};
+/** The config object `useNativeGesture` accepts. */
+export type NativeGestureHookConfig = CommonGestureHookConfig & {
+    shouldActivateOnStart?: boolean;
+    disallowInterruption?: boolean;
+    yieldsToContinuousGestures?: boolean;
+    /** A native view is continuous upstream, so it reports travel. */
+    onUpdate?: (event: GestureEventPayload) => void;
+};
+/**
+ * The config object `usePinchGesture` and `useRotationGesture` accept.
+ *
+ * Nothing of their own, and that is upstream's shape rather than an omission:
+ * `PinchGestureNativeProperties` and `RotationGestureNativeProperties` are
+ * both `Record<string, never>` in 3.1.0's `src/v3`, and the builder classes
+ * add no methods either. Both are continuous, so `onUpdate` is here.
+ */
+export type TouchpadGestureHookConfig = CommonGestureHookConfig & {
+    onUpdate?: (event: GestureEventPayload) => void;
+};
+/**
+ * The hook spelling. Rebuilds its spec every render, exactly as the builder
+ * chained in a component body does, because the callbacks it closes over are
+ * rebuilt every render too — `GestureDetector` reads the config through a ref
+ * rather than resubscribing, which is what makes that free.
+ */
+export declare const usePanGesture: (config?: PanGestureHookConfig) => GestureSpec;
+/**
+ * `useTapGesture`, the hook spelling of `Gesture.Tap()`.
+ *
+ * `shouldCancelWhenOutside` defaults to true here, matching the builder.
+ * Upstream's own hook does NOT do this even though its builder's constructor
+ * does and its native handler config does — `useLongPressGesture` remembers it
+ * (`transformLongPressProps`) and `useTapGesture` forgets. Two spellings of
+ * one gesture disagreeing about whether a press may wander off the view is a
+ * slip rather than a semantic, and reproducing it would make this module's own
+ * "two spellings, one implementation" claim false.
+ */
+export declare const useTapGesture: (config?: TapGestureHookConfig) => GestureSpec;
+/** `useLongPressGesture`, the hook spelling of `Gesture.LongPress()`. */
+export declare const useLongPressGesture: (config?: LongPressGestureHookConfig) => GestureSpec;
+/** `useNativeGesture`, the hook spelling of `Gesture.Native()`. */
+export declare const useNativeGesture: (config?: NativeGestureHookConfig) => GestureSpec;
+/**
+ * `usePinchGesture`, the hook spelling of `Gesture.Pinch()` — and the spelling
+ * upstream's own `@deprecated` tag on `Gesture.Pinch()` points at.
+ *
+ * `shouldCancelWhenOutside` defaults to FALSE, matching the builder and
+ * matching `PinchGestureHandler.init`: a pinch is not addressed to a point the
+ * way a tap is, and a focal point that drifts off the view mid-gesture is not
+ * a reason to cancel it.
+ */
+export declare const usePinchGesture: (config?: TouchpadGestureHookConfig) => GestureSpec;
+/** `useRotationGesture`, the hook spelling of `Gesture.Rotation()`. */
+export declare const useRotationGesture: (config?: TouchpadGestureHookConfig) => GestureSpec;
+/**
+ * The config object `useFlingGesture` accepts.
+ *
+ * No `onUpdate`, matching upstream: `FlingGestureInternalConfig` is a
+ * `BaseDiscreteGestureConfig`, which omits it by name. A fling activates and
+ * ends in one breath and has nothing to update with.
+ */
+export type FlingGestureHookConfig = CommonGestureHookConfig & {
+    direction?: number;
+    numberOfPointers?: number;
+};
+/** The config object `useManualGesture` accepts, which is only the common one. */
+export type ManualGestureHookConfig = CommonGestureHookConfig & {
+    onUpdate?: (event: GestureEventPayload) => void;
+};
+/** The config object `useHoverGesture` accepts. */
+export type HoverGestureHookConfig = CommonGestureHookConfig & {
+    /**
+     * iOS's own pointer effect. Upstream's hook maps `effect` onto the native
+     * `hoverEffect` prop; both names arrive at the same inert field here.
+     */
+    effect?: number;
+    onUpdate?: (event: GestureEventPayload) => void;
+};
+/** `useFlingGesture`, the hook spelling of `Gesture.Fling()`. */
+export declare const useFlingGesture: (config?: FlingGestureHookConfig) => GestureSpec;
+/** `useManualGesture`, the hook spelling of `Gesture.Manual()`. */
+export declare const useManualGesture: (config?: ManualGestureHookConfig) => GestureSpec;
+/** `useHoverGesture`, the hook spelling of `Gesture.Hover()`. */
+export declare const useHoverGesture: (config?: HoverGestureHookConfig) => GestureSpec;
+export declare const useCompetingGestures: (...gestures: AnyGestureSpec[]) => ComposedGestureSpec;
+export declare const useSimultaneousGestures: (...gestures: AnyGestureSpec[]) => ComposedGestureSpec;
+export declare const useExclusiveGestures: (...gestures: AnyGestureSpec[]) => ComposedGestureSpec;
+export {};