react-native-gtkx 0.1.0-alpha.4 → 0.2.0-alpha.2

package/dist/responder/system.js

@@ -0,0 +1,184 @@
+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, fromStart) => {
+        responder = host;
+        notify(host, "onResponderGrant", event);
+        if (fromStart) {
+            notify(host, "onResponderStart", event);
+        }
+        options.onGrant?.(host);
+    };
+    /**
+     * 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);
+    };
+    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);
+            options.onRelease?.(holder);
+        }
+    };
+    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 };
+            recordTouchStart(history, touch);
+            refreshActiveTouches(history);
+            const path = pathOf(host);
+            const event = createEvent(touch, true);
+            dispatchTouch(path, "onTouchStartCapture", "onTouchStart", event);
+            if (responder !== null) {
+                return;
+            }
+            const winner = negotiate(path, event, "start");
+            if (winner) {
+                grant(winner, event, true);
+            }
+        },
+        touchMove(host, touch) {
+            if (session === null || session.host !== host) {
+                return;
+            }
+            recordTouchMove(history, touch);
+            refreshActiveTouches(history);
+            const path = pathOf(host);
+            const event = createEvent(touch, true);
+            dispatchTouch(path, "onTouchMoveCapture", "onTouchMove", event);
+            if (responder === null) {
+                // The common PanResponder shape: nothing claims on press, and the
+                // pan starts once onMoveShouldSetPanResponder sees enough movement.
+                const winner = negotiate(path, event, "move");
+                if (winner) {
+                    grant(winner, event, false);
+                }
+                return;
+            }
+            // v1 deliberately does not renegotiate while a responder holds: GTK
+            // cannot revoke a claim, so a transfer we cannot enforce natively would
+            // be a lie at the boundary with native widgets. Tracked as task 002b.
+            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"]);
+        },
+        getResponder: () => responder,
+    };
+};
+//# 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 the\n// grant/release notifications the platform uses to make its one-way GTK\n// claim. That keeps the algorithm unit-testable off Linux, which matters\n// because this is the part that is subtle and the part every platform\n// 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\nexport type ResponderSystemOptions = {\n  /** The platform's parent link. Returning null ends the path. */\n  parentOf: (host: ResponderHost) => ResponderHost | null\n  /**\n   * Fired after a node is granted the responder — where the platform makes\n   * its GTK `CLAIMED` declaration. One-way by construction: GTK has no way\n   * to hand a claimed sequence back, so this is only ever called once JS has\n   * already decided (docs/research/gestures.md, \"no voluntary release\").\n   */\n  onGrant?: (host: ResponderHost) => void\n  /** Fired when the responder is released or terminated. */\n  onRelease?: (host: 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.\ntype Session = { host: ResponderHost; identifier: number }\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  /** The node currently holding the responder, or null. */\n  getResponder(): 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 = (\n    host: ResponderHost,\n    event: GestureResponderEvent,\n    fromStart: boolean,\n  ): void => {\n    responder = host\n    notify(host, \"onResponderGrant\", event)\n    if (fromStart) {\n      notify(host, \"onResponderStart\", event)\n    }\n    options.onGrant?.(host)\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  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      options.onRelease?.(holder)\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 = { host, identifier: touch.identifier }\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      if (responder !== null) {\n        return\n      }\n      const winner = negotiate(path, event, \"start\")\n      if (winner) {\n        grant(winner, event, true)\n      }\n    },\n\n    touchMove(host, touch) {\n      if (session === null || session.host !== host) {\n        return\n      }\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      if (responder === null) {\n        // The common PanResponder shape: nothing claims on press, and the\n        // pan starts once onMoveShouldSetPanResponder sees enough movement.\n        const winner = negotiate(path, event, \"move\")\n        if (winner) {\n          grant(winner, event, false)\n        }\n        return\n      }\n      // v1 deliberately does not renegotiate while a responder holds: GTK\n      // cannot revoke a claim, so a transfer we cannot enforce natively would\n      // be a lie at the boundary with native widgets. Tracked as task 002b.\n      notify(responder, \"onResponderMove\", event)\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    getResponder: () => responder,\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":"AAUA,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAiB,EAAE,CAAC,CAAC;IACrD,SAAS,EAAE,EAAE;IACb,mBAAmB,EAAE,CAAC;IACtB,wBAAwB,EAAE,CAAC,CAAC;IAC5B,mBAAmB,EAAE,CAAC;CACvB,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,OAAqB,EACrB,KAAkB,EACZ,EAAE;IACR,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,CAAA;IACnC,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,CAAA;IAC9C,IAAI,QAAQ,EAAE,CAAC;QACb,QAAQ,CAAC,WAAW,GAAG,IAAI,CAAA;QAC3B,QAAQ,CAAC,UAAU,GAAG,KAAK,CAAC,KAAK,CAAA;QACjC,QAAQ,CAAC,UAAU,GAAG,KAAK,CAAC,KAAK,CAAA;QACjC,QAAQ,CAAC,cAAc,GAAG,KAAK,CAAC,SAAS,CAAA;QACzC,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAC,KAAK,CAAA;QACnC,QAAQ,CAAC,YAAY,GAAG,KAAK,CAAC,KAAK,CAAA;QACnC,QAAQ,CAAC,gBAAgB,GAAG,KAAK,CAAC,SAAS,CAAA;QAC3C,QAAQ,CAAC,aAAa,GAAG,KAAK,CAAC,KAAK,CAAA;QACpC,QAAQ,CAAC,aAAa,GAAG,KAAK,CAAC,KAAK,CAAA;QACpC,QAAQ,CAAC,iBAAiB,GAAG,KAAK,CAAC,SAAS,CAAA;IAC9C,CAAC;SAAM,CAAC;QACN,MAAM,MAAM,GAAgB;YAC1B,WAAW,EAAE,IAAI;YACjB,UAAU,EAAE,KAAK,CAAC,KAAK;YACvB,UAAU,EAAE,KAAK,CAAC,KAAK;YACvB,cAAc,EAAE,KAAK,CAAC,SAAS;YAC/B,YAAY,EAAE,KAAK,CAAC,KAAK;YACzB,YAAY,EAAE,KAAK,CAAC,KAAK;YACzB,gBAAgB,EAAE,KAAK,CAAC,SAAS;YACjC,aAAa,EAAE,KAAK,CAAC,KAAK;YAC1B,aAAa,EAAE,KAAK,CAAC,KAAK;YAC1B,iBAAiB,EAAE,KAAK,CAAC,SAAS;SACnC,CAAA;QACD,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,MAAM,CAAA;IACxC,CAAC;IACD,OAAO,CAAC,mBAAmB,GAAG,KAAK,CAAC,SAAS,CAAA;AAC/C,CAAC,CAAA;AAED,MAAM,oBAAoB,GAAG,CAC3B,OAAqB,EACrB,KAAkB,EAClB,WAAoB,EACd,EAAE;IACR,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;IAClD,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,yEAAyE;QACzE,sEAAsE;QACtE,OAAM;IACR,CAAC;IACD,MAAM,CAAC,WAAW,GAAG,WAAW,CAAA;IAChC,MAAM,CAAC,aAAa,GAAG,MAAM,CAAC,YAAY,CAAA;IAC1C,MAAM,CAAC,aAAa,GAAG,MAAM,CAAC,YAAY,CAAA;IAC1C,MAAM,CAAC,iBAAiB,GAAG,MAAM,CAAC,gBAAgB,CAAA;IAClD,MAAM,CAAC,YAAY,GAAG,KAAK,CAAC,KAAK,CAAA;IACjC,MAAM,CAAC,YAAY,GAAG,KAAK,CAAC,KAAK,CAAA;IACjC,MAAM,CAAC,gBAAgB,GAAG,KAAK,CAAC,SAAS,CAAA;IACzC,OAAO,CAAC,mBAAmB,GAAG,KAAK,CAAC,SAAS,CAAA;AAC/C,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,OAAqB,EACrB,KAAkB,EACZ,EAAE;IACR,oBAAoB,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAA;AAC5C,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,OAAqB,EACrB,KAAkB,EACZ,EAAE;IACR,oBAAoB,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,CAAA;AAC7C,CAAC,CAAA;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,OAAqB,EAAQ,EAAE;IAClE,IAAI,MAAM,GAAG,CAAC,CAAA;IACd,IAAI,WAAW,GAAG,CAAC,CAAC,CAAA;IACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACrD,MAAM,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;QACnC,IAAI,MAAM,EAAE,WAAW,EAAE,CAAC;YACxB,MAAM,IAAI,CAAC,CAAA;YACX,WAAW,GAAG,CAAC,CAAA;QACjB,CAAC;IACH,CAAC;IACD,OAAO,CAAC,mBAAmB,GAAG,MAAM,CAAA;IACpC,OAAO,CAAC,wBAAwB,GAAG,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AACpE,CAAC,CAAA","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,12 @@
+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;
+/**
+ * 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;

package/dist/responder/use-responder.js

@@ -0,0 +1,98 @@
+// The platform half of the responder system: GTK carries the events, the
+// pure module in ./system owns the algorithm.
+//
+// Shape and why (docs/research/gestures.md, "Verifiability decides the
+// implementation shape"): the architecturally cleanest source would be one
+// GtkEventControllerLegacy on the toplevel doing its own hit-testing, which
+// is react-native-web's design. It is also untestable here —
+// @gtkx/testing's userEvent emits GtkGesture SIGNALS on the widget you name
+// and never produces a GdkEvent, so a raw tap could not be driven in CI at
+// all. A gesture per responder-declaring View is drivable today
+// (`userEvent.drag`), and GTK's own bubble chain still delivers a press to
+// every ancestor's gesture, so the path is not lost.
+//
+// One GtkGestureDrag per View covers press, move and release: it emits
+// drag-begin on press with no threshold of its own, which is exactly what
+// RN wants — the responder system has no threshold either, and PanResponder
+// users apply their own inside onMoveShouldSetPanResponder.
+import { useLayoutEffect, useRef } from "react";
+import { createTouch } from "../components/press-event";
+import { Gtk } from "../gtkx/bridge/index";
+import { createResponderSystem } from "./system";
+import { hasResponderProps } from "./types";
+// The gesture that reported each registered widget, so a grant can make the
+// GTK claim on the right one.
+const gestures = new WeakMap();
+/**
+ * One lock for the process, as in RN. What is island-scoped is the
+ * negotiation PATH, not the lock: `parentOf` walks the GTK widget tree and
+ * simply finds nothing registered above a layout Root, so an RN island
+ * inside a native widget tree negotiates among its own views and no others.
+ */
+const responderSystem = createResponderSystem({
+    parentOf: (host) => host.getParent(),
+    onGrant: (host) => {
+        // GTK's only arbitration primitive, used the only way it can honestly be
+        // used: a final one-way declaration AFTER JS has decided. There is no
+        // un-claim, so nothing may depend on taking it back.
+        gestures.get(host)?.setState(Gtk.EventSequenceState.CLAIMED);
+    },
+});
+/** Exposed for tests and for future ScrollView arbitration. */
+export const getCurrentResponder = () => responderSystem.getResponder();
+/**
+ * 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 const useResponder = (widgetRef, props) => {
+    // Handlers are read through a ref so a re-render never detaches and
+    // re-adds the gesture mid-drag (the same reasoning as Pressable's). The
+    // ref is refreshed in an effect rather than during render: a render-phase
+    // write is not safe under concurrent rendering, and this effect is
+    // declared BEFORE the registration effect so the handlers are already
+    // current the first time the gesture can fire.
+    const propsRef = useRef(props);
+    useLayoutEffect(() => {
+        propsRef.current = props;
+    });
+    const active = hasResponderProps(props);
+    useLayoutEffect(() => {
+        const widget = widgetRef.current;
+        if (!widget || !active) {
+            return;
+        }
+        const unregister = responderSystem.register(widget, () => propsRef.current);
+        const drag = new Gtk.GestureDrag();
+        gestures.set(widget, drag);
+        // drag-update/end report offsets FROM the start point, not absolute
+        // coordinates — the start has to be carried.
+        let startX = 0;
+        let startY = 0;
+        drag.on("drag-begin", (x, y) => {
+            startX = x;
+            startY = y;
+            responderSystem.touchStart(widget, createTouch(widget, x, y));
+        });
+        drag.on("drag-update", (offsetX, offsetY) => {
+            responderSystem.touchMove(widget, createTouch(widget, startX + offsetX, startY + offsetY));
+        });
+        drag.on("drag-end", (offsetX, offsetY) => {
+            responderSystem.touchEnd(widget, createTouch(widget, startX + offsetX, startY + offsetY));
+        });
+        // GTK cancels a sequence when something upstream claims it — a native
+        // ancestor scrolling, say. RN calls that a termination, and it is the
+        // one termination trigger we get for free.
+        drag.on("cancel", () => {
+            responderSystem.touchCancel(widget, createTouch(widget, startX, startY));
+        });
+        widget.addController(drag);
+        return () => {
+            widget.removeController(drag);
+            gestures.delete(widget);
+            unregister();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [active]);
+};
+//# sourceMappingURL=use-responder.js.map

package/dist/responder/use-responder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-responder.js","sourceRoot":"","sources":["../../src/responder/use-responder.ts"],"names":[],"mappings":"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","sourcesContent":["// The platform half of the responder system: GTK carries the events, the\n// pure module in ./system owns the algorithm.\n//\n// Shape and why (docs/research/gestures.md, \"Verifiability decides the\n// implementation shape\"): the architecturally cleanest source would be one\n// GtkEventControllerLegacy on the toplevel doing its own hit-testing, which\n// is react-native-web's design. It is also untestable here —\n// @gtkx/testing's userEvent emits GtkGesture SIGNALS on the widget you name\n// and never produces a GdkEvent, so a raw tap could not be driven in CI at\n// all. A gesture per responder-declaring View is drivable today\n// (`userEvent.drag`), and GTK's own bubble chain still delivers a press to\n// every ancestor's gesture, so the path is not lost.\n//\n// One GtkGestureDrag per View covers press, move and release: it emits\n// drag-begin on press with no threshold of its own, which is exactly what\n// RN wants — the responder system has no threshold either, and PanResponder\n// users apply their own inside onMoveShouldSetPanResponder.\nimport { useLayoutEffect, useRef, type RefObject } from \"react\"\nimport { createTouch } from \"../components/press-event\"\nimport { Gtk } from \"../gtkx/bridge/index\"\nimport { createResponderSystem, type ResponderHost } from \"./system\"\nimport { hasResponderProps, type ResponderProps } from \"./types\"\n\n// The gesture that reported each registered widget, so a grant can make the\n// GTK claim on the right one.\nconst gestures = new WeakMap<ResponderHost, Gtk.Gesture>()\n\n/**\n * One lock for the process, as in RN. What is island-scoped is the\n * negotiation PATH, not the lock: `parentOf` walks the GTK widget tree and\n * simply finds nothing registered above a layout Root, so an RN island\n * inside a native widget tree negotiates among its own views and no others.\n */\nconst responderSystem = createResponderSystem({\n  parentOf: (host) => (host as Gtk.Widget).getParent(),\n  onGrant: (host) => {\n    // GTK's only arbitration primitive, used the only way it can honestly be\n    // used: a final one-way declaration AFTER JS has decided. There is no\n    // un-claim, so nothing may depend on taking it back.\n    gestures.get(host)?.setState(Gtk.EventSequenceState.CLAIMED)\n  },\n})\n\n/** Exposed for tests and for future ScrollView arbitration. */\nexport const getCurrentResponder = (): ResponderHost | null =>\n  responderSystem.getResponder()\n\n/**\n * Attaches the responder event source to a component's widget, but only when\n * it actually declares responder props — RN never asks a view without\n * handlers, so a controller on every View would be pure cost.\n */\nexport const useResponder = (\n  widgetRef: RefObject<Gtk.Widget | null>,\n  props: ResponderProps,\n): void => {\n  // Handlers are read through a ref so a re-render never detaches and\n  // re-adds the gesture mid-drag (the same reasoning as Pressable's). The\n  // ref is refreshed in an effect rather than during render: a render-phase\n  // write is not safe under concurrent rendering, and this effect is\n  // declared BEFORE the registration effect so the handlers are already\n  // current the first time the gesture can fire.\n  const propsRef = useRef(props)\n  useLayoutEffect(() => {\n    propsRef.current = props\n  })\n  const active = hasResponderProps(props)\n\n  useLayoutEffect(() => {\n    const widget = widgetRef.current\n    if (!widget || !active) {\n      return\n    }\n\n    const unregister = responderSystem.register(widget, () => propsRef.current)\n\n    const drag = new Gtk.GestureDrag()\n    gestures.set(widget, drag)\n\n    // drag-update/end report offsets FROM the start point, not absolute\n    // coordinates — the start has to be carried.\n    let startX = 0\n    let startY = 0\n\n    drag.on(\"drag-begin\", (x: number, y: number) => {\n      startX = x\n      startY = y\n      responderSystem.touchStart(widget, createTouch(widget, x, y))\n    })\n    drag.on(\"drag-update\", (offsetX: number, offsetY: number) => {\n      responderSystem.touchMove(\n        widget,\n        createTouch(widget, startX + offsetX, startY + offsetY),\n      )\n    })\n    drag.on(\"drag-end\", (offsetX: number, offsetY: number) => {\n      responderSystem.touchEnd(\n        widget,\n        createTouch(widget, startX + offsetX, startY + offsetY),\n      )\n    })\n    // GTK cancels a sequence when something upstream claims it — a native\n    // ancestor scrolling, say. RN calls that a termination, and it is the\n    // one termination trigger we get for free.\n    drag.on(\"cancel\", () => {\n      responderSystem.touchCancel(widget, createTouch(widget, startX, startY))\n    })\n\n    widget.addController(drag)\n\n    return () => {\n      widget.removeController(drag)\n      gestures.delete(widget)\n      unregister()\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [active])\n}\n"]}

package/dist/runner/host-dev.js

@@ -54,7 +54,9 @@ globalThis.__ReactRefresh = {
 const CONFIG_REQUIRED = "gtkx.config.ts with an applicationId is required in the app root " +
     '(export default defineConfig({ applicationId: "...", libraries: [...] })).';
 const { createConfigLoader } = await import(pathToFileURL(fromPackage.resolve("@gtkx/config/internal")).href);
-const gtkxConfig = await createConfigLoader()(process.cwd()).catch((error) => fail(`${CONFIG_REQUIRED}\n${String(error)}`));
+const gtkxConfig = await createConfigLoader()
+    .resolve(process.cwd())
+    .catch((error) => fail(`${CONFIG_REQUIRED}\n${String(error)}`));
 if (!gtkxConfig.applicationId) {
     fail(CONFIG_REQUIRED);
 }