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

package/dist/responder/system.js

@@ -0,0 +1,304 @@
+import { createTouchHistory, recordTouchEnd, recordTouchMove, recordTouchStart, refreshActiveTouches, } from "./touch-history";
+export const createResponderSystem = (options) => {
+    const registry = new Map();
+    const history = createTouchHistory();
+    let responder = null;
+    let session = null;
+    /**
+     * The registered nodes from the toplevel down to `host`, root first — RN's
+     * capture order, reversed for bubble.
+     *
+     * The walk stops wherever `parentOf` stops, which on this platform is the
+     * layout Root: an RN tree here is an island inside a native GTK widget
+     * tree (NestedRoot/IntrinsicRoot mount engines into arbitrary GTK slots),
+     * so there is no single app-wide view hierarchy to traverse. Native
+     * widgets on the way up are simply not registered and take no part.
+     */
+    const pathOf = (host) => {
+        const path = [];
+        let current = host;
+        while (current) {
+            if (registry.has(current)) {
+                path.unshift(current);
+            }
+            current = options.parentOf(current);
+        }
+        return path;
+    };
+    const propsOf = (host) => registry.get(host)?.getProps() ?? null;
+    const createEvent = (touch, stillDown) => ({
+        nativeEvent: {
+            ...touch,
+            // Single-pointer: `touches` is the still-active set (empty once the
+            // pointer is up), `changedTouches` is always this one.
+            touches: stillDown ? [touch] : [],
+            changedTouches: [touch],
+        },
+        touchHistory: history,
+    });
+    /**
+     * Runs a should-set handler over `path` in order, stopping at the first
+     * that returns true — RN's executeDispatchesInOrderStopAtTrue. Handlers
+     * before the winner all run, which PanResponder depends on: its capture
+     * handlers are where gestureState is initialised and where dx/dy are
+     * accumulated on move.
+     */
+    const firstToClaim = (path, name, event) => {
+        for (const host of path) {
+            const handler = propsOf(host)?.[name];
+            if (handler?.(event) === true) {
+                return host;
+            }
+        }
+        return null;
+    };
+    const notify = (host, name, event) => {
+        propsOf(host)?.[name]?.(event);
+    };
+    const dispatchTouch = (path, captureName, bubbleName, event) => {
+        for (const host of path) {
+            propsOf(host)?.[captureName]?.(event);
+        }
+        for (let i = path.length - 1; i >= 0; i -= 1) {
+            propsOf(path[i])?.[bubbleName]?.(event);
+        }
+    };
+    const grant = (host, event) => {
+        responder = host;
+        notify(host, "onResponderGrant", event);
+        // The GTK claim is per INTERACTION, not per grant: a transfer moves a JS
+        // lock, and there is nothing left to tell GTK once the sequence is
+        // already ours. Claiming again on the new holder's own gesture would
+        // deny the sequence on the source below it and silently end the drag.
+        if (session && !session.claimed) {
+            session.claimed = true;
+            options.onClaim?.(session.host);
+        }
+    };
+    /**
+     * The negotiation path when someone already holds the responder: RN prunes
+     * it to the lowest common ancestor of the holder and the event target, and
+     * then skips the holder itself so it is never asked whether it wants what
+     * it already has. Pruning is what makes the lock transferable only
+     * UPWARDS — a descendant of the holder is not on the pruned path and
+     * cannot take it, which is RN's documented rule.
+     *
+     * Returns null when the two paths are disjoint (RNW's `lowestCommonAncestor
+     * == null`): nothing may take the responder in that case.
+     */
+    const pruneToAncestors = (path, holder) => {
+        const holderPath = pathOf(holder);
+        let common = -1;
+        const shared = Math.min(path.length, holderPath.length);
+        for (let i = 0; i < shared && path[i] === holderPath[i]; i += 1) {
+            common = i;
+        }
+        if (common === -1) {
+            return null;
+        }
+        return path.slice(0, path[common] === holder ? common : common + 1);
+    };
+    /**
+     * RN's handoff, in react-native-web's order: ask the holder, then
+     * terminate it, then grant. (Upstream's ResponderEventPlugin dispatches
+     * the grant BEFORE asking, so a rejected candidate still sees
+     * `onResponderGrant` — a quirk of the pooled-event implementation rather
+     * than of the model. RN's own documentation diagram, which RNW reproduces
+     * verbatim, shows TerminationRequest -> GRANT, and that is what we do.)
+     *
+     * A holder with no `onResponderTerminationRequest` always yields: absent
+     * means "sure", in RN and in RNW alike.
+     */
+    const attemptTransfer = (winner, event) => {
+        const holder = responder;
+        if (holder === null) {
+            grant(winner, event);
+            return;
+        }
+        if (holder === winner) {
+            return;
+        }
+        if (propsOf(holder)?.onResponderTerminationRequest?.(event) === false) {
+            notify(winner, "onResponderReject", event);
+            return;
+        }
+        notify(holder, "onResponderTerminate", event);
+        responder = null;
+        grant(winner, event);
+    };
+    /**
+     * Capture root-to-target, then bubble target-to-root — RN's two-phase
+     * negotiation, and the one place GTK's model and RN's agree, since GTK's
+     * CAPTURE/TARGET/BUBBLE phases run in exactly this order. We still do the
+     * walk ourselves so a single GTK event source can drive the whole path.
+     */
+    const negotiate = (path, event, phase) => {
+        const capture = phase === "start"
+            ? "onStartShouldSetResponderCapture"
+            : "onMoveShouldSetResponderCapture";
+        const bubble = phase === "start"
+            ? "onStartShouldSetResponder"
+            : "onMoveShouldSetResponder";
+        const captured = firstToClaim(path, capture, event);
+        if (captured) {
+            return captured;
+        }
+        return firstToClaim([...path].reverse(), bubble, event);
+    };
+    /**
+     * The whole negotiation for one event: prune the path if the lock is held,
+     * ask who wants it, hand it over. Returns nothing — the caller reads
+     * `responder` afterwards, because RN dispatches `onResponderStart`/`Move`
+     * to whoever holds the lock AFTER the handoff, not before it.
+     */
+    const negotiateAndTransfer = (path, event, phase) => {
+        const holder = responder;
+        const candidates = holder === null ? path : pruneToAncestors(path, holder);
+        if (candidates === null || candidates.length === 0) {
+            return;
+        }
+        const winner = negotiate(candidates, event, phase);
+        if (winner) {
+            attemptTransfer(winner, event);
+        }
+    };
+    const finish = (touch, terminated, touchProps) => {
+        const current = session;
+        if (!current) {
+            return;
+        }
+        recordTouchEnd(history, touch);
+        refreshActiveTouches(history);
+        const event = createEvent(touch, false);
+        dispatchTouch(pathOf(current.host), touchProps[0], touchProps[1], event);
+        const holder = responder;
+        session = null;
+        responder = null;
+        if (holder) {
+            notify(holder, "onResponderEnd", event);
+            notify(holder, terminated ? "onResponderTerminate" : "onResponderRelease", event);
+        }
+    };
+    return {
+        register(host, getProps) {
+            registry.set(host, { getProps });
+            return () => {
+                registry.delete(host);
+                // A responder that unmounts mid-gesture cannot be asked anything
+                // ever again; drop the lock rather than stranding it.
+                if (responder === host) {
+                    responder = null;
+                }
+                if (session?.host === host) {
+                    session = null;
+                }
+            };
+        },
+        touchStart(host, touch) {
+            // Already tracking this press: this is an ancestor's gesture seeing the
+            // same event through GTK's bubble chain.
+            if (session !== null) {
+                return;
+            }
+            session = {
+                host,
+                identifier: touch.identifier,
+                lastTouch: touch,
+                claimed: false,
+            };
+            recordTouchStart(history, touch);
+            refreshActiveTouches(history);
+            const path = pathOf(host);
+            const event = createEvent(touch, true);
+            dispatchTouch(path, "onTouchStartCapture", "onTouchStart", event);
+            negotiateAndTransfer(path, event, "start");
+            // RN dispatches this to whoever holds the lock once the handoff is
+            // over, which is why it is not folded into grant(): a view granted on
+            // a MOVE must not be told the interaction just started.
+            if (responder !== null) {
+                notify(responder, "onResponderStart", event);
+            }
+        },
+        touchMove(host, touch) {
+            if (session === null || session.host !== host) {
+                return;
+            }
+            session.lastTouch = touch;
+            recordTouchMove(history, touch);
+            refreshActiveTouches(history);
+            const path = pathOf(host);
+            const event = createEvent(touch, true);
+            dispatchTouch(path, "onTouchMoveCapture", "onTouchMove", event);
+            // Two shapes go through here. Nobody holds the lock yet: the common
+            // PanResponder one, where the pan starts once
+            // onMoveShouldSetPanResponder sees enough movement. Somebody does: an
+            // ancestor may still take it over, and the move is then delivered to
+            // whoever ends up holding it — including in the same event as the
+            // handoff, exactly as RN's own state diagram shows.
+            negotiateAndTransfer(path, event, "move");
+            if (responder !== null) {
+                notify(responder, "onResponderMove", event);
+            }
+        },
+        touchEnd(host, touch) {
+            if (session === null || session.host !== host) {
+                return;
+            }
+            finish(touch, false, ["onTouchEndCapture", "onTouchEnd"]);
+        },
+        touchCancel(host, touch) {
+            if (session === null || session.host !== host) {
+                return;
+            }
+            finish(touch, true, ["onTouchCancelCapture", "onTouchCancel"]);
+        },
+        terminate(reason) {
+            const current = session;
+            const holder = responder;
+            if (current === null || holder === null) {
+                // Nothing holds the lock: an ancestor scrolling or a menu opening is
+                // then simply an ancestor scrolling or a menu opening. RN terminates
+                // a RESPONDER; it has nothing to say when there is not one.
+                return false;
+            }
+            const event = createEvent(current.lastTouch, false);
+            if (reason === "scroll" &&
+                propsOf(holder)?.onResponderTerminationRequest?.(event) === false) {
+                return false;
+            }
+            // No onResponderEnd here, and that is RN's shape rather than an
+            // oversight: End pairs with a touch actually ending. A termination
+            // that is not a pointer event goes straight to Terminate.
+            recordTouchEnd(history, current.lastTouch);
+            refreshActiveTouches(history);
+            session = null;
+            responder = null;
+            notify(holder, "onResponderTerminate", event);
+            return true;
+        },
+        requestResponder(host) {
+            const current = session;
+            if (current === null) {
+                // No interaction to take. A timer that fires after the pointer is up
+                // is a timer that lost, and there is nothing to negotiate over.
+                return false;
+            }
+            if (responder === host) {
+                return true;
+            }
+            const path = pathOf(current.host);
+            // A node off the interaction's path is not a candidate — the same rule
+            // the touch paths enforce by construction, stated here because this
+            // entry point is reached from a timer rather than from an event that
+            // already travelled the tree.
+            if (!path.includes(host)) {
+                return false;
+            }
+            negotiateAndTransfer(path, createEvent(current.lastTouch, true), "move");
+            return responder === host;
+        },
+        getResponder: () => responder,
+        getSource: () => session?.host ?? null,
+    };
+};
+//# sourceMappingURL=system.js.map

package/dist/responder/system.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.js","sourceRoot":"","sources":["../../src/responder/system.ts"],"names":[],"mappings":"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","sourcesContent":["// RN's Gesture Responder System: the negotiation, in pure JS.\n//\n// Zero @gtkx imports on purpose. Everything platform-specific enters through\n// two seams — `parentOf`, which turns a host handle into its parent, and\n// `onClaim`, the one-way GTK declaration the platform makes once per\n// interaction. That keeps the algorithm unit-testable off Linux, which\n// matters because this is the part that is subtle and the part every\n// platform historically gets wrong.\n//\n// Why reimplemented rather than reused: every other RN platform feeds\n// `topTouchStart/Move/End/Cancel` to the stock renderer's\n// ResponderEventPlugin, which lives in `facebook/react` inside\n// `react-native-renderer`. We render through `@gtkx/react` on\n// `react-reconciler`, so there is no plugin seam to feed —\n// react-native-web is in the same position and reimplemented for the same\n// reason (docs/research/gestures.md).\nimport type { NativeTouch } from \"../components/press-event\"\nimport {\n  createTouchHistory,\n  recordTouchEnd,\n  recordTouchMove,\n  recordTouchStart,\n  refreshActiveTouches,\n} from \"./touch-history\"\nimport type { GestureResponderEvent, ResponderProps } from \"./types\"\n\n/** An opaque platform handle. A Gtk.Widget in practice; never treated as one. */\nexport type ResponderHost = object\n\n/**\n * Why the responder was taken away by something that is not a pointer event.\n *\n * react-native-web's list is longer — cancel-ish events, context menu,\n * window blur, ancestor scroll, selection change — and measuring GTK\n * collapsed most of it. GTK cancels a single-button gesture the instant a\n * second button goes down, and a widget that steals a sequence (a\n * selectable label, a `GtkDragSource` attached through `Controllers`)\n * cancels it too, so \"context menu\" and \"selection change\" both arrive as\n * an ordinary `::cancel` on the event source and need no trigger of their\n * own. What is left needs asking for:\n *\n * - `\"blur\"`: the toplevel stopped being the active window. Not a question,\n *   in RN or here — the window is gone either way.\n * - `\"scroll\"`: an ancestor scroller moved under the gesture. The one\n *   termination a holder may refuse, and therefore the only place\n *   `onResponderTerminationRequest` is consulted outside a transfer (PRD\n *   crux 2: GTK's `CLAIMED` is irrevocable, so anything GTK has already\n *   taken cannot be given back no matter what the holder answers).\n */\nexport type TerminationReason = \"blur\" | \"scroll\"\n\nexport type ResponderSystemOptions = {\n  /** The platform's parent link. Returning null ends the path. */\n  parentOf: (host: ResponderHost) => ResponderHost | null\n  /**\n   * Fired at most ONCE per interaction, the first time any node is granted\n   * the responder — where the platform makes its GTK `CLAIMED` declaration.\n   *\n   * Its argument is the node whose event source is carrying the interaction,\n   * NOT the node that won the responder. Those differ whenever an ancestor\n   * claims (the common `onMoveShouldSetPanResponder` shape), and claiming on\n   * the ancestor is actively wrong: GTK denies the sequence on every gesture\n   * below the one that claims, which kills the very source the interaction\n   * is arriving through. What GTK is being told is \"this interaction belongs\n   * to React Native, native widgets keep off\" — a statement about the\n   * island, not about which view inside it currently holds the lock, which\n   * is a JS matter GTK has no way to represent.\n   *\n   * One-way by construction: GTK has no way to hand a claimed sequence back,\n   * so this only ever runs once JS has already decided (see\n   * docs/research/gestures.md, \"no voluntary release\").\n   */\n  onClaim?: (source: ResponderHost) => void\n}\n\ntype Registration = { getProps: () => ResponderProps }\n\n// One interaction, from press to release. v1 is single-pointer: a mouse is\n// one fabricated touch, so at most one session exists at a time. It also\n// does the deduplicating — GTK delivers a press to every ancestor's gesture\n// in the bubble chain, so the second and later reports for the same press\n// find a session already open and return.\n//\n// `lastTouch` exists for termination: a window losing focus is not a pointer\n// event, and `onResponderTerminate` still has to be handed an RN-shaped\n// event. The last known position is what RN reports there too.\ntype Session = {\n  host: ResponderHost\n  identifier: number\n  lastTouch: NativeTouch\n  claimed: boolean\n}\n\nexport type ResponderSystem = {\n  register(host: ResponderHost, getProps: () => ResponderProps): () => void\n  touchStart(host: ResponderHost, touch: NativeTouch): void\n  touchMove(host: ResponderHost, touch: NativeTouch): void\n  touchEnd(host: ResponderHost, touch: NativeTouch): void\n  touchCancel(host: ResponderHost, touch: NativeTouch): void\n  /**\n   * Something that is not a pointer event took the interaction. Returns\n   * whether the responder was actually given up — `false` means either\n   * nothing held it or the holder refused a reason that allows refusal.\n   */\n  terminate(reason: TerminationReason): boolean\n  /**\n   * THE OUT-OF-EVENT GRANT CHANNEL. A registered node asks for the responder\n   * between touch events, and the ordinary negotiation runs against a\n   * synthesized event at the last known pointer position.\n   *\n   * RN negotiates inside touch events only, so a recognizer that changes its\n   * mind on a TIMER has no way to take the interaction until the pointer next\n   * moves. `activateAfterLongPress` is exactly that recognizer: the press\n   * matures while the pointer is still, and waiting for the next move puts\n   * the \"lifted\" visual one frame late — or, for a press-and-hold that never\n   * moves again, never.\n   *\n   * The precedent is react-native-web, which added\n   * `onScrollShouldSetResponder` and `onSelectionChangeShouldSetResponder`\n   * for its own platform's realities; extending the model where the platform\n   * demands it is recorded as acceptable in docs/research/gestures.md, and\n   * this channel is documented there with its reason.\n   *\n   * Deliberately NOT a new prop and not a new grant path: it reuses\n   * `negotiateAndTransfer` unchanged, so capture still beats bubble, the LCA\n   * pruning still applies, and an ancestor that wants the interaction still\n   * wins it. The only thing that is new is WHEN the question gets asked. The\n   * synthesized event is the same one `terminate()` already builds from\n   * `session.lastTouch`, for the same reason.\n   *\n   * No `onResponderMove` is dispatched afterwards: the pointer did not move,\n   * and inventing a move to announce a grant would put a fabricated\n   * coordinate into every consumer's translation arithmetic.\n   *\n   * Returns whether `host` holds the responder once the negotiation is over\n   * — `false` when there is no interaction, when `host` is not on the path\n   * the interaction is travelling, or when somebody else won.\n   */\n  requestResponder(host: ResponderHost): boolean\n  /** The node currently holding the responder, or null. */\n  getResponder(): ResponderHost | null\n  /** The node whose event source is carrying the interaction, or null. */\n  getSource(): ResponderHost | null\n}\n\ntype ShouldSetName =\n  | \"onStartShouldSetResponder\"\n  | \"onStartShouldSetResponderCapture\"\n  | \"onMoveShouldSetResponder\"\n  | \"onMoveShouldSetResponderCapture\"\n\ntype NotifyName =\n  | \"onResponderGrant\"\n  | \"onResponderStart\"\n  | \"onResponderMove\"\n  | \"onResponderEnd\"\n  | \"onResponderRelease\"\n  | \"onResponderTerminate\"\n  | \"onResponderReject\"\n\ntype TouchName =\n  | \"onTouchStart\"\n  | \"onTouchStartCapture\"\n  | \"onTouchMove\"\n  | \"onTouchMoveCapture\"\n  | \"onTouchEnd\"\n  | \"onTouchEndCapture\"\n  | \"onTouchCancel\"\n  | \"onTouchCancelCapture\"\n\nexport const createResponderSystem = (\n  options: ResponderSystemOptions,\n): ResponderSystem => {\n  const registry = new Map<ResponderHost, Registration>()\n  const history = createTouchHistory()\n  let responder: ResponderHost | null = null\n  let session: Session | null = null\n\n  /**\n   * The registered nodes from the toplevel down to `host`, root first — RN's\n   * capture order, reversed for bubble.\n   *\n   * The walk stops wherever `parentOf` stops, which on this platform is the\n   * layout Root: an RN tree here is an island inside a native GTK widget\n   * tree (NestedRoot/IntrinsicRoot mount engines into arbitrary GTK slots),\n   * so there is no single app-wide view hierarchy to traverse. Native\n   * widgets on the way up are simply not registered and take no part.\n   */\n  const pathOf = (host: ResponderHost): ResponderHost[] => {\n    const path: ResponderHost[] = []\n    let current: ResponderHost | null = host\n    while (current) {\n      if (registry.has(current)) {\n        path.unshift(current)\n      }\n      current = options.parentOf(current)\n    }\n    return path\n  }\n\n  const propsOf = (host: ResponderHost): ResponderProps | null =>\n    registry.get(host)?.getProps() ?? null\n\n  const createEvent = (\n    touch: NativeTouch,\n    stillDown: boolean,\n  ): GestureResponderEvent => ({\n    nativeEvent: {\n      ...touch,\n      // Single-pointer: `touches` is the still-active set (empty once the\n      // pointer is up), `changedTouches` is always this one.\n      touches: stillDown ? [touch] : [],\n      changedTouches: [touch],\n    },\n    touchHistory: history,\n  })\n\n  /**\n   * Runs a should-set handler over `path` in order, stopping at the first\n   * that returns true — RN's executeDispatchesInOrderStopAtTrue. Handlers\n   * before the winner all run, which PanResponder depends on: its capture\n   * handlers are where gestureState is initialised and where dx/dy are\n   * accumulated on move.\n   */\n  const firstToClaim = (\n    path: readonly ResponderHost[],\n    name: ShouldSetName,\n    event: GestureResponderEvent,\n  ): ResponderHost | null => {\n    for (const host of path) {\n      const handler = propsOf(host)?.[name]\n      if (handler?.(event) === true) {\n        return host\n      }\n    }\n    return null\n  }\n\n  const notify = (\n    host: ResponderHost,\n    name: NotifyName,\n    event: GestureResponderEvent,\n  ): void => {\n    propsOf(host)?.[name]?.(event)\n  }\n\n  const dispatchTouch = (\n    path: readonly ResponderHost[],\n    captureName: TouchName,\n    bubbleName: TouchName,\n    event: GestureResponderEvent,\n  ): void => {\n    for (const host of path) {\n      propsOf(host)?.[captureName]?.(event)\n    }\n    for (let i = path.length - 1; i >= 0; i -= 1) {\n      propsOf(path[i]!)?.[bubbleName]?.(event)\n    }\n  }\n\n  const grant = (host: ResponderHost, event: GestureResponderEvent): void => {\n    responder = host\n    notify(host, \"onResponderGrant\", event)\n    // The GTK claim is per INTERACTION, not per grant: a transfer moves a JS\n    // lock, and there is nothing left to tell GTK once the sequence is\n    // already ours. Claiming again on the new holder's own gesture would\n    // deny the sequence on the source below it and silently end the drag.\n    if (session && !session.claimed) {\n      session.claimed = true\n      options.onClaim?.(session.host)\n    }\n  }\n\n  /**\n   * The negotiation path when someone already holds the responder: RN prunes\n   * it to the lowest common ancestor of the holder and the event target, and\n   * then skips the holder itself so it is never asked whether it wants what\n   * it already has. Pruning is what makes the lock transferable only\n   * UPWARDS — a descendant of the holder is not on the pruned path and\n   * cannot take it, which is RN's documented rule.\n   *\n   * Returns null when the two paths are disjoint (RNW's `lowestCommonAncestor\n   * == null`): nothing may take the responder in that case.\n   */\n  const pruneToAncestors = (\n    path: readonly ResponderHost[],\n    holder: ResponderHost,\n  ): ResponderHost[] | null => {\n    const holderPath = pathOf(holder)\n    let common = -1\n    const shared = Math.min(path.length, holderPath.length)\n    for (let i = 0; i < shared && path[i] === holderPath[i]; i += 1) {\n      common = i\n    }\n    if (common === -1) {\n      return null\n    }\n    return path.slice(0, path[common] === holder ? common : common + 1)\n  }\n\n  /**\n   * RN's handoff, in react-native-web's order: ask the holder, then\n   * terminate it, then grant. (Upstream's ResponderEventPlugin dispatches\n   * the grant BEFORE asking, so a rejected candidate still sees\n   * `onResponderGrant` — a quirk of the pooled-event implementation rather\n   * than of the model. RN's own documentation diagram, which RNW reproduces\n   * verbatim, shows TerminationRequest -> GRANT, and that is what we do.)\n   *\n   * A holder with no `onResponderTerminationRequest` always yields: absent\n   * means \"sure\", in RN and in RNW alike.\n   */\n  const attemptTransfer = (\n    winner: ResponderHost,\n    event: GestureResponderEvent,\n  ): void => {\n    const holder = responder\n    if (holder === null) {\n      grant(winner, event)\n      return\n    }\n    if (holder === winner) {\n      return\n    }\n    if (propsOf(holder)?.onResponderTerminationRequest?.(event) === false) {\n      notify(winner, \"onResponderReject\", event)\n      return\n    }\n    notify(holder, \"onResponderTerminate\", event)\n    responder = null\n    grant(winner, event)\n  }\n\n  /**\n   * Capture root-to-target, then bubble target-to-root — RN's two-phase\n   * negotiation, and the one place GTK's model and RN's agree, since GTK's\n   * CAPTURE/TARGET/BUBBLE phases run in exactly this order. We still do the\n   * walk ourselves so a single GTK event source can drive the whole path.\n   */\n  const negotiate = (\n    path: readonly ResponderHost[],\n    event: GestureResponderEvent,\n    phase: \"start\" | \"move\",\n  ): ResponderHost | null => {\n    const capture =\n      phase === \"start\"\n        ? \"onStartShouldSetResponderCapture\"\n        : \"onMoveShouldSetResponderCapture\"\n    const bubble =\n      phase === \"start\"\n        ? \"onStartShouldSetResponder\"\n        : \"onMoveShouldSetResponder\"\n    const captured = firstToClaim(path, capture, event)\n    if (captured) {\n      return captured\n    }\n    return firstToClaim([...path].reverse(), bubble, event)\n  }\n\n  /**\n   * The whole negotiation for one event: prune the path if the lock is held,\n   * ask who wants it, hand it over. Returns nothing — the caller reads\n   * `responder` afterwards, because RN dispatches `onResponderStart`/`Move`\n   * to whoever holds the lock AFTER the handoff, not before it.\n   */\n  const negotiateAndTransfer = (\n    path: readonly ResponderHost[],\n    event: GestureResponderEvent,\n    phase: \"start\" | \"move\",\n  ): void => {\n    const holder = responder\n    const candidates = holder === null ? path : pruneToAncestors(path, holder)\n    if (candidates === null || candidates.length === 0) {\n      return\n    }\n    const winner = negotiate(candidates, event, phase)\n    if (winner) {\n      attemptTransfer(winner, event)\n    }\n  }\n\n  const finish = (\n    touch: NativeTouch,\n    terminated: boolean,\n    touchProps: [TouchName, TouchName],\n  ): void => {\n    const current = session\n    if (!current) {\n      return\n    }\n    recordTouchEnd(history, touch)\n    refreshActiveTouches(history)\n    const event = createEvent(touch, false)\n    dispatchTouch(pathOf(current.host), touchProps[0], touchProps[1], event)\n\n    const holder = responder\n    session = null\n    responder = null\n    if (holder) {\n      notify(holder, \"onResponderEnd\", event)\n      notify(\n        holder,\n        terminated ? \"onResponderTerminate\" : \"onResponderRelease\",\n        event,\n      )\n    }\n  }\n\n  return {\n    register(host, getProps) {\n      registry.set(host, { getProps })\n      return () => {\n        registry.delete(host)\n        // A responder that unmounts mid-gesture cannot be asked anything\n        // ever again; drop the lock rather than stranding it.\n        if (responder === host) {\n          responder = null\n        }\n        if (session?.host === host) {\n          session = null\n        }\n      }\n    },\n\n    touchStart(host, touch) {\n      // Already tracking this press: this is an ancestor's gesture seeing the\n      // same event through GTK's bubble chain.\n      if (session !== null) {\n        return\n      }\n      session = {\n        host,\n        identifier: touch.identifier,\n        lastTouch: touch,\n        claimed: false,\n      }\n      recordTouchStart(history, touch)\n      refreshActiveTouches(history)\n\n      const path = pathOf(host)\n      const event = createEvent(touch, true)\n      dispatchTouch(path, \"onTouchStartCapture\", \"onTouchStart\", event)\n\n      negotiateAndTransfer(path, event, \"start\")\n      // RN dispatches this to whoever holds the lock once the handoff is\n      // over, which is why it is not folded into grant(): a view granted on\n      // a MOVE must not be told the interaction just started.\n      if (responder !== null) {\n        notify(responder, \"onResponderStart\", event)\n      }\n    },\n\n    touchMove(host, touch) {\n      if (session === null || session.host !== host) {\n        return\n      }\n      session.lastTouch = touch\n      recordTouchMove(history, touch)\n      refreshActiveTouches(history)\n\n      const path = pathOf(host)\n      const event = createEvent(touch, true)\n      dispatchTouch(path, \"onTouchMoveCapture\", \"onTouchMove\", event)\n\n      // Two shapes go through here. Nobody holds the lock yet: the common\n      // PanResponder one, where the pan starts once\n      // onMoveShouldSetPanResponder sees enough movement. Somebody does: an\n      // ancestor may still take it over, and the move is then delivered to\n      // whoever ends up holding it — including in the same event as the\n      // handoff, exactly as RN's own state diagram shows.\n      negotiateAndTransfer(path, event, \"move\")\n      if (responder !== null) {\n        notify(responder, \"onResponderMove\", event)\n      }\n    },\n\n    touchEnd(host, touch) {\n      if (session === null || session.host !== host) {\n        return\n      }\n      finish(touch, false, [\"onTouchEndCapture\", \"onTouchEnd\"])\n    },\n\n    touchCancel(host, touch) {\n      if (session === null || session.host !== host) {\n        return\n      }\n      finish(touch, true, [\"onTouchCancelCapture\", \"onTouchCancel\"])\n    },\n\n    terminate(reason) {\n      const current = session\n      const holder = responder\n      if (current === null || holder === null) {\n        // Nothing holds the lock: an ancestor scrolling or a menu opening is\n        // then simply an ancestor scrolling or a menu opening. RN terminates\n        // a RESPONDER; it has nothing to say when there is not one.\n        return false\n      }\n      const event = createEvent(current.lastTouch, false)\n      if (\n        reason === \"scroll\" &&\n        propsOf(holder)?.onResponderTerminationRequest?.(event) === false\n      ) {\n        return false\n      }\n\n      // No onResponderEnd here, and that is RN's shape rather than an\n      // oversight: End pairs with a touch actually ending. A termination\n      // that is not a pointer event goes straight to Terminate.\n      recordTouchEnd(history, current.lastTouch)\n      refreshActiveTouches(history)\n      session = null\n      responder = null\n      notify(holder, \"onResponderTerminate\", event)\n      return true\n    },\n\n    requestResponder(host) {\n      const current = session\n      if (current === null) {\n        // No interaction to take. A timer that fires after the pointer is up\n        // is a timer that lost, and there is nothing to negotiate over.\n        return false\n      }\n      if (responder === host) {\n        return true\n      }\n      const path = pathOf(current.host)\n      // A node off the interaction's path is not a candidate — the same rule\n      // the touch paths enforce by construction, stated here because this\n      // entry point is reached from a timer rather than from an event that\n      // already travelled the tree.\n      if (!path.includes(host)) {\n        return false\n      }\n      negotiateAndTransfer(path, createEvent(current.lastTouch, true), \"move\")\n      return responder === host\n    },\n\n    getResponder: () => responder,\n    getSource: () => session?.host ?? null,\n  }\n}\n"]}

package/dist/responder/touch-history.d.ts

@@ -0,0 +1,10 @@
+import type { NativeTouch, TouchHistory } from "./types";
+export declare const createTouchHistory: () => TouchHistory;
+export declare const recordTouchStart: (history: TouchHistory, touch: NativeTouch) => void;
+export declare const recordTouchMove: (history: TouchHistory, touch: NativeTouch) => void;
+export declare const recordTouchEnd: (history: TouchHistory, touch: NativeTouch) => void;
+/**
+ * Recomputes `numberActiveTouches` and `indexOfSingleActiveTouch` — the two
+ * derived fields TouchHistoryMath's single-touch fast path reads.
+ */
+export declare const refreshActiveTouches: (history: TouchHistory) => void;

package/dist/responder/touch-history.js

@@ -0,0 +1,78 @@
+export const createTouchHistory = () => ({
+    touchBank: [],
+    numberActiveTouches: 0,
+    indexOfSingleActiveTouch: -1,
+    mostRecentTimeStamp: 0,
+});
+export const recordTouchStart = (history, touch) => {
+    const identifier = touch.identifier;
+    const existing = history.touchBank[identifier];
+    if (existing) {
+        existing.touchActive = true;
+        existing.startPageX = touch.pageX;
+        existing.startPageY = touch.pageY;
+        existing.startTimeStamp = touch.timestamp;
+        existing.currentPageX = touch.pageX;
+        existing.currentPageY = touch.pageY;
+        existing.currentTimeStamp = touch.timestamp;
+        existing.previousPageX = touch.pageX;
+        existing.previousPageY = touch.pageY;
+        existing.previousTimeStamp = touch.timestamp;
+    }
+    else {
+        const record = {
+            touchActive: true,
+            startPageX: touch.pageX,
+            startPageY: touch.pageY,
+            startTimeStamp: touch.timestamp,
+            currentPageX: touch.pageX,
+            currentPageY: touch.pageY,
+            currentTimeStamp: touch.timestamp,
+            previousPageX: touch.pageX,
+            previousPageY: touch.pageY,
+            previousTimeStamp: touch.timestamp,
+        };
+        history.touchBank[identifier] = record;
+    }
+    history.mostRecentTimeStamp = touch.timestamp;
+};
+const recordTouchMoveOrEnd = (history, touch, stillActive) => {
+    const record = history.touchBank[touch.identifier];
+    if (!record) {
+        // Upstream warns here. A move without a start means the event source and
+        // the store disagree, which is a bug in the caller, not a user error.
+        return;
+    }
+    record.touchActive = stillActive;
+    record.previousPageX = record.currentPageX;
+    record.previousPageY = record.currentPageY;
+    record.previousTimeStamp = record.currentTimeStamp;
+    record.currentPageX = touch.pageX;
+    record.currentPageY = touch.pageY;
+    record.currentTimeStamp = touch.timestamp;
+    history.mostRecentTimeStamp = touch.timestamp;
+};
+export const recordTouchMove = (history, touch) => {
+    recordTouchMoveOrEnd(history, touch, true);
+};
+export const recordTouchEnd = (history, touch) => {
+    recordTouchMoveOrEnd(history, touch, false);
+};
+/**
+ * Recomputes `numberActiveTouches` and `indexOfSingleActiveTouch` — the two
+ * derived fields TouchHistoryMath's single-touch fast path reads.
+ */
+export const refreshActiveTouches = (history) => {
+    let active = 0;
+    let singleIndex = -1;
+    for (let i = 0; i < history.touchBank.length; i += 1) {
+        const record = history.touchBank[i];
+        if (record?.touchActive) {
+            active += 1;
+            singleIndex = i;
+        }
+    }
+    history.numberActiveTouches = active;
+    history.indexOfSingleActiveTouch = active === 1 ? singleIndex : -1;
+};
+//# sourceMappingURL=touch-history.js.map

package/dist/responder/touch-history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"touch-history.js","sourceRoot":"","sources":["../../src/responder/touch-history.ts"],"names":[],"mappings":"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","sourcesContent":["// The touch-history store, transcribed from RN's ResponderTouchHistoryStore\n// so the vendored PanResponder runs against it unmodified.\n//\n// Everything here is deliberately mechanical. The three-way split — start /\n// previous / current — is what makes velocity and clustered multi-touch\n// accumulation computable at all, and \"previous\" specifically means the\n// value before THIS event, not one frame ago. Collapsing any of it would\n// break TouchHistoryMath in ways that only show up as a subtly wrong vx.\nimport type { NativeTouch, TouchHistory, TouchRecord } from \"./types\"\n\nexport const createTouchHistory = (): TouchHistory => ({\n  touchBank: [],\n  numberActiveTouches: 0,\n  indexOfSingleActiveTouch: -1,\n  mostRecentTimeStamp: 0,\n})\n\nexport const recordTouchStart = (\n  history: TouchHistory,\n  touch: NativeTouch,\n): void => {\n  const identifier = touch.identifier\n  const existing = history.touchBank[identifier]\n  if (existing) {\n    existing.touchActive = true\n    existing.startPageX = touch.pageX\n    existing.startPageY = touch.pageY\n    existing.startTimeStamp = touch.timestamp\n    existing.currentPageX = touch.pageX\n    existing.currentPageY = touch.pageY\n    existing.currentTimeStamp = touch.timestamp\n    existing.previousPageX = touch.pageX\n    existing.previousPageY = touch.pageY\n    existing.previousTimeStamp = touch.timestamp\n  } else {\n    const record: TouchRecord = {\n      touchActive: true,\n      startPageX: touch.pageX,\n      startPageY: touch.pageY,\n      startTimeStamp: touch.timestamp,\n      currentPageX: touch.pageX,\n      currentPageY: touch.pageY,\n      currentTimeStamp: touch.timestamp,\n      previousPageX: touch.pageX,\n      previousPageY: touch.pageY,\n      previousTimeStamp: touch.timestamp,\n    }\n    history.touchBank[identifier] = record\n  }\n  history.mostRecentTimeStamp = touch.timestamp\n}\n\nconst recordTouchMoveOrEnd = (\n  history: TouchHistory,\n  touch: NativeTouch,\n  stillActive: boolean,\n): void => {\n  const record = history.touchBank[touch.identifier]\n  if (!record) {\n    // Upstream warns here. A move without a start means the event source and\n    // the store disagree, which is a bug in the caller, not a user error.\n    return\n  }\n  record.touchActive = stillActive\n  record.previousPageX = record.currentPageX\n  record.previousPageY = record.currentPageY\n  record.previousTimeStamp = record.currentTimeStamp\n  record.currentPageX = touch.pageX\n  record.currentPageY = touch.pageY\n  record.currentTimeStamp = touch.timestamp\n  history.mostRecentTimeStamp = touch.timestamp\n}\n\nexport const recordTouchMove = (\n  history: TouchHistory,\n  touch: NativeTouch,\n): void => {\n  recordTouchMoveOrEnd(history, touch, true)\n}\n\nexport const recordTouchEnd = (\n  history: TouchHistory,\n  touch: NativeTouch,\n): void => {\n  recordTouchMoveOrEnd(history, touch, false)\n}\n\n/**\n * Recomputes `numberActiveTouches` and `indexOfSingleActiveTouch` — the two\n * derived fields TouchHistoryMath's single-touch fast path reads.\n */\nexport const refreshActiveTouches = (history: TouchHistory): void => {\n  let active = 0\n  let singleIndex = -1\n  for (let i = 0; i < history.touchBank.length; i += 1) {\n    const record = history.touchBank[i]\n    if (record?.touchActive) {\n      active += 1\n      singleIndex = i\n    }\n  }\n  history.numberActiveTouches = active\n  history.indexOfSingleActiveTouch = active === 1 ? singleIndex : -1\n}\n"]}

package/dist/responder/types.d.ts

@@ -0,0 +1,63 @@
+import type { NativeTouch, PressEvent } from "../components/press-event";
+/** One tracked touch. Field names are RN's; do not "tidy" them. */
+export type TouchRecord = {
+    touchActive: boolean;
+    startPageX: number;
+    startPageY: number;
+    startTimeStamp: number;
+    currentPageX: number;
+    currentPageY: number;
+    currentTimeStamp: number;
+    previousPageX: number;
+    previousPageY: number;
+    previousTimeStamp: number;
+};
+export type TouchHistory = {
+    touchBank: TouchRecord[];
+    numberActiveTouches: number;
+    indexOfSingleActiveTouch: number;
+    mostRecentTimeStamp: number;
+};
+/**
+ * What every responder callback receives. PanResponder reads `touchHistory`
+ * off the EVENT, not off `nativeEvent` — an easy detail to get wrong, and it
+ * silently zeroes every gesture if you do.
+ */
+export type GestureResponderEvent = PressEvent & {
+    touchHistory: TouchHistory;
+};
+export type ShouldSetResponder = (event: GestureResponderEvent) => boolean;
+/**
+ * RN's responder and touch props. The touch props fire regardless of who
+ * holds the responder; the rest are the negotiation.
+ */
+export type ResponderProps = {
+    onStartShouldSetResponder?: ShouldSetResponder;
+    onStartShouldSetResponderCapture?: ShouldSetResponder;
+    onMoveShouldSetResponder?: ShouldSetResponder;
+    onMoveShouldSetResponderCapture?: ShouldSetResponder;
+    onResponderGrant?: (event: GestureResponderEvent) => void | boolean;
+    onResponderStart?: (event: GestureResponderEvent) => void;
+    onResponderMove?: (event: GestureResponderEvent) => void;
+    onResponderEnd?: (event: GestureResponderEvent) => void;
+    onResponderRelease?: (event: GestureResponderEvent) => void;
+    onResponderTerminate?: (event: GestureResponderEvent) => void;
+    onResponderTerminationRequest?: ShouldSetResponder;
+    onResponderReject?: (event: GestureResponderEvent) => void;
+    onTouchStart?: (event: GestureResponderEvent) => void;
+    onTouchStartCapture?: (event: GestureResponderEvent) => void;
+    onTouchMove?: (event: GestureResponderEvent) => void;
+    onTouchMoveCapture?: (event: GestureResponderEvent) => void;
+    onTouchEnd?: (event: GestureResponderEvent) => void;
+    onTouchEndCapture?: (event: GestureResponderEvent) => void;
+    onTouchCancel?: (event: GestureResponderEvent) => void;
+    onTouchCancelCapture?: (event: GestureResponderEvent) => void;
+};
+/**
+ * Whether a component needs an event source at all. A View with no responder
+ * props gets no GTK controller: RN only ever asks views that declare
+ * handlers, so attaching one everywhere would be pure cost.
+ */
+export declare const hasResponderProps: (props: ResponderProps) => boolean;
+/** A single touch as PanResponder's `touches`/`changedTouches` see it. */
+export type { NativeTouch };

package/dist/responder/types.js

@@ -0,0 +1,29 @@
+const RESPONDER_PROP_NAMES = [
+    "onStartShouldSetResponder",
+    "onStartShouldSetResponderCapture",
+    "onMoveShouldSetResponder",
+    "onMoveShouldSetResponderCapture",
+    "onResponderGrant",
+    "onResponderStart",
+    "onResponderMove",
+    "onResponderEnd",
+    "onResponderRelease",
+    "onResponderTerminate",
+    "onResponderTerminationRequest",
+    "onResponderReject",
+    "onTouchStart",
+    "onTouchStartCapture",
+    "onTouchMove",
+    "onTouchMoveCapture",
+    "onTouchEnd",
+    "onTouchEndCapture",
+    "onTouchCancel",
+    "onTouchCancelCapture",
+];
+/**
+ * Whether a component needs an event source at all. A View with no responder
+ * props gets no GTK controller: RN only ever asks views that declare
+ * handlers, so attaching one everywhere would be pure cost.
+ */
+export const hasResponderProps = (props) => RESPONDER_PROP_NAMES.some((name) => props[name] !== undefined);
+//# sourceMappingURL=types.js.map

package/dist/responder/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/responder/types.ts"],"names":[],"mappings":"AA2EA,MAAM,oBAAoB,GAAG;IAC3B,2BAA2B;IAC3B,kCAAkC;IAClC,0BAA0B;IAC1B,iCAAiC;IACjC,kBAAkB;IAClB,kBAAkB;IAClB,iBAAiB;IACjB,gBAAgB;IAChB,oBAAoB;IACpB,sBAAsB;IACtB,+BAA+B;IAC/B,mBAAmB;IACnB,cAAc;IACd,qBAAqB;IACrB,aAAa;IACb,oBAAoB;IACpB,YAAY;IACZ,mBAAmB;IACnB,eAAe;IACf,sBAAsB;CAC8B,CAAA;AAEtD;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,KAAqB,EAAW,EAAE,CAClE,oBAAoB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC,CAAA","sourcesContent":["// The responder system's public vocabulary: the touch-history shape RN's\n// PanResponder expects, and the props a View accepts.\n//\n// The touch-history shape is not ours to design. react-native-web proved\n// that RN's own PanResponder runs unmodified on a foreign platform provided\n// this structure is reproduced exactly — field for field, including the\n// three-way current/previous/start split and the millisecond timestamps —\n// so it is transcribed from ResponderTouchHistoryStore rather than invented.\nimport type { NativeTouch, PressEvent } from \"../components/press-event\"\n\n/** One tracked touch. Field names are RN's; do not \"tidy\" them. */\nexport type TouchRecord = {\n  touchActive: boolean\n  startPageX: number\n  startPageY: number\n  startTimeStamp: number\n  currentPageX: number\n  currentPageY: number\n  currentTimeStamp: number\n  previousPageX: number\n  previousPageY: number\n  previousTimeStamp: number\n}\n\nexport type TouchHistory = {\n  // Sparse: indexed by touch identifier, exactly as RN does it.\n  touchBank: TouchRecord[]\n  numberActiveTouches: number\n  // Only meaningful when numberActiveTouches === 1; TouchHistoryMath's fast\n  // path reads it directly.\n  indexOfSingleActiveTouch: number\n  mostRecentTimeStamp: number\n}\n\n/**\n * What every responder callback receives. PanResponder reads `touchHistory`\n * off the EVENT, not off `nativeEvent` — an easy detail to get wrong, and it\n * silently zeroes every gesture if you do.\n */\nexport type GestureResponderEvent = PressEvent & {\n  touchHistory: TouchHistory\n}\n\nexport type ShouldSetResponder = (event: GestureResponderEvent) => boolean\n\n/**\n * RN's responder and touch props. The touch props fire regardless of who\n * holds the responder; the rest are the negotiation.\n */\nexport type ResponderProps = {\n  onStartShouldSetResponder?: ShouldSetResponder\n  onStartShouldSetResponderCapture?: ShouldSetResponder\n  onMoveShouldSetResponder?: ShouldSetResponder\n  onMoveShouldSetResponderCapture?: ShouldSetResponder\n  // RN lets onResponderGrant return a boolean (onShouldBlockNativeResponder);\n  // PanResponder's does. Nothing consumes it here yet — see docs/api.md.\n  onResponderGrant?: (event: GestureResponderEvent) => void | boolean\n  onResponderStart?: (event: GestureResponderEvent) => void\n  onResponderMove?: (event: GestureResponderEvent) => void\n  onResponderEnd?: (event: GestureResponderEvent) => void\n  onResponderRelease?: (event: GestureResponderEvent) => void\n  onResponderTerminate?: (event: GestureResponderEvent) => void\n  onResponderTerminationRequest?: ShouldSetResponder\n  onResponderReject?: (event: GestureResponderEvent) => void\n\n  onTouchStart?: (event: GestureResponderEvent) => void\n  onTouchStartCapture?: (event: GestureResponderEvent) => void\n  onTouchMove?: (event: GestureResponderEvent) => void\n  onTouchMoveCapture?: (event: GestureResponderEvent) => void\n  onTouchEnd?: (event: GestureResponderEvent) => void\n  onTouchEndCapture?: (event: GestureResponderEvent) => void\n  onTouchCancel?: (event: GestureResponderEvent) => void\n  onTouchCancelCapture?: (event: GestureResponderEvent) => void\n}\n\nconst RESPONDER_PROP_NAMES = [\n  \"onStartShouldSetResponder\",\n  \"onStartShouldSetResponderCapture\",\n  \"onMoveShouldSetResponder\",\n  \"onMoveShouldSetResponderCapture\",\n  \"onResponderGrant\",\n  \"onResponderStart\",\n  \"onResponderMove\",\n  \"onResponderEnd\",\n  \"onResponderRelease\",\n  \"onResponderTerminate\",\n  \"onResponderTerminationRequest\",\n  \"onResponderReject\",\n  \"onTouchStart\",\n  \"onTouchStartCapture\",\n  \"onTouchMove\",\n  \"onTouchMoveCapture\",\n  \"onTouchEnd\",\n  \"onTouchEndCapture\",\n  \"onTouchCancel\",\n  \"onTouchCancelCapture\",\n] as const satisfies readonly (keyof ResponderProps)[]\n\n/**\n * Whether a component needs an event source at all. A View with no responder\n * props gets no GTK controller: RN only ever asks views that declare\n * handlers, so attaching one everywhere would be pure cost.\n */\nexport const hasResponderProps = (props: ResponderProps): boolean =>\n  RESPONDER_PROP_NAMES.some((name) => props[name] !== undefined)\n\n/** A single touch as PanResponder's `touches`/`changedTouches` see it. */\nexport type { NativeTouch }\n"]}

package/dist/responder/use-responder.d.ts

@@ -0,0 +1,23 @@
+import { type RefObject } from "react";
+import { Gtk } from "../gtkx/bridge/index";
+import { type ResponderHost } from "./system";
+import { type ResponderProps } from "./types";
+/** Exposed for tests and for future ScrollView arbitration. */
+export declare const getCurrentResponder: () => ResponderHost | null;
+/**
+ * The out-of-event grant channel, for a recognizer whose mind was changed by
+ * a timer rather than by a pointer (`activateAfterLongPress`). See
+ * `ResponderSystem.requestResponder` for what it does and
+ * docs/research/gestures.md for why the model is extended at all.
+ *
+ * @internal Not part of the RN surface: an app writes responder props, and
+ * nothing in RN asks for the responder from outside an event. This exists for
+ * `GestureDetector`, whose recognizers do.
+ */
+export declare const requestResponder: (widget: Gtk.Widget) => boolean;
+/**
+ * Attaches the responder event source to a component's widget, but only when
+ * it actually declares responder props — RN never asks a view without
+ * handlers, so a controller on every View would be pure cost.
+ */
+export declare const useResponder: (widgetRef: RefObject<Gtk.Widget | null>, props: ResponderProps) => void;