@astryxdesign/core 0.7.5 → 0.7.6-canary.0135af4

package/dist/gestures/GestureArena.js

@@ -56,7 +56,12 @@ export const browserClock = {
  * be swallowed now and replayed if the recognizers holding it all fail.
  */
 
+/**
+ * The arena that decides which recognizer gets a touch.
+ */
 export class GestureArena {
+  /** The touches whose move the arena is delivering right now. */
+  movingIds = new Set();
   records = new Map();
   /** Recognizers involved in the current interaction, in resolution order. */
   active = [];
@@ -68,6 +73,10 @@ export class GestureArena {
   /** The latest time processed: input never moves the clock backwards. */
   latestTime = Number.NEGATIVE_INFINITY;
   depth = 0;
+  /** Open `deferResolution` calls: what their stops unblock waits. */
+  deferDepth = 0;
+  /** A deferred stop left recognitions, held touches or resets to settle. */
+  owesResolution = false;
   constructor(options = {}) {
     this.options = options;
     this.clock = options.clock ?? browserClock;
@@ -195,6 +204,45 @@ export class GestureArena {
     });
   }
 
+  /**
+   * A contact began where nothing takes part (plain page content). It is
+   * never tracked and stays the browser's; recognizers already tracking a
+   * gesture hear of it, as of any touch off their hit path.
+   */
+  untrackedBegan(input) {
+    if (!this.active.some(recognizer => recognizer.numberOfTouches > 0)) {
+      return;
+    }
+    this.run(input.time, () => {
+      const time = this.clampTime(input.time);
+      const touch = {
+        id: input.id,
+        pointerType: input.pointerType,
+        phase: 'began',
+        x: input.x,
+        y: input.y,
+        time,
+        startX: input.x,
+        startY: input.y,
+        startTime: time,
+        samples: [{
+          x: input.x,
+          y: input.y,
+          time
+        }],
+        target: input.target,
+        scroll: input.scroll ?? null,
+        takenByBrowser: false
+      };
+      const context = this.context();
+      for (const recognizer of [...this.active]) {
+        if (recognizer.numberOfTouches > 0) {
+          recognizer.deliverBeganElsewhere([touch], context);
+        }
+      }
+    });
+  }
+
   /** Contacts moved. */
   moved(inputs) {
     if (inputs.length === 0) {
@@ -206,8 +254,14 @@ export class GestureArena {
         return;
       }
       const context = this.context();
-      for (const recognizer of [...this.active]) {
-        recognizer.deliverMoved(changed, context);
+      const previous = this.movingIds;
+      this.movingIds = new Set(changed.map(touch => touch.id));
+      try {
+        for (const recognizer of [...this.active]) {
+          recognizer.deliverMoved(changed, context);
+        }
+      } finally {
+        this.movingIds = previous;
       }
       for (const touch of changed) {
         const record = this.records.get(touch.id);
@@ -351,11 +405,41 @@ export class GestureArena {
     }
   }
 
+  /**
+   * Runs `body`, code outside input that stops recognizers (an Effect that
+   * turns one off or detaches it), without resolving what those stops
+   * unblock: the recognitions waiting on them, the touches they held from a
+   * view, the resets. A pass a microtask later resolves all of it, at the
+   * last event's time, so the listeners and consumers it reaches hear it
+   * outside the caller's frame and read the recognized state
+   * (react-component-runtime INV2).
+   */
+  deferResolution(body) {
+    this.deferDepth += 1;
+    try {
+      body();
+    } finally {
+      this.deferDepth -= 1;
+    }
+    if (this.deferDepth === 0 && this.owesResolution) {
+      queueMicrotask(() => {
+        if (this.owesResolution && this.deferDepth === 0) {
+          this.run(this.lastEventTime(), () => {});
+        }
+      });
+    }
+  }
+
+  /** The last event's time, or now before any event. */
+  lastEventTime() {
+    return Number.isFinite(this.latestTime) ? this.latestTime : this.clock.now();
+  }
+
   /** Cancel an active recognizer, or fail a possible one. */
   stop(recognizer) {
     // A cancel from code between events happens at the last event's time:
     // wall time would run deadlines ahead of input still queued (FR16).
-    const time = this.currentTime ?? (Number.isFinite(this.latestTime) ? this.latestTime : this.clock.now());
+    const time = this.currentTime ?? this.lastEventTime();
     this.run(time, () => {
       if (isActive(recognizer.state)) {
         this.apply(recognizer, 'cancelled');
@@ -448,6 +532,11 @@ export class GestureArena {
     }
     recognizer.pending = null;
     this.apply(recognizer, 'failed');
+    if (this.deferDepth > 0) {
+      // Inside `deferResolution`, the next pass settles.
+      this.owesResolution = true;
+      return;
+    }
     this.reviewPending();
   }
 
@@ -455,12 +544,16 @@ export class GestureArena {
    * A recognition that claimed its touches and then fails or is cancelled (a
    * waiting recognition that fails, a gesture a second finger or the app
    * cancels) gives them back to the browser unless another recognition owns
-   * them, so a finger still resting there can pinch-zoom the page.
+   * them, so a finger still resting there can pinch-zoom the page. A gesture
+   * that cancels itself on a finger's move (a long press past its tolerance)
+   * keeps that finger until it lifts: the drag goes on, and the page never
+   * takes it over midway (`spec:AST-094` FR14), as UIKit's scroll view never
+   * takes a touch another recognizer had.
    */
-  releaseClaim(recognizer) {
+  releaseClaim(recognizer, keep = new Set()) {
     for (const touch of recognizer.trackedTouches) {
       const record = this.records.get(touch.id);
-      if (record == null || !record.isClaimed) {
+      if (record == null || !record.isClaimed || keep.has(touch.id)) {
         continue;
       }
       // A recognized discrete gesture (`ended`, a swipe) still owns its
@@ -482,7 +575,9 @@ export class GestureArena {
     if (isTerminal(next)) {
       this.clearTimer(recognizer);
     }
-    if (next === 'cancelled' || next === 'failed') {
+    if (next === 'cancelled') {
+      this.releaseClaim(recognizer, this.movingIds);
+    } else if (next === 'failed') {
       this.releaseClaim(recognizer);
     }
   }
@@ -701,9 +796,15 @@ export class GestureArena {
       this.currentTime = this.clampTime(time);
       body();
       // Re-entrant calls settle with the outermost one: settling mid-delivery
-      // would reset recognizers that have not heard the event yet.
+      // would reset recognizers that have not heard the event yet. Inside
+      // `deferResolution`, the next pass settles.
       if (this.depth === 1) {
-        this.settle();
+        if (this.deferDepth > 0) {
+          this.owesResolution = true;
+        } else {
+          this.owesResolution = false;
+          this.settle();
+        }
       }
     } finally {
       this.depth -= 1;

package/dist/gestures/GestureHost.d.ts

@@ -0,0 +1,351 @@
+import { GestureArena, type GestureArenaOptions, type GestureClock } from './GestureArena.js';
+import type { GestureRecognizer } from './GestureRecognizer.js';
+import type { GestureTouch, PointerKind, TouchConsumer } from './types.js';
+export interface GestureHostOptions {
+    /** The arena's clock; tests pass a manual one. */
+    clock?: GestureClock;
+    /**
+     * Where fingers come from: Touch Events where the browser has them
+     * (`auto`), or Pointer Events only.
+     */
+    inputMode?: 'auto' | 'pointer-events';
+    /** Every recognizer transition, for debugging and tests. */
+    onTransition?: GestureArenaOptions['onTransition'];
+    /**
+     * Whether the primary pointer is coarse (a phone, a tablet). Gestures
+     * attach for every pointer (`spec:AST-094` FR43); where it is fine, an
+     * element that uses a gesture keeps one passive `pointerdown` listener
+     * (beside a claiming recognizer's blocking `touchmove`, FR19) and the
+     * page's listeners last only a press (FR24).
+     * @default `(pointer: coarse)` on the document's window
+     */
+    isPrimaryPointerCoarse?: () => boolean;
+}
+export interface AttachOptions {
+    /**
+     * Let the host set the element's styles: its `touch-action`, and the
+     * selection and callout lock a hold that does something keeps while it is
+     * held (`spec:AST-094` FR41). With false the caller keeps both.
+     * @default true
+     */
+    manageStyle?: boolean;
+    /**
+     * The element is an action group, sibling actions a held pointer slides
+     * across (`family:action-groups` FR5). It is served like every
+     * attachment, for every pointer (`spec:AST-094` FR43). @default false
+     */
+    actionGroup?: boolean;
+}
+/**
+ * A kind of view-level consumer found by attribute instead of attached to
+ * each element.
+ */
+export interface DelegatedConsumerType {
+    /** Marks an element as this kind of consumer. */
+    readonly attribute: string;
+    /**
+     * The consumer for one contact on `element`, or null for none (a disabled
+     * control). The innermost marked element decides, even with null: a press
+     * on a disabled button does not light the row around it.
+     */
+    create(element: Element, pointerType: PointerKind): TouchConsumer | null;
+}
+export declare class GestureHost {
+    readonly arena: GestureArena;
+    private readonly doc;
+    private readonly registry;
+    private readonly delegated;
+    /** Touch.identifier → arena id, for live fingers. */
+    private readonly touchIds;
+    /** Touch.identifier → the element the finger landed on. */
+    private readonly touchTargets;
+    /**
+     * Finger targets with listeners of their own: how many fingers each, and
+     * how many of those a recognizer could claim while they move (only those
+     * need the blocking `touchmove` listener).
+     */
+    private readonly watched;
+    /** Fingers whose target listener is the blocking one. */
+    private readonly blockingFingers;
+    /** Touch events already handled (the document's and the target's listeners both see one). */
+    private readonly processed;
+    /** pointerId → arena id, for live mouse and pen contacts. */
+    private readonly pointerIds;
+    /** Elements whose caller touch-action waits for a read after paint. */
+    private readonly pendingCallerReads;
+    private isCallerReadScheduled;
+    /**
+     * The boxes the host watches for screen-edge pans (syncLayoutWatch): each
+     * element with an enabled one, and the root for one whose band moves with
+     * the viewport (spec:AST-094 FR18, FR19, DEC-22), and the one observer
+     * that watches them.
+     */
+    private readonly layoutWatched;
+    private layoutObserver;
+    /** Fingers whose first uncancelable `touchmove` was already judged. */
+    private readonly judgedUncancelable;
+    /**
+     * A finger's pointerId → its arena id, once its pointerdown and its
+     * touchstart are paired. Chromium sends no `touchmove` until a finger has
+     * travelled its slop (about 16 px), but sends every `pointermove`, so the
+     * finger's movement comes from both channels; and its `pointercancel` is
+     * the browser's claim of exactly that finger.
+     */
+    private readonly fingerPointers;
+    /** Finger pointerdowns still waiting for their touchstart. */
+    private readonly pendingPointers;
+    /**
+     * Under `inputMode: 'pointer-events'`, where claimed fingers lifted: the
+     * `touchend` that follows their `pointerup` is cancelled (FR21).
+     */
+    private readonly claimedLifts;
+    /** Fingers still waiting for their pointerdown, by arena id. */
+    private readonly unpairedTouches;
+    /** The elements each held contact turned selection off on. */
+    private readonly heldSelectionBy;
+    private readonly isPrimaryPointerCoarse;
+    private readonly coarseQuery;
+    private isWatchingPointer;
+    private readonly onPointerKindChange;
+    /** The last position fed per contact, so one channel's echo is dropped. */
+    private readonly lastFed;
+    /** When a finger was last down or lifted, and where it landed. */
+    private lastTouch;
+    /** Scrollers a recognizer is scrolling itself this frame (ownScroll). */
+    private readonly ownedScrolls;
+    /** The last scroll a finger drove, and when. */
+    private lastScroll;
+    private nextId;
+    private isInstalled;
+    private readonly inputMode;
+    private usesTouchEvents;
+    private swallowDeadline;
+    /**
+     * Where the primary pointer is fine: what listens for a press itself (the
+     * elements that use a gesture, and the document for delegated consumers),
+     * with its removal; whether a press one armed is held, the page's
+     * listeners lasting that long; and the pending removal of the click
+     * listener a released press kept (FR21, FR24).
+     */
+    private readonly armed;
+    private isArmedPress;
+    private clickRemoval;
+    constructor(doc: Document, options?: GestureHostOptions);
+    /** Re-derive every element's styles and the host's listeners. */
+    private refreshAll;
+    /** Attach a recognizer to an element. Returns the detach function. */
+    attach(element: Element, recognizer: GestureRecognizer, options?: AttachOptions): () => void;
+    /**
+     * Watch the box of each element with an enabled screen-edge pan, and the
+     * root's for a pan that watches the right side, whose band moves with the
+     * viewport: a resize may move an element into or out of its edge band, and
+     * the pan then measures again and re-derives the element's touch-action
+     * (FR19). The host sets touch-action for every pointer (FR43), so it
+     * watches under any primary pointer. One ResizeObserver serves every
+     * element and goes with the last one, and no listener is added (FR24); an
+     * engine without ResizeObserver keeps each pan's first measurement.
+     */
+    private syncLayoutWatch;
+    /** A watched box or the root resized: each enabled edge pan measures again. */
+    private readonly onLayoutChange;
+    /** Attach the view-level touch consumer of an element (a pressable control). */
+    attachConsumer(element: Element, consumer: TouchConsumer): () => void;
+    /**
+     * Find consumers of a kind by attribute, one instance per contact. Returns
+     * the function that stops it.
+     */
+    addDelegatedConsumer(type: DelegatedConsumerType): () => void;
+    /**
+     * Re-derive an element's styles and the host's listeners after its
+     * recognizers' options or its consumer's enabled state changed.
+     */
+    update(element: Element): void;
+    /**
+     * The Pointer Events `pointerId` of a contact the arena tracks: a mouse's
+     * or a pen's own, and for a finger driven by touch events the pointer its
+     * touch was paired with (null before the pairing, or without Pointer
+     * Events). It hands a held finger to code that follows pointers, as a
+     * menu does when a long press turns into a press-drag selection.
+     */
+    pointerIdOf(touch: GestureTouch | number): number | null;
+    /**
+     * Whether a finger set a scroller containing `node` moving within the last
+     * `window` ms. A touch there now brakes the scroll rather than pressing
+     * whatever is under it: a native list highlights nothing for one.
+     */
+    isScrollBraking(node: Node, window?: number): boolean;
+    private registrationFor;
+    private refresh;
+    private applyStyle;
+    /**
+     * The touch-action to write inline, if any. The author's value (a
+     * trigger's own `touch-action: none`) stays in force and the host never
+     * allows more (spec:AST-094 FR18, DEC-8):
+     * - an inline value is the style's own, read with no recalc, and the host
+     *   writes what both allow, inline; a CSS-wide keyword (`initial`,
+     *   `inherit`, `unset`, `revert`, `revert-layer`) names no touch-action of
+     *   its own, so it is read as an author rule is, as what it resolves to;
+     * - otherwise the element is marked with the derived value, under a rule
+     *   any author rule outranks, as the recognizer attaches: a subtree that
+     *   mounts with it is styled once, never restyled for it in a later frame.
+     *   The next frame reads what is in force, styles clean, and the host
+     *   writes inline only what both allow where that is narrower than an
+     *   author rule's value.
+     */
+    private touchActionToWrite;
+    /**
+     * Read the touch-action in force on each marked element in the next frame,
+     * then apply its style again. Batched: one style read serves every pending
+     * element, and the writes follow the reads. The host has written no
+     * touch-action inline on them, so a value other than the mark is an author
+     * rule's.
+     */
+    private readCallerTouchActionInNextFrame;
+    private cleanup;
+    /**
+     * Listen only while something could take a touch now (`spec:AST-094`
+     * FR24, FR43): where the primary pointer is coarse, while an enabled
+     * recognizer or consumer, or a delegated consumer, is attached; where it is
+     * fine, only during a press something armed (syncArmed). Otherwise no page
+     * listener is registered, so an idle page and a disabled control pay
+     * nothing.
+     */
+    private syncListeners;
+    private shouldListen;
+    /**
+     * Where the primary pointer is fine, each element with an enabled
+     * recognizer or press consumer listens for a press itself: one passive
+     * `pointerdown` listener, in the capture phase, so the outermost one hears
+     * a press first and serves every recognizer on its path. Delegated
+     * consumer types, which have no element, arm the document once. A press
+     * installs the host's page listeners for as long as its contacts last
+     * (`spec:AST-094` FR24, FR43). Where the primary pointer is coarse the
+     * page's listeners serve every press, and nothing is armed.
+     */
+    private syncArmed;
+    /**
+     * A press on something armed, where the primary pointer is fine: a
+     * mouse's primary button, a pen, or a finger. The page's listeners come
+     * for this press, and the press goes on to them, its capture phase on the
+     * page being over.
+     */
+    private readonly onArmedPress;
+    /**
+     * After a contact ends: once no contact of the press that armed the page's
+     * listeners is down, they go (FR24). A recognizer still deciding after the
+     * lift needs no input; the click it may owe keeps its listener
+     * (releaseClickListener).
+     */
+    private releaseArmedPress;
+    /**
+     * The click listener outlives the page's others while the swallower is
+     * armed: a claimed lift's click comes after its pointerup or touchend
+     * (`spec:AST-094` FR21; FR24 counts it as press work). It goes when that
+     * window closes, unless the host listens again by then.
+     */
+    private releaseClickListener;
+    private install;
+    private uninstall;
+    /**
+     * The recognizers on the path from `target` to the document, innermost
+     * first, and (for a contact) its consumer: the innermost element with an
+     * attached consumer or a delegated consumer type's attribute.
+     */
+    private participantsAt;
+    /** Whether this event is new to the host (and mark it handled). */
+    private takeEvent;
+    private readonly onTouchStart;
+    private readonly onTouchMove;
+    /**
+     * Under `inputMode: 'pointer-events'` a finger comes from its pointer
+     * events, so its touches carry no id of ours: the live finger it is, the
+     * nearest pointer-fed finger on the same target. Its touchmoves can then
+     * be cancelled once a recognizer claims it (`spec:AST-094` FR19, FR21).
+     */
+    private pointerFingerAt;
+    /**
+     * Cancel the `touchend` of a finger a recognizer owned when it lifted
+     * (`inputMode: 'pointer-events'`): its `pointerup` came first, at the same
+     * place on the same target (`spec:AST-094` FR21).
+     */
+    private cancelClaimedLift;
+    /**
+     * Cancel a `touchmove` while a recognizer owns one of its fingers. A touch
+     * no recognizer owns keeps its moves (`spec:AST-094` FR19): nothing is
+     * cancelled before a recognizer begins, or for a touch it does not track.
+     */
+    private cancelIfClaimed;
+    private readonly onTouchEnd;
+    private readonly onTouchCancel;
+    /** The target's own listeners, for a target that left the document. */
+    private readonly onTargetTouchMove;
+    /** The same for a finger nothing could claim while it moves: never blocks. */
+    private readonly onTargetTouchMovePassive;
+    private readonly onTargetTouchEnd;
+    private readonly onTargetTouchCancel;
+    /**
+     * Cancel tracked fingers the event says are no longer down. `touches`
+     * lists every finger on the screen; one missing from it (and not lifting
+     * in this very event) ended where we could not see it.
+     */
+    private dropFingersNotDown;
+    private watchTarget;
+    private unwatchTarget;
+    /**
+     * Keeps one `touchmove` listener on a watched target: the blocking one
+     * while a finger on it could be claimed as it moves, a passive one
+     * otherwise, so a scroll starting there never waits on the main thread
+     * (`spec:AST-094` FR19).
+     */
+    private swapTargetTouchMove;
+    /** Stop tracking a finger by its Touch.identifier; returns its arena id. */
+    private forgetFinger;
+    private pairTouch;
+    private pairPointer;
+    /** Feed moves, dropping the echo of a move the other channel delivered. */
+    private feedMoves;
+    /**
+     * For one held press by a finger or a pen: text selection and the touch
+     * callout off on the elements whose hold does something (a long press),
+     * as `holdSelectionStyle` decides (`spec:AST-094` FR41, DEC-9).
+     * Everything else keeps the browser's long-press selection. Restored when
+     * the contact ends; refcounted across contacts on one element.
+     */
+    private holdSelection;
+    /** Undo `holdSelection` for a contact that ended; idempotent. */
+    private releaseSelection;
+    /** Forget a contact's pairing and echo state. */
+    private forgetContact;
+    private readonly onPointerDown;
+    private readonly onPointerMove;
+    private readonly onPointerUp;
+    private readonly onPointerCancel;
+    /**
+     * Which live finger a touch `pointercancel` is about. The pointer keeps
+     * the target the finger landed on (implicit capture), as the Touch does;
+     * among fingers on that target, the nearest. WebKit also numbers the
+     * pointer like the Touch, which settles what position cannot.
+     */
+    private touchForCancelledPointer;
+    private armSwallower;
+    private disarmSwallower;
+    private readonly onClick;
+    private replayClick;
+    private readonly onContextMenu;
+    /**
+     * A recognizer is about to scroll `scroller` itself (a menu's edge
+     * autoscroll, spec:AST-094 FR30): the scroll that write fires is not a
+     * finger's and not the browser taking one. It passes until the end of the
+     * next frame, when that event has fired; a real pan in that window still
+     * reports itself through pointercancel or touchcancel.
+     */
+    ownScroll(scroller: Node): void;
+    private readonly onScroll;
+    private readonly onVisibilityChange;
+    private readonly onBlur;
+    /** The app lost focus: UIKit cancels every touch in flight. */
+    private cancelEverything;
+}
+/** The gesture host of a document, created on first use. */
+export declare function getGestureHost(doc: Document): GestureHost;
+//# sourceMappingURL=GestureHost.d.ts.map

package/dist/gestures/GestureHost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GestureHost.d.ts","sourceRoot":"","sources":["../../src/gestures/GestureHost.ts"],"names":[],"mappings":"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"}