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

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

@@ -0,0 +1,284 @@
+// The activation loop: one place where every gesture in an interaction asks
+// whether it may become active, and one place where an activation cancels
+// everything it excludes.
+//
+// THE SECOND LOCK. The responder lock (src/responder) keeps its one job —
+// this interaction belongs to React Native, one holder, one irrevocable GTK
+// `CLAIMED` on the source. This loop is the second lock, at the second level,
+// and it is JS-only by construction: it imports nothing from the platform,
+// takes no widget, and never makes GTK claim anything. Every relation is
+// resolved here BEFORE the responder lock is asked for, which is what makes
+// the model honest given that GTK's `CLAIMED` cannot be taken back.
+//
+// Concretely: the FIRST gesture to activate in an interaction asks for the
+// responder and becomes ACTIVE on the grant, exactly as slice 1 did. A gesture
+// that activates alongside it — the only way that can happen is a simultaneous
+// relation, see `shouldBeCancelledBy` — does NOT ask, because the interaction
+// is already ours and there is nothing left to tell GTK. It becomes ACTIVE in
+// this registry and is driven from the touch props, which fire regardless of
+// responder status.
+//
+// Restated from behaviour, not transcribed: docs/research/gesture-detector.md,
+// "Probe 2: what the orchestrator actually guarantees", has the specification
+// this implements and the five rules it has to honour.
+import { createRelationRegistry } from "./relations";
+import { GESTURE_STATE } from "./types";
+export const createOrchestrator = (relations = createRelationRegistry()) => {
+    const entries = new Map();
+    /** Recording order, because the broadcast cancel walks it backwards. */
+    const recorded = [];
+    const awaiting = [];
+    let activationIndex = 0;
+    const isFinished = (entry) => entry.finishedAs !== null;
+    const live = (participant) => {
+        const entry = entries.get(participant);
+        return entry === undefined || isFinished(entry) ? null : entry;
+    };
+    const drop = (list, participant) => {
+        const index = list.indexOf(participant);
+        if (index >= 0) {
+            list.splice(index, 1);
+        }
+    };
+    const unpark = (participant) => {
+        const entry = entries.get(participant);
+        if (entry) {
+            entry.awaiting = false;
+        }
+        drop(awaiting, participant);
+    };
+    /**
+     * Finished gestures are kept until the next interaction starts, not dropped
+     * as they end, because `tryActivate` has to be able to tell a gesture it
+     * waits for that already ENDED apart from one that was never here. Upstream
+     * keeps them for a microtask and sweeps; sweeping at the next press is the
+     * same guarantee without a scheduler, and a press is the only moment that
+     * can put a gesture back into play.
+     */
+    const sweepFinished = () => {
+        for (const participant of [...recorded]) {
+            const entry = entries.get(participant);
+            if (entry !== undefined && isFinished(entry)) {
+                entries.delete(participant);
+                drop(recorded, participant);
+                drop(awaiting, participant);
+            }
+        }
+    };
+    /**
+     * A simultaneous relation in EITHER direction exempts the pair, and a
+     * gesture is always simultaneous with itself. Declaring it on one side is
+     * enough — upstream also copies the relation onto the other gesture, which
+     * this question makes unnecessary.
+     */
+    const canRunSimultaneously = (one, other) => one === other ||
+        relations.shouldRecognizeSimultaneously(one.tag, other.tag) ||
+        relations.shouldRecognizeSimultaneously(other.tag, one.tag);
+    /**
+     * The two spellings of one relation: `requireExternalGestureToFail` on the
+     * waiter, and `blocksExternalGesture` on the gesture being waited for.
+     */
+    const shouldWaitForOther = (participant, other) => participant !== other &&
+        (relations.shouldWaitForFailure(participant.tag, other.tag) ||
+            relations.blocks(other.tag, participant.tag));
+    /**
+     * The one rule the relation registry contributes: a gesture that is already
+     * ACTIVE, or parked waiting for another to fail, is cancelled only by an
+     * active `Native` handler.
+     *
+     * Upstream exempts buttons from this too (`isButton()`); the button family —
+     * `RectButton`, `BaseButton` and the rest — is refused by name on this
+     * platform, so there is nothing for the exemption to apply to and adding a
+     * flag nobody can set would be decoration.
+     */
+    const cancelledByActive = (other) => other.kind === "native" && entries.get(other)?.active === true;
+    /**
+     * Should `participant` be cancelled because `winner` just activated?
+     *
+     * MUTUAL EXCLUSION IS THE DEFAULT and a simultaneous relation is the only
+     * exemption. Upstream's third branch — two handlers that share no pointer
+     * and sit on different views conflict only if a tracked pointer lies inside
+     * both views' bounds — has no reachable case here: there is one pointer,
+     * one interaction and one fabricated touch, a gesture is recorded only when
+     * that touch reaches it, so every pair of recorded gestures shares it. What
+     * upstream computes in that branch, this platform knows by construction.
+     */
+    const shouldBeCancelledBy = (participant, winner) => {
+        if (canRunSimultaneously(participant, winner)) {
+            return false;
+        }
+        const entry = entries.get(participant);
+        if (entry?.active === true || entry?.awaiting === true) {
+            return cancelledByActive(winner);
+        }
+        return true;
+    };
+    /** The same question asked by the gesture that wants to activate. */
+    const blockedFromActivating = (participant) => recorded.some((other) => other !== participant &&
+        !canRunSimultaneously(participant, other) &&
+        cancelledByActive(other));
+    const park = (participant) => {
+        const entry = entries.get(participant);
+        if (entry === undefined || entry.awaiting) {
+            return;
+        }
+        entry.awaiting = true;
+        entry.activationIndex = activationIndex;
+        activationIndex += 1;
+        awaiting.push(participant);
+    };
+    const makeActive = (participant) => {
+        const entry = entries.get(participant);
+        if (entry === undefined) {
+            return;
+        }
+        entry.activationIndex = activationIndex;
+        activationIndex += 1;
+        // The interaction is already React Native's once another gesture HOLDS
+        // it, and `grant()` is a no-op for the GTK claim after the first one
+        // anyway. So a second gesture does not ask for the responder — it would be
+        // asking for a lock that is single-holder by design, and winning it would
+        // take the interaction away from the gesture it was told to run alongside.
+        //
+        // Holding, not merely being active: an active `Gesture.Native()` holds
+        // nothing on purpose, so a pan beside it still has a lock to take.
+        const held = recorded.some((other) => other !== participant &&
+            entries.get(other)?.active === true &&
+            other.holdsResponder());
+        participant.authorize(!held);
+    };
+    const tryActivate = (participant) => {
+        const entry = live(participant);
+        if (entry === null || entry.active) {
+            return;
+        }
+        // Waiting for a gesture that already ENDED is not waiting, it is losing:
+        // the thing this one was deferring to actually happened.
+        if (recorded.some((other) => shouldWaitForOther(participant, other) &&
+            entries.get(other)?.finishedAs === GESTURE_STATE.END)) {
+            unpark(participant);
+            participant.cancel();
+            return;
+        }
+        // Rule 1: park in BEGAN, holding nothing, until the other one finishes.
+        // This is what `requireExternalGestureToFail` IS.
+        if (recorded.some((other) => live(other) !== null && shouldWaitForOther(participant, other))) {
+            park(participant);
+            return;
+        }
+        if (blockedFromActivating(participant)) {
+            unpark(participant);
+            participant.cancel();
+            return;
+        }
+        makeActive(participant);
+    };
+    const activated = (participant) => {
+        const entry = entries.get(participant);
+        if (entry === undefined) {
+            return;
+        }
+        entry.active = true;
+        unpark(participant);
+        // Upstream cancels the losers inside `makeActive`, because activation is
+        // synchronous there. Here it is not always: a gesture that has to take the
+        // responder first becomes ACTIVE only when the negotiation grants it, and
+        // an ancestor can still win. Cancelling from the moment the gesture really
+        // is ACTIVE is the same rule applied at the only moment it is true.
+        for (let i = recorded.length - 1; i >= 0; i -= 1) {
+            const other = recorded[i];
+            if (other !== participant && live(other) !== null) {
+                if (shouldBeCancelledBy(other, participant)) {
+                    other.cancel();
+                }
+            }
+        }
+    };
+    const finished = (participant, outcome) => {
+        const entry = entries.get(participant);
+        if (entry === undefined) {
+            return;
+        }
+        entry.finishedAs = outcome;
+        entry.active = false;
+        unpark(participant);
+        // Rule 4: FAILED or CANCELLED releases the waiters, END cancels them.
+        for (const other of [...awaiting]) {
+            if (!shouldWaitForOther(other, participant)) {
+                continue;
+            }
+            unpark(other);
+            if (outcome === GESTURE_STATE.END) {
+                other.cancel();
+                continue;
+            }
+            tryActivate(other);
+        }
+    };
+    return {
+        relations,
+        record: (participant) => {
+            // A press is the only thing that puts a gesture back into play, so it is
+            // also where the previous interaction's leftovers go.
+            sweepFinished();
+            const existing = entries.get(participant);
+            if (existing !== undefined) {
+                existing.active = false;
+                existing.awaiting = false;
+                existing.finishedAs = null;
+                existing.activationIndex = Number.MAX_SAFE_INTEGER;
+                drop(awaiting, participant);
+                return;
+            }
+            entries.set(participant, {
+                active: false,
+                awaiting: false,
+                activationIndex: Number.MAX_SAFE_INTEGER,
+                finishedAs: null,
+            });
+            recorded.push(participant);
+        },
+        forget: (participant) => {
+            entries.delete(participant);
+            drop(recorded, participant);
+            drop(awaiting, participant);
+            relations.drop(participant.tag);
+        },
+        tryActivate,
+        activated,
+        finished,
+        interactionLost: (participant) => {
+            for (const other of [...recorded]) {
+                if (other !== participant && entries.get(other)?.active === true) {
+                    other.cancel();
+                }
+            }
+        },
+        isAwaiting: (participant) => entries.get(participant)?.awaiting === true,
+        activeTags: () => recorded
+            .filter((participant) => entries.get(participant)?.active === true)
+            .map((participant) => participant.tag),
+        reset: () => {
+            entries.clear();
+            recorded.length = 0;
+            awaiting.length = 0;
+            activationIndex = 0;
+            relations.reset();
+        },
+    };
+};
+/**
+ * The process-wide loop, which is the right scope for it and needs saying
+ * because the responder lock's scope is the question slice 3 had to answer.
+ *
+ * This registry has NO tree knowledge at all: it is keyed by handler tag and
+ * a gesture enters it only when the interaction's pointer reaches it. That is
+ * what makes the islands answer simple — see docs/api.md, "Relations across
+ * `Root`s". A relation naming a gesture in another `Root` is expressible and
+ * simply never has an occasion to apply, because a gesture in another `Root`
+ * is never recorded during this interaction. In particular it does not
+ * deadlock: parking only ever happens against a gesture that is live in the
+ * interaction under way.
+ */
+export const gestureOrchestrator = createOrchestrator();
+//# sourceMappingURL=orchestrator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/orchestrator.ts"],"names":[],"mappings":"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","sourcesContent":["// The activation loop: one place where every gesture in an interaction asks\n// whether it may become active, and one place where an activation cancels\n// everything it excludes.\n//\n// THE SECOND LOCK. The responder lock (src/responder) keeps its one job —\n// this interaction belongs to React Native, one holder, one irrevocable GTK\n// `CLAIMED` on the source. This loop is the second lock, at the second level,\n// and it is JS-only by construction: it imports nothing from the platform,\n// takes no widget, and never makes GTK claim anything. Every relation is\n// resolved here BEFORE the responder lock is asked for, which is what makes\n// the model honest given that GTK's `CLAIMED` cannot be taken back.\n//\n// Concretely: the FIRST gesture to activate in an interaction asks for the\n// responder and becomes ACTIVE on the grant, exactly as slice 1 did. A gesture\n// that activates alongside it — the only way that can happen is a simultaneous\n// relation, see `shouldBeCancelledBy` — does NOT ask, because the interaction\n// is already ours and there is nothing left to tell GTK. It becomes ACTIVE in\n// this registry and is driven from the touch props, which fire regardless of\n// responder status.\n//\n// Restated from behaviour, not transcribed: docs/research/gesture-detector.md,\n// \"Probe 2: what the orchestrator actually guarantees\", has the specification\n// this implements and the five rules it has to honour.\nimport { createRelationRegistry, type RelationRegistry } from \"./relations\"\nimport { GESTURE_STATE, type GestureStateValue } from \"./types\"\n\n/** One mounted recognizer, as the loop sees it. */\nexport type Participant = {\n  readonly tag: number\n  /**\n   * The recognizer kind.\n   *\n   * The loop reads exactly one thing off it — whether this is\n   * `Gesture.Native()` — because that is the single rule the relation\n   * registry contributes to cancellation, and it is why `Native` is special\n   * rather than just another recognizer: an ALREADY ACTIVE or parked gesture\n   * is cancelled by nothing except an active native one, and a gesture that\n   * wants to activate beside one is refused by it. `@gorhom/bottom-sheet`'s\n   * scrollable is the shape that needs both halves.\n   */\n  readonly kind: string\n  /**\n   * Cleared to become ACTIVE.\n   *\n   * `needsResponder` is false when another participant already holds the\n   * interaction, and it is where the two locks meet: a gesture told `false`\n   * activates in JS without touching the responder lock, which is the only\n   * way `Simultaneous` can be expressed on a single-holder lock.\n   */\n  authorize: (needsResponder: boolean) => void\n  /**\n   * Whether this gesture is holding the responder right now.\n   *\n   * Asked rather than assumed, because \"is anything else active\" is the wrong\n   * question and `Gesture.Native()` is what makes the difference visible: it\n   * is ACTIVE and it deliberately holds nothing, so a pan activating beside it\n   * still has an interaction to take. Nor is it a static per-kind fact — a\n   * `Pan` that lost the lock to a simultaneous partner is a claiming kind that\n   * does not hold it either.\n   */\n  holdsResponder: () => boolean\n  /** Lost the arbitration: end now, unsuccessfully. */\n  cancel: () => void\n}\n\ntype Entry = {\n  active: boolean\n  awaiting: boolean\n  /** Upstream's `activationIndex`: the order gestures took their turn in. */\n  activationIndex: number\n  /** END / FAILED / CANCELLED once it is over, null while it is live. */\n  finishedAs: GestureStateValue | null\n}\n\nexport type Orchestrator = {\n  readonly relations: RelationRegistry\n  /** This gesture reached BEGAN and is part of the interaction under way. */\n  record: (participant: Participant) => void\n  /** This gesture unmounted. Drops its relations with it. */\n  forget: (participant: Participant) => void\n  /** This gesture's own criteria are met; may it activate? */\n  tryActivate: (participant: Participant) => void\n  /** It really is ACTIVE now — the moment mutual exclusion is enforced. */\n  activated: (participant: Participant) => void\n  finished: (participant: Participant, outcome: GestureStateValue) => void\n  /**\n   * The participant holding the responder lost it to something outside this\n   * registry — an ancestor took the interaction, or the window went away.\n   */\n  interactionLost: (participant: Participant) => void\n  /** Whether the loop is holding this one in BEGAN, waiting on another. */\n  isAwaiting: (participant: Participant) => boolean\n  /** Every tag ACTIVE right now. `Simultaneous` is a claim about this list. */\n  activeTags: () => number[]\n  reset: () => void\n}\n\nexport const createOrchestrator = (\n  relations: RelationRegistry = createRelationRegistry(),\n): Orchestrator => {\n  const entries = new Map<Participant, Entry>()\n  /** Recording order, because the broadcast cancel walks it backwards. */\n  const recorded: Participant[] = []\n  const awaiting: Participant[] = []\n  let activationIndex = 0\n\n  const isFinished = (entry: Entry): boolean => entry.finishedAs !== null\n\n  const live = (participant: Participant): Entry | null => {\n    const entry = entries.get(participant)\n    return entry === undefined || isFinished(entry) ? null : entry\n  }\n\n  const drop = (list: Participant[], participant: Participant): void => {\n    const index = list.indexOf(participant)\n    if (index >= 0) {\n      list.splice(index, 1)\n    }\n  }\n\n  const unpark = (participant: Participant): void => {\n    const entry = entries.get(participant)\n    if (entry) {\n      entry.awaiting = false\n    }\n    drop(awaiting, participant)\n  }\n\n  /**\n   * Finished gestures are kept until the next interaction starts, not dropped\n   * as they end, because `tryActivate` has to be able to tell a gesture it\n   * waits for that already ENDED apart from one that was never here. Upstream\n   * keeps them for a microtask and sweeps; sweeping at the next press is the\n   * same guarantee without a scheduler, and a press is the only moment that\n   * can put a gesture back into play.\n   */\n  const sweepFinished = (): void => {\n    for (const participant of [...recorded]) {\n      const entry = entries.get(participant)\n      if (entry !== undefined && isFinished(entry)) {\n        entries.delete(participant)\n        drop(recorded, participant)\n        drop(awaiting, participant)\n      }\n    }\n  }\n\n  /**\n   * A simultaneous relation in EITHER direction exempts the pair, and a\n   * gesture is always simultaneous with itself. Declaring it on one side is\n   * enough — upstream also copies the relation onto the other gesture, which\n   * this question makes unnecessary.\n   */\n  const canRunSimultaneously = (\n    one: Participant,\n    other: Participant,\n  ): boolean =>\n    one === other ||\n    relations.shouldRecognizeSimultaneously(one.tag, other.tag) ||\n    relations.shouldRecognizeSimultaneously(other.tag, one.tag)\n\n  /**\n   * The two spellings of one relation: `requireExternalGestureToFail` on the\n   * waiter, and `blocksExternalGesture` on the gesture being waited for.\n   */\n  const shouldWaitForOther = (\n    participant: Participant,\n    other: Participant,\n  ): boolean =>\n    participant !== other &&\n    (relations.shouldWaitForFailure(participant.tag, other.tag) ||\n      relations.blocks(other.tag, participant.tag))\n\n  /**\n   * The one rule the relation registry contributes: a gesture that is already\n   * ACTIVE, or parked waiting for another to fail, is cancelled only by an\n   * active `Native` handler.\n   *\n   * Upstream exempts buttons from this too (`isButton()`); the button family —\n   * `RectButton`, `BaseButton` and the rest — is refused by name on this\n   * platform, so there is nothing for the exemption to apply to and adding a\n   * flag nobody can set would be decoration.\n   */\n  const cancelledByActive = (other: Participant): boolean =>\n    other.kind === \"native\" && entries.get(other)?.active === true\n\n  /**\n   * Should `participant` be cancelled because `winner` just activated?\n   *\n   * MUTUAL EXCLUSION IS THE DEFAULT and a simultaneous relation is the only\n   * exemption. Upstream's third branch — two handlers that share no pointer\n   * and sit on different views conflict only if a tracked pointer lies inside\n   * both views' bounds — has no reachable case here: there is one pointer,\n   * one interaction and one fabricated touch, a gesture is recorded only when\n   * that touch reaches it, so every pair of recorded gestures shares it. What\n   * upstream computes in that branch, this platform knows by construction.\n   */\n  const shouldBeCancelledBy = (\n    participant: Participant,\n    winner: Participant,\n  ): boolean => {\n    if (canRunSimultaneously(participant, winner)) {\n      return false\n    }\n    const entry = entries.get(participant)\n    if (entry?.active === true || entry?.awaiting === true) {\n      return cancelledByActive(winner)\n    }\n    return true\n  }\n\n  /** The same question asked by the gesture that wants to activate. */\n  const blockedFromActivating = (participant: Participant): boolean =>\n    recorded.some(\n      (other) =>\n        other !== participant &&\n        !canRunSimultaneously(participant, other) &&\n        cancelledByActive(other),\n    )\n\n  const park = (participant: Participant): void => {\n    const entry = entries.get(participant)\n    if (entry === undefined || entry.awaiting) {\n      return\n    }\n    entry.awaiting = true\n    entry.activationIndex = activationIndex\n    activationIndex += 1\n    awaiting.push(participant)\n  }\n\n  const makeActive = (participant: Participant): void => {\n    const entry = entries.get(participant)\n    if (entry === undefined) {\n      return\n    }\n    entry.activationIndex = activationIndex\n    activationIndex += 1\n    // The interaction is already React Native's once another gesture HOLDS\n    // it, and `grant()` is a no-op for the GTK claim after the first one\n    // anyway. So a second gesture does not ask for the responder — it would be\n    // asking for a lock that is single-holder by design, and winning it would\n    // take the interaction away from the gesture it was told to run alongside.\n    //\n    // Holding, not merely being active: an active `Gesture.Native()` holds\n    // nothing on purpose, so a pan beside it still has a lock to take.\n    const held = recorded.some(\n      (other) =>\n        other !== participant &&\n        entries.get(other)?.active === true &&\n        other.holdsResponder(),\n    )\n    participant.authorize(!held)\n  }\n\n  const tryActivate = (participant: Participant): void => {\n    const entry = live(participant)\n    if (entry === null || entry.active) {\n      return\n    }\n\n    // Waiting for a gesture that already ENDED is not waiting, it is losing:\n    // the thing this one was deferring to actually happened.\n    if (\n      recorded.some(\n        (other) =>\n          shouldWaitForOther(participant, other) &&\n          entries.get(other)?.finishedAs === GESTURE_STATE.END,\n      )\n    ) {\n      unpark(participant)\n      participant.cancel()\n      return\n    }\n\n    // Rule 1: park in BEGAN, holding nothing, until the other one finishes.\n    // This is what `requireExternalGestureToFail` IS.\n    if (\n      recorded.some(\n        (other) =>\n          live(other) !== null && shouldWaitForOther(participant, other),\n      )\n    ) {\n      park(participant)\n      return\n    }\n\n    if (blockedFromActivating(participant)) {\n      unpark(participant)\n      participant.cancel()\n      return\n    }\n\n    makeActive(participant)\n  }\n\n  const activated = (participant: Participant): void => {\n    const entry = entries.get(participant)\n    if (entry === undefined) {\n      return\n    }\n    entry.active = true\n    unpark(participant)\n\n    // Upstream cancels the losers inside `makeActive`, because activation is\n    // synchronous there. Here it is not always: a gesture that has to take the\n    // responder first becomes ACTIVE only when the negotiation grants it, and\n    // an ancestor can still win. Cancelling from the moment the gesture really\n    // is ACTIVE is the same rule applied at the only moment it is true.\n    for (let i = recorded.length - 1; i >= 0; i -= 1) {\n      const other = recorded[i]!\n      if (other !== participant && live(other) !== null) {\n        if (shouldBeCancelledBy(other, participant)) {\n          other.cancel()\n        }\n      }\n    }\n  }\n\n  const finished = (\n    participant: Participant,\n    outcome: GestureStateValue,\n  ): void => {\n    const entry = entries.get(participant)\n    if (entry === undefined) {\n      return\n    }\n    entry.finishedAs = outcome\n    entry.active = false\n    unpark(participant)\n\n    // Rule 4: FAILED or CANCELLED releases the waiters, END cancels them.\n    for (const other of [...awaiting]) {\n      if (!shouldWaitForOther(other, participant)) {\n        continue\n      }\n      unpark(other)\n      if (outcome === GESTURE_STATE.END) {\n        other.cancel()\n        continue\n      }\n      tryActivate(other)\n    }\n  }\n\n  return {\n    relations,\n\n    record: (participant) => {\n      // A press is the only thing that puts a gesture back into play, so it is\n      // also where the previous interaction's leftovers go.\n      sweepFinished()\n      const existing = entries.get(participant)\n      if (existing !== undefined) {\n        existing.active = false\n        existing.awaiting = false\n        existing.finishedAs = null\n        existing.activationIndex = Number.MAX_SAFE_INTEGER\n        drop(awaiting, participant)\n        return\n      }\n      entries.set(participant, {\n        active: false,\n        awaiting: false,\n        activationIndex: Number.MAX_SAFE_INTEGER,\n        finishedAs: null,\n      })\n      recorded.push(participant)\n    },\n\n    forget: (participant) => {\n      entries.delete(participant)\n      drop(recorded, participant)\n      drop(awaiting, participant)\n      relations.drop(participant.tag)\n    },\n\n    tryActivate,\n    activated,\n    finished,\n\n    interactionLost: (participant) => {\n      for (const other of [...recorded]) {\n        if (other !== participant && entries.get(other)?.active === true) {\n          other.cancel()\n        }\n      }\n    },\n\n    isAwaiting: (participant) => entries.get(participant)?.awaiting === true,\n\n    activeTags: () =>\n      recorded\n        .filter((participant) => entries.get(participant)?.active === true)\n        .map((participant) => participant.tag),\n\n    reset: () => {\n      entries.clear()\n      recorded.length = 0\n      awaiting.length = 0\n      activationIndex = 0\n      relations.reset()\n    },\n  }\n}\n\n/**\n * The process-wide loop, which is the right scope for it and needs saying\n * because the responder lock's scope is the question slice 3 had to answer.\n *\n * This registry has NO tree knowledge at all: it is keyed by handler tag and\n * a gesture enters it only when the interaction's pointer reaches it. That is\n * what makes the islands answer simple — see docs/api.md, \"Relations across\n * `Root`s\". A relation naming a gesture in another `Root` is expressible and\n * simply never has an occasion to apply, because a gesture in another `Root`\n * is never recorded during this interaction. In particular it does not\n * deadlock: parking only ever happens against a gesture that is live in the\n * interaction under way.\n */\nexport const gestureOrchestrator = createOrchestrator()\n"]}

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

@@ -0,0 +1,23 @@
+import type { RecognizerDecider } from "./recognizer";
+import type { OffsetBound, RecognizerConfig } from "./types";
+/** Upstream's default minimum travel before an unconfigured pan activates. */
+export declare const DEFAULT_MIN_DISTANCE = 10;
+/**
+ * A bound in its two spellings, normalised to `[low, high]`.
+ *
+ * The single-number form is DIRECTIONAL and the direction is the sign:
+ * `activeOffsetX(20)` bounds the positive side and leaves the negative side
+ * open, `activeOffsetX(-20)` the reverse. Reading it as a symmetric ±20 turns
+ * a one-way drawer into a two-way one, and does it silently.
+ */
+export declare const asRange: (value: OffsetBound) => [number, number];
+/**
+ * The distance that activates an otherwise unconfigured pan.
+ *
+ * An explicit `minDistance` always wins. Otherwise a config that names its
+ * own activation criteria opts OUT of the distance rule entirely — the
+ * offsets are the criteria, and a 10px fallback underneath them would
+ * activate diagonal drags neither offset asked for.
+ */
+export declare const effectiveMinDistance: (config: RecognizerConfig) => number;
+export declare const panDecider: RecognizerDecider;

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

@@ -0,0 +1,116 @@
+/** Upstream's default minimum travel before an unconfigured pan activates. */
+export const DEFAULT_MIN_DISTANCE = 10;
+/**
+ * A bound in its two spellings, normalised to `[low, high]`.
+ *
+ * The single-number form is DIRECTIONAL and the direction is the sign:
+ * `activeOffsetX(20)` bounds the positive side and leaves the negative side
+ * open, `activeOffsetX(-20)` the reverse. Reading it as a symmetric ±20 turns
+ * a one-way drawer into a two-way one, and does it silently.
+ */
+export const asRange = (value) => {
+    if (typeof value !== "number") {
+        return [value[0], value[1]];
+    }
+    return value < 0
+        ? [value, Number.POSITIVE_INFINITY]
+        : [Number.NEGATIVE_INFINITY, value];
+};
+const crosses = (value, bound) => {
+    if (bound === undefined) {
+        return false;
+    }
+    const [low, high] = asRange(bound);
+    return value < low || value > high;
+};
+/**
+ * Whether the config names its own activation criteria.
+ *
+ * `failOffset*` is deliberately NOT in this set, and that is a correction to
+ * the spike this module grew out of. A pan configured with only
+ * `failOffsetY([-5, 5])` still activates on ordinary distance upstream;
+ * treating a failure bound as an activation criterion would pin `minDistance`
+ * at infinity and the gesture could never start at all.
+ */
+const hasCustomActivationCriteria = (config) => config.activeOffsetX !== undefined ||
+    config.activeOffsetY !== undefined ||
+    config.minVelocity !== undefined ||
+    config.minVelocityX !== undefined ||
+    config.minVelocityY !== undefined;
+/**
+ * The distance that activates an otherwise unconfigured pan.
+ *
+ * An explicit `minDistance` always wins. Otherwise a config that names its
+ * own activation criteria opts OUT of the distance rule entirely — the
+ * offsets are the criteria, and a 10px fallback underneath them would
+ * activate diagonal drags neither offset asked for.
+ */
+export const effectiveMinDistance = (config) => {
+    if (config.minDistance !== undefined) {
+        return config.minDistance;
+    }
+    return hasCustomActivationCriteria(config)
+        ? Number.POSITIVE_INFINITY
+        : DEFAULT_MIN_DISTANCE;
+};
+const exceeds = (value, floor) => floor !== undefined && Math.abs(value) >= floor;
+/**
+ * Whether this pan has to be HELD before it may activate.
+ *
+ * `> 0`, not "was set": upstream's default for the option is the number `0`,
+ * and both of its own implementations guard on `activateAfterLongPress > 0`
+ * (`src/web/handlers/PanGestureHandler.ts`, `PanGestureHandler.kt`). So
+ * passing `0` explicitly means "no hold at all" there, and reading it as
+ * "a hold of zero" is not the same thing: it arms a zero-delay timer and,
+ * until that timer has fired, the failure test below turns any movement past
+ * the default minimum into a DEAD gesture. `react-native-reanimated-dnd`'s
+ * `SortableGrid` takes an `activationDelay` prop and hands it straight
+ * through, so `activationDelay={0}` — the natural thing for a desktop app
+ * whose users drag with a mouse rather than long-pressing — used to produce a
+ * grid that could not be dragged at all.
+ */
+const holdsBeforeActivating = (config) => config.activateAfterLongPress !== undefined &&
+    config.activateAfterLongPress > 0;
+export const panDecider = {
+    kind: "pan",
+    /** Only `activateAfterLongPress` arms one; an ordinary pan has no clock. */
+    timer: (config) => holdsBeforeActivating(config)
+        ? { delay: config.activateAfterLongPress, elapsed: "activate" }
+        : null,
+    shouldFail: (view, config) => {
+        if (holdsBeforeActivating(config) && !view.timerElapsed) {
+            // Before the timer, travelling further than the default minimum says
+            // this was a drag rather than a hold, and the gesture is done. Past the
+            // timer the press has matured and the ordinary bounds take over.
+            return (Math.hypot(view.translationX, view.translationY) > DEFAULT_MIN_DISTANCE);
+        }
+        return (crosses(view.translationX, config.failOffsetX) ||
+            crosses(view.translationY, config.failOffsetY));
+    },
+    shouldActivate: (view, config) => {
+        // The timer is an activation criterion in its own right, and the only one
+        // that does not come from the pointer. Checked first because the pointer
+        // has not necessarily moved at all when it fires.
+        if (view.timerElapsed) {
+            return true;
+        }
+        if (crosses(view.translationX, config.activeOffsetX) ||
+            crosses(view.translationY, config.activeOffsetY)) {
+            return true;
+        }
+        if (exceeds(view.velocityX, config.minVelocityX) ||
+            exceeds(view.velocityY, config.minVelocityY) ||
+            exceeds(Math.hypot(view.velocityX, view.velocityY), config.minVelocity)) {
+            return true;
+        }
+        const minDistance = effectiveMinDistance(config);
+        if (!Number.isFinite(minDistance)) {
+            return false;
+        }
+        // Non-strict, where the failure test above is strict: a translation
+        // sitting exactly on a bound activates rather than fails. That asymmetry
+        // is upstream's.
+        return Math.hypot(view.translationX, view.translationY) >= minDistance;
+    },
+};
+//# sourceMappingURL=pan.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pan.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/pan.ts"],"names":[],"mappings":"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","sourcesContent":["// Pan's two predicates, and the defaults that decide when they are consulted.\n//\n// The arithmetic is restated from upstream's BEHAVIOUR, not transcribed from\n// its source: activation when the translation crosses an `activeOffset*`\n// bound, or exceeds a velocity floor, or covers `minDistance`; failure when\n// it crosses a `failOffset*` bound; and, with `activateAfterLongPress` set,\n// movement past the default minimum before the timer fires is a failure,\n// because that press was a drag and not a hold.\nimport type {\n  RecognizerDecider,\n  RecognizerTimer,\n  RecognizerView,\n} from \"./recognizer\"\nimport type { OffsetBound, RecognizerConfig } from \"./types\"\n\n/** Upstream's default minimum travel before an unconfigured pan activates. */\nexport const DEFAULT_MIN_DISTANCE = 10\n\n/**\n * A bound in its two spellings, normalised to `[low, high]`.\n *\n * The single-number form is DIRECTIONAL and the direction is the sign:\n * `activeOffsetX(20)` bounds the positive side and leaves the negative side\n * open, `activeOffsetX(-20)` the reverse. Reading it as a symmetric ±20 turns\n * a one-way drawer into a two-way one, and does it silently.\n */\nexport const asRange = (value: OffsetBound): [number, number] => {\n  if (typeof value !== \"number\") {\n    return [value[0], value[1]]\n  }\n  return value < 0\n    ? [value, Number.POSITIVE_INFINITY]\n    : [Number.NEGATIVE_INFINITY, value]\n}\n\nconst crosses = (value: number, bound: OffsetBound | undefined): boolean => {\n  if (bound === undefined) {\n    return false\n  }\n  const [low, high] = asRange(bound)\n  return value < low || value > high\n}\n\n/**\n * Whether the config names its own activation criteria.\n *\n * `failOffset*` is deliberately NOT in this set, and that is a correction to\n * the spike this module grew out of. A pan configured with only\n * `failOffsetY([-5, 5])` still activates on ordinary distance upstream;\n * treating a failure bound as an activation criterion would pin `minDistance`\n * at infinity and the gesture could never start at all.\n */\nconst hasCustomActivationCriteria = (config: RecognizerConfig): boolean =>\n  config.activeOffsetX !== undefined ||\n  config.activeOffsetY !== undefined ||\n  config.minVelocity !== undefined ||\n  config.minVelocityX !== undefined ||\n  config.minVelocityY !== undefined\n\n/**\n * The distance that activates an otherwise unconfigured pan.\n *\n * An explicit `minDistance` always wins. Otherwise a config that names its\n * own activation criteria opts OUT of the distance rule entirely — the\n * offsets are the criteria, and a 10px fallback underneath them would\n * activate diagonal drags neither offset asked for.\n */\nexport const effectiveMinDistance = (config: RecognizerConfig): number => {\n  if (config.minDistance !== undefined) {\n    return config.minDistance\n  }\n  return hasCustomActivationCriteria(config)\n    ? Number.POSITIVE_INFINITY\n    : DEFAULT_MIN_DISTANCE\n}\n\nconst exceeds = (value: number, floor: number | undefined): boolean =>\n  floor !== undefined && Math.abs(value) >= floor\n\n/**\n * Whether this pan has to be HELD before it may activate.\n *\n * `> 0`, not \"was set\": upstream's default for the option is the number `0`,\n * and both of its own implementations guard on `activateAfterLongPress > 0`\n * (`src/web/handlers/PanGestureHandler.ts`, `PanGestureHandler.kt`). So\n * passing `0` explicitly means \"no hold at all\" there, and reading it as\n * \"a hold of zero\" is not the same thing: it arms a zero-delay timer and,\n * until that timer has fired, the failure test below turns any movement past\n * the default minimum into a DEAD gesture. `react-native-reanimated-dnd`'s\n * `SortableGrid` takes an `activationDelay` prop and hands it straight\n * through, so `activationDelay={0}` — the natural thing for a desktop app\n * whose users drag with a mouse rather than long-pressing — used to produce a\n * grid that could not be dragged at all.\n */\nconst holdsBeforeActivating = (config: RecognizerConfig): boolean =>\n  config.activateAfterLongPress !== undefined &&\n  config.activateAfterLongPress > 0\n\nexport const panDecider: RecognizerDecider = {\n  kind: \"pan\",\n\n  /** Only `activateAfterLongPress` arms one; an ordinary pan has no clock. */\n  timer: (config: RecognizerConfig): RecognizerTimer | null =>\n    holdsBeforeActivating(config)\n      ? { delay: config.activateAfterLongPress!, elapsed: \"activate\" }\n      : null,\n\n  shouldFail: (view: RecognizerView, config: RecognizerConfig): boolean => {\n    if (holdsBeforeActivating(config) && !view.timerElapsed) {\n      // Before the timer, travelling further than the default minimum says\n      // this was a drag rather than a hold, and the gesture is done. Past the\n      // timer the press has matured and the ordinary bounds take over.\n      return (\n        Math.hypot(view.translationX, view.translationY) > DEFAULT_MIN_DISTANCE\n      )\n    }\n    return (\n      crosses(view.translationX, config.failOffsetX) ||\n      crosses(view.translationY, config.failOffsetY)\n    )\n  },\n\n  shouldActivate: (view: RecognizerView, config: RecognizerConfig): boolean => {\n    // The timer is an activation criterion in its own right, and the only one\n    // that does not come from the pointer. Checked first because the pointer\n    // has not necessarily moved at all when it fires.\n    if (view.timerElapsed) {\n      return true\n    }\n    if (\n      crosses(view.translationX, config.activeOffsetX) ||\n      crosses(view.translationY, config.activeOffsetY)\n    ) {\n      return true\n    }\n    if (\n      exceeds(view.velocityX, config.minVelocityX) ||\n      exceeds(view.velocityY, config.minVelocityY) ||\n      exceeds(Math.hypot(view.velocityX, view.velocityY), config.minVelocity)\n    ) {\n      return true\n    }\n    const minDistance = effectiveMinDistance(config)\n    if (!Number.isFinite(minDistance)) {\n      return false\n    }\n    // Non-strict, where the failure test above is strict: a translation\n    // sitting exactly on a bound activates rather than fails. That asymmetry\n    // is upstream's.\n    return Math.hypot(view.translationX, view.translationY) >= minDistance\n  },\n}\n"]}