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

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

@@ -0,0 +1,111 @@
+// `Race`, `Simultaneous` and `Exclusive` — list-builders over the three
+// relation maps, and nothing else.
+//
+// This file is the evidence for a claim the recon made and this slice had to
+// either prove or withdraw: **composition is sugar**. There is no composed
+// state machine, no composed recognizer and no second arbitration path. Each
+// composer decides which references land in which of two maps, `prepare`
+// below writes them, and the loop in ./orchestrator reads exactly the same
+// maps it reads for a hand-written relation. If that were false, this file
+// would need a mechanism of its own; it needs none, and a test asserts that
+// a composition and the equivalent hand-written relations behave identically.
+//
+// None of the four measured consumers calls a composer
+// (docs/research/gesture-detector.md, probe 3). They are here because they are
+// cheap over the maps, not because anything is waiting on them.
+import { flattenGestures, isComposedGestureSpec, } from "./types";
+const prepareInto = (gesture, simultaneousWith, waitFor, out) => {
+    if (!isComposedGestureSpec(gesture)) {
+        out.push({
+            spec: gesture,
+            relations: {
+                // What the gesture asked for itself comes first, then what the
+                // composition adds. Built fresh rather than written back onto the
+                // config: upstream mutates the gesture object in `prepare()` and had
+                // to add a snapshot to stop the relations accumulating across renders
+                // (#3763). A composition that computes instead of mutating cannot
+                // accumulate anything.
+                simultaneousHandlers: [
+                    ...(gesture.config.simultaneousHandlers ?? []),
+                    ...simultaneousWith,
+                ],
+                waitFor: [...(gesture.config.waitFor ?? []), ...waitFor],
+                // `blocksHandlers` is deliberately NOT extended by any composer, and
+                // that is upstream's own note: reversing the order of two gestures in
+                // `Exclusive` already produces the same relation from the other end.
+                blocksHandlers: gesture.config.blocksHandlers ?? [],
+            },
+        });
+        return;
+    }
+    const members = gesture.gestures;
+    if (gesture.composed === "simultaneous") {
+        // Pairwise: each member becomes simultaneous with every OTHER member,
+        // flattened. Flattened and not composed-as-a-unit, because a member that
+        // is itself an `Exclusive` group must not have its own members made
+        // simultaneous with each other — that would undo the exclusivity it was
+        // written to express.
+        members.forEach((member, index) => {
+            const others = members
+                .filter((_, other) => other !== index)
+                .flatMap(flattenGestures);
+            prepareInto(member, [...simultaneousWith, ...others], waitFor, out);
+        });
+        return;
+    }
+    if (gesture.composed === "exclusive") {
+        // A chain: every group waits for all the groups before it. So the first
+        // one written wins if it can, and the last is the fallback — which is the
+        // ordering `Gesture.Exclusive(doubleTap, singleTap)` reads as.
+        let earlier = [];
+        for (const member of members) {
+            prepareInto(member, simultaneousWith, [...waitFor, ...earlier], out);
+            earlier = [...earlier, ...flattenGestures(member)];
+        }
+        return;
+    }
+    // `Race` adds nothing at all. It is the default — mutual exclusion between
+    // gestures that share the interaction is what the loop does with no
+    // relations recorded — so composing with it changes precisely one thing:
+    // the gestures end up on the same detector.
+    for (const member of members) {
+        prepareInto(member, simultaneousWith, waitFor, out);
+    }
+};
+/**
+ * Flattens a gesture or a composition into the recognizers a detector has to
+ * mount, each with the relations composition gave it.
+ */
+export const prepareGestures = (gesture) => {
+    const prepared = [];
+    prepareInto(gesture, [], [], prepared);
+    return prepared;
+};
+const compose = (composed, gestures) => {
+    const flattened = gestures.flatMap(flattenGestures);
+    if (new Set(flattened).size !== flattened.length) {
+        // Upstream throws here too, and the reason is worth keeping: the same
+        // gesture in two arms of one composition would be asked to be both
+        // simultaneous with itself and to wait for itself, and the maps have no
+        // way to say which was meant.
+        throw new Error("react-native-gtkx: each gesture can be used only once in a gesture composition.");
+    }
+    return {
+        composed,
+        gestures,
+        toGestureArray: () => flattened,
+    };
+};
+/**
+ * `Gesture.Race()` — the default, spelled out.
+ *
+ * Upstream's hook spelling calls this `useCompetingGestures`, which is the
+ * better name for it: the gestures compete, the first to activate cancels the
+ * rest, and that would have happened anyway.
+ */
+export const raceGestures = (...gestures) => compose("race", gestures);
+/** `Gesture.Simultaneous()` — a pairwise fill of `simultaneousHandlers`. */
+export const simultaneousGestures = (...gestures) => compose("simultaneous", gestures);
+/** `Gesture.Exclusive()` — a chain fill of `waitFor`. */
+export const exclusiveGestures = (...gestures) => compose("exclusive", gestures);
+//# sourceMappingURL=composition.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"composition.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/composition.ts"],"names":[],"mappings":"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","sourcesContent":["// `Race`, `Simultaneous` and `Exclusive` — list-builders over the three\n// relation maps, and nothing else.\n//\n// This file is the evidence for a claim the recon made and this slice had to\n// either prove or withdraw: **composition is sugar**. There is no composed\n// state machine, no composed recognizer and no second arbitration path. Each\n// composer decides which references land in which of two maps, `prepare`\n// below writes them, and the loop in ./orchestrator reads exactly the same\n// maps it reads for a hand-written relation. If that were false, this file\n// would need a mechanism of its own; it needs none, and a test asserts that\n// a composition and the equivalent hand-written relations behave identically.\n//\n// None of the four measured consumers calls a composer\n// (docs/research/gesture-detector.md, probe 3). They are here because they are\n// cheap over the maps, not because anything is waiting on them.\nimport {\n  flattenGestures,\n  isComposedGestureSpec,\n  type AnyGestureSpec,\n  type ComposedGestureKind,\n  type ComposedGestureSpec,\n  type GestureRef,\n  type GestureRelations,\n  type GestureSpec,\n} from \"./types\"\n\n/** One recognizer, with the relations it ends up with once composed. */\nexport type PreparedGesture = {\n  spec: GestureSpec\n  relations: GestureRelations\n}\n\nconst prepareInto = (\n  gesture: AnyGestureSpec,\n  simultaneousWith: readonly GestureRef[],\n  waitFor: readonly GestureRef[],\n  out: PreparedGesture[],\n): void => {\n  if (!isComposedGestureSpec(gesture)) {\n    out.push({\n      spec: gesture,\n      relations: {\n        // What the gesture asked for itself comes first, then what the\n        // composition adds. Built fresh rather than written back onto the\n        // config: upstream mutates the gesture object in `prepare()` and had\n        // to add a snapshot to stop the relations accumulating across renders\n        // (#3763). A composition that computes instead of mutating cannot\n        // accumulate anything.\n        simultaneousHandlers: [\n          ...(gesture.config.simultaneousHandlers ?? []),\n          ...simultaneousWith,\n        ],\n        waitFor: [...(gesture.config.waitFor ?? []), ...waitFor],\n        // `blocksHandlers` is deliberately NOT extended by any composer, and\n        // that is upstream's own note: reversing the order of two gestures in\n        // `Exclusive` already produces the same relation from the other end.\n        blocksHandlers: gesture.config.blocksHandlers ?? [],\n      },\n    })\n    return\n  }\n\n  const members = gesture.gestures\n\n  if (gesture.composed === \"simultaneous\") {\n    // Pairwise: each member becomes simultaneous with every OTHER member,\n    // flattened. Flattened and not composed-as-a-unit, because a member that\n    // is itself an `Exclusive` group must not have its own members made\n    // simultaneous with each other — that would undo the exclusivity it was\n    // written to express.\n    members.forEach((member, index) => {\n      const others = members\n        .filter((_, other) => other !== index)\n        .flatMap(flattenGestures)\n      prepareInto(member, [...simultaneousWith, ...others], waitFor, out)\n    })\n    return\n  }\n\n  if (gesture.composed === \"exclusive\") {\n    // A chain: every group waits for all the groups before it. So the first\n    // one written wins if it can, and the last is the fallback — which is the\n    // ordering `Gesture.Exclusive(doubleTap, singleTap)` reads as.\n    let earlier: GestureSpec[] = []\n    for (const member of members) {\n      prepareInto(member, simultaneousWith, [...waitFor, ...earlier], out)\n      earlier = [...earlier, ...flattenGestures(member)]\n    }\n    return\n  }\n\n  // `Race` adds nothing at all. It is the default — mutual exclusion between\n  // gestures that share the interaction is what the loop does with no\n  // relations recorded — so composing with it changes precisely one thing:\n  // the gestures end up on the same detector.\n  for (const member of members) {\n    prepareInto(member, simultaneousWith, waitFor, out)\n  }\n}\n\n/**\n * Flattens a gesture or a composition into the recognizers a detector has to\n * mount, each with the relations composition gave it.\n */\nexport const prepareGestures = (gesture: AnyGestureSpec): PreparedGesture[] => {\n  const prepared: PreparedGesture[] = []\n  prepareInto(gesture, [], [], prepared)\n  return prepared\n}\n\nconst compose = (\n  composed: ComposedGestureKind,\n  gestures: readonly AnyGestureSpec[],\n): ComposedGestureSpec => {\n  const flattened = gestures.flatMap(flattenGestures)\n  if (new Set(flattened).size !== flattened.length) {\n    // Upstream throws here too, and the reason is worth keeping: the same\n    // gesture in two arms of one composition would be asked to be both\n    // simultaneous with itself and to wait for itself, and the maps have no\n    // way to say which was meant.\n    throw new Error(\n      \"react-native-gtkx: each gesture can be used only once in a gesture composition.\",\n    )\n  }\n  return {\n    composed,\n    gestures,\n    toGestureArray: () => flattened,\n  }\n}\n\n/**\n * `Gesture.Race()` — the default, spelled out.\n *\n * Upstream's hook spelling calls this `useCompetingGestures`, which is the\n * better name for it: the gestures compete, the first to activate cancels the\n * rest, and that would have happened anyway.\n */\nexport const raceGestures = (\n  ...gestures: AnyGestureSpec[]\n): ComposedGestureSpec => compose(\"race\", gestures)\n\n/** `Gesture.Simultaneous()` — a pairwise fill of `simultaneousHandlers`. */\nexport const simultaneousGestures = (\n  ...gestures: AnyGestureSpec[]\n): ComposedGestureSpec => compose(\"simultaneous\", gestures)\n\n/** `Gesture.Exclusive()` — a chain fill of `waitFor`. */\nexport const exclusiveGestures = (\n  ...gestures: AnyGestureSpec[]\n): ComposedGestureSpec => compose(\"exclusive\", gestures)\n"]}

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

@@ -0,0 +1,3 @@
+import type { RecognizerDecider } from "./recognizer";
+import type { GestureKind } from "./types";
+export declare const DECIDERS: Record<GestureKind, RecognizerDecider>;

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

@@ -0,0 +1,47 @@
+// Which pair of predicates the one machine runs, per kind.
+//
+// The whole of what tells the four kinds apart. There is no second state
+// machine, no second event stream and no second grant channel —
+// `docs/research/gesture-detector.md` predicted that `Tap` and `LongPress`
+// would be an afternoon over slice 1's core, and this map is the shape of that
+// claim.
+//
+// `Native` stretched it by exactly one flag rather than one machine: it wants
+// the same progression without the responder grant, because taking the
+// interaction is the one thing a gesture that stands for the native widget
+// must not do. See ./native and `RecognizerDecider.claimsResponder`.
+//
+// Its own file, and free of every platform import, so a test can mount a
+// recognizer of any kind without pulling in GTK — which is what lets the
+// arbitration tests drive several real recognizers off Linux.
+import { flingDecider } from "./fling";
+import { forceTouchDecider } from "./force-touch";
+import { hoverDecider } from "./hover";
+import { longPressDecider } from "./long-press";
+import { manualDecider } from "./manual";
+import { nativeDecider } from "./native";
+import { panDecider } from "./pan";
+import { tapDecider } from "./tap";
+import { pinchDecider, rotationDecider } from "./touchpad";
+export const DECIDERS = {
+    pan: panDecider,
+    tap: tapDecider,
+    longPress: longPressDecider,
+    native: nativeDecider,
+    // Two predicates each and a `source`, which is the whole of what slice 5
+    // added to the machine: `Pinch` and `Rotation` are fed by GTK because a
+    // touchpad pinch is not in the pointer stream, and are otherwise ordinary.
+    pinch: pinchDecider,
+    rotation: rotationDecider,
+    // The last four, and the map is the evidence for the claim the epic has been
+    // making since slice 2: ten recognizers, one state machine. Each of these
+    // is a pair of predicates and at most two flags —
+    // `Fling` adds `endsOnActivate`, `Manual` adds a release outcome that
+    // decides nothing, `Hover` and `ForceTouch` add a `source`. None of them
+    // adds a state, an event stream, a grant channel or an arbitration rule.
+    fling: flingDecider,
+    manual: manualDecider,
+    hover: hoverDecider,
+    forceTouch: forceTouchDecider,
+};
+//# sourceMappingURL=deciders.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deciders.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/deciders.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,EAAE;AACF,yEAAyE;AACzE,gEAAgE;AAChE,2EAA2E;AAC3E,+EAA+E;AAC/E,SAAS;AACT,EAAE;AACF,8EAA8E;AAC9E,uEAAuE;AACvE,2EAA2E;AAC3E,qEAAqE;AACrE,EAAE;AACF,yEAAyE;AACzE,yEAAyE;AACzE,8DAA8D;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAA;AAElC,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAA;AAClC,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAG1D,MAAM,CAAC,MAAM,QAAQ,GAA2C;IAC9D,GAAG,EAAE,UAAU;IACf,GAAG,EAAE,UAAU;IACf,SAAS,EAAE,gBAAgB;IAC3B,MAAM,EAAE,aAAa;IACrB,yEAAyE;IACzE,wEAAwE;IACxE,2EAA2E;IAC3E,KAAK,EAAE,YAAY;IACnB,QAAQ,EAAE,eAAe;IACzB,6EAA6E;IAC7E,0EAA0E;IAC1E,kDAAkD;IAClD,sEAAsE;IACtE,yEAAyE;IACzE,yEAAyE;IACzE,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,aAAa;IACrB,KAAK,EAAE,YAAY;IACnB,UAAU,EAAE,iBAAiB;CAC9B,CAAA","sourcesContent":["// Which pair of predicates the one machine runs, per kind.\n//\n// The whole of what tells the four kinds apart. There is no second state\n// machine, no second event stream and no second grant channel —\n// `docs/research/gesture-detector.md` predicted that `Tap` and `LongPress`\n// would be an afternoon over slice 1's core, and this map is the shape of that\n// claim.\n//\n// `Native` stretched it by exactly one flag rather than one machine: it wants\n// the same progression without the responder grant, because taking the\n// interaction is the one thing a gesture that stands for the native widget\n// must not do. See ./native and `RecognizerDecider.claimsResponder`.\n//\n// Its own file, and free of every platform import, so a test can mount a\n// recognizer of any kind without pulling in GTK — which is what lets the\n// arbitration tests drive several real recognizers off Linux.\nimport { flingDecider } from \"./fling\"\nimport { forceTouchDecider } from \"./force-touch\"\nimport { hoverDecider } from \"./hover\"\nimport { longPressDecider } from \"./long-press\"\nimport { manualDecider } from \"./manual\"\nimport { nativeDecider } from \"./native\"\nimport { panDecider } from \"./pan\"\nimport type { RecognizerDecider } from \"./recognizer\"\nimport { tapDecider } from \"./tap\"\nimport { pinchDecider, rotationDecider } from \"./touchpad\"\nimport type { GestureKind } from \"./types\"\n\nexport const DECIDERS: Record<GestureKind, RecognizerDecider> = {\n  pan: panDecider,\n  tap: tapDecider,\n  longPress: longPressDecider,\n  native: nativeDecider,\n  // Two predicates each and a `source`, which is the whole of what slice 5\n  // added to the machine: `Pinch` and `Rotation` are fed by GTK because a\n  // touchpad pinch is not in the pointer stream, and are otherwise ordinary.\n  pinch: pinchDecider,\n  rotation: rotationDecider,\n  // The last four, and the map is the evidence for the claim the epic has been\n  // making since slice 2: ten recognizers, one state machine. Each of these\n  // is a pair of predicates and at most two flags —\n  // `Fling` adds `endsOnActivate`, `Manual` adds a release outcome that\n  // decides nothing, `Hover` and `ForceTouch` add a `source`. None of them\n  // adds a state, an event stream, a grant channel or an arbitration rule.\n  fling: flingDecider,\n  manual: manualDecider,\n  hover: hoverDecider,\n  forceTouch: forceTouchDecider,\n}\n"]}

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

@@ -0,0 +1,44 @@
+import { type Gtk as GtkNs } from "../gtkx/bridge/index";
+import type { GestureResponderEvent } from "../responder/types";
+import type { PreparedGesture } from "./composition";
+import { type Recognizer } from "./recognizer";
+import { type GestureKind, type GestureSpec } from "./types";
+/** The two responder props that answer a question rather than take an event. */
+export declare const PREDICATES: Set<string>;
+/** A ref in either of React's two spellings. */
+type AnyRef = ((instance: unknown) => void) | {
+    current: unknown;
+} | null | undefined;
+type Mounted = {
+    /** The spec object this recognizer currently drives; rebound every render. */
+    spec: GestureSpec;
+    readonly kind: GestureKind;
+    readonly tag: number;
+    readonly recognizer: Recognizer;
+    /**
+     * The GTK controller feeding a kind the pointer stream cannot — a `Pinch`, a
+     * `Rotation`, a `Hover` or a `ForceTouch` — once the child has produced a
+     * widget to attach it to. Null for every pointer kind, and null until then:
+     * the child's ref lands before this parent's layout effect, but a child that
+     * carries no widget at all never gets one.
+     *
+     * Typed as the base controller rather than as `Gesture`, because `Hover`'s
+     * is a `GtkEventControllerMotion` and that is not a gesture at all.
+     */
+    controller: GtkNs.EventController | null;
+};
+export type DetectorRuntime = {
+    /** The recognizer props to merge into the child. Stable for the mount. */
+    handlers: Record<string, (event: GestureResponderEvent) => boolean | void>;
+    /** The callback ref to put on the child. Stable for the detector's life. */
+    assignHandle: (instance: unknown) => void;
+    /** Called from a layout effect on every render. */
+    sync: (prepared: readonly PreparedGesture[], forwarded: AnyRef) => void;
+    /** Warns once if the child turned out to carry no widget. */
+    checkWidget: () => void;
+    /** Every mounted recognizer, in the order the gestures were written. */
+    gestures: () => readonly Mounted[];
+    dispose: () => void;
+};
+export declare const createDetectorRuntime: () => DetectorRuntime;
+export {};

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

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