@astryxdesign/core 0.7.6-canary.fdabeba → 0.7.6

package/dist/gestures/GestureArena.js

@@ -44,6 +44,7 @@
 
 import { isActive, isTerminal } from "./GestureRecognizer.js";
 import { DEFAULT_ENVIRONMENT } from "./types.js";
+import { internals } from "./recognizerInternals.js";
 /** The browser's clock: `performance.now()`, the base of `event.timeStamp`. */
 export const browserClock = {
   now: () => typeof performance === 'undefined' ? Date.now() : performance.now(),
@@ -75,7 +76,7 @@ export class GestureArena {
   depth = 0;
   /** Open `deferResolution` calls: what their stops unblock waits. */
   deferDepth = 0;
-  /** A deferred stop left recognitions, held touches or resets to settle. */
+  /** A deferred stop left a resolution for the next pass. */
   owesResolution = false;
   constructor(options = {}) {
     this.options = options;
@@ -95,11 +96,25 @@ export class GestureArena {
     return this.records.get(id)?.isClaimed === true;
   }
 
+  /** @internal The view-level consumer of this touch, if any. */
+  consumerOf(id) {
+    return this.records.get(id)?.consumer ?? null;
+  }
+
   /** The live touch with this id. */
   getTouch(id) {
     return this.records.get(id)?.touch;
   }
 
+  /**
+   * The recognizers that took touch `id` when it began: each was enabled,
+   * accepted its pointer, and its `shouldReceiveTouch` agreed. Empty for a
+   * touch the arena does not track.
+   */
+  participantsOf(id) {
+    return this.records.get(id)?.participants ?? [];
+  }
+
   /** Every touch the arena tracks, lifted ones awaiting a decision included. */
   get touches() {
     return [...this.records.values()].map(record => record.touch);
@@ -147,11 +162,11 @@ export class GestureArena {
         };
         const participants = [];
         for (const [depth, recognizer] of input.recognizers.entries()) {
-          if (!recognizer.wantsTouch(touch)) {
+          if (!internals(recognizer).wantsTouch(touch)) {
             continue;
           }
           participants.push(recognizer);
-          recognizer.arena = this;
+          internals(recognizer).arena = this;
           if (!this.active.includes(recognizer)) {
             // Resolution follows `active`, so a recognizer joins ahead of any
             // that sits further out on this touch's path: when two recognize
@@ -185,7 +200,7 @@ export class GestureArena {
       for (const recognizer of [...this.active]) {
         const touches = newTouches.get(recognizer);
         if (touches != null) {
-          recognizer.deliverBegan(touches, context);
+          internals(recognizer).deliverBegan(touches, context);
         }
       }
       // A recognizer already tracking a gesture hears of a touch that began
@@ -195,7 +210,7 @@ export class GestureArena {
         const own = newTouches.get(recognizer);
         const elsewhere = created.map(record => record.touch).filter(touch => own == null || !own.includes(touch));
         if (elsewhere.length > 0 && recognizer.numberOfTouches > 0) {
-          recognizer.deliverBeganElsewhere(elsewhere, context);
+          internals(recognizer).deliverBeganElsewhere(elsewhere, context);
         }
       }
       for (const record of created) {
@@ -237,7 +252,7 @@ export class GestureArena {
       const context = this.context();
       for (const recognizer of [...this.active]) {
         if (recognizer.numberOfTouches > 0) {
-          recognizer.deliverBeganElsewhere([touch], context);
+          internals(recognizer).deliverBeganElsewhere([touch], context);
         }
       }
     });
@@ -258,7 +273,7 @@ export class GestureArena {
       this.movingIds = new Set(changed.map(touch => touch.id));
       try {
         for (const recognizer of [...this.active]) {
-          recognizer.deliverMoved(changed, context);
+          internals(recognizer).deliverMoved(changed, context);
         }
       } finally {
         this.movingIds = previous;
@@ -285,7 +300,7 @@ export class GestureArena {
       const changed = this.update(inputs, 'ended');
       const context = this.context();
       for (const recognizer of [...this.active]) {
-        recognizer.deliverEnded(changed, context);
+        internals(recognizer).deliverEnded(changed, context);
       }
       // A lift can decide a waiting recognition (its requirement lifted
       // undecided and failed): settle those first, so each click's answer is
@@ -312,7 +327,7 @@ export class GestureArena {
       }
       const context = this.context();
       for (const recognizer of [...this.active]) {
-        recognizer.deliverCancelled(touches, context);
+        internals(recognizer).deliverCancelled(touches, context);
       }
       for (const touch of touches) {
         const record = this.records.get(touch.id);
@@ -345,7 +360,7 @@ export class GestureArena {
       }
       const context = this.context();
       for (const recognizer of [...this.active]) {
-        recognizer.deliverTakenByBrowser(touches, context);
+        internals(recognizer).deliverTakenByBrowser(touches, context);
       }
       for (const touch of touches) {
         const record = this.records.get(touch.id);
@@ -372,7 +387,7 @@ export class GestureArena {
       this.fail(recognizer);
       return;
     }
-    if (recognizer.pending != null && (next === 'began' || next === 'ended')) {
+    if (internals(recognizer).pending != null && (next === 'began' || next === 'ended')) {
       // Already waiting on a requirement; the recognition stands as asked.
       return;
     }
@@ -408,8 +423,8 @@ 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
+   * 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).
@@ -439,7 +454,7 @@ export class GestureArena {
   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 ?? this.lastEventTime();
+    const time = this.currentTime ?? (Number.isFinite(this.latestTime) ? this.latestTime : this.clock.now());
     this.run(time, () => {
       if (isActive(recognizer.state)) {
         this.apply(recognizer, 'cancelled');
@@ -453,13 +468,13 @@ export class GestureArena {
   // --- Resolution ------------------------------------------------------------
 
   attemptRecognition(recognizer, next) {
-    if (!recognizer.shouldBegin() || this.isVetoedByConsumer(recognizer)) {
+    if (!internals(recognizer).shouldBegin() || this.isVetoedByConsumer(recognizer)) {
       this.fail(recognizer);
       return;
     }
     let isWaiting = false;
     for (const other of this.active) {
-      if (other === recognizer || !recognizer.requiresFailureOf(other)) {
+      if (other === recognizer || !internals(recognizer).requiresFailureOf(other)) {
         continue;
       }
       if (other.state === 'failed') {
@@ -475,7 +490,7 @@ export class GestureArena {
       }
     }
     if (isWaiting) {
-      recognizer.pending = next;
+      internals(recognizer).pending = next;
       this.claim(recognizer);
       return;
     }
@@ -494,19 +509,24 @@ export class GestureArena {
       if (other === recognizer || other.state !== 'possible') {
         continue;
       }
-      if (other.requiresFailureOf(recognizer) || this.conflicts(recognizer, other)) {
+      if (internals(other).requiresFailureOf(recognizer) || this.conflicts(recognizer, other)) {
         this.fail(other);
       }
     }
     this.claim(recognizer);
-    if (recognizer.cancelsTouchesInView) {
+    // A watcher takes nothing from the view either: the press and the click
+    // under it stay (spec:AST-094 FR11, FR19; FR15 exempts watchers).
+    if (recognizer.claimsTouches && recognizer.cancelsTouchesInView) {
       this.cancelViewTouchesOf(recognizer);
     }
   }
 
   /** Whether `winner` being recognized prevents `other`. */
   conflicts(winner, other) {
-    if (!sharesTouches(winner, other) || winner.allowsSimultaneous(other)) {
+    if (!sharesTouches(winner, other) || internals(winner).allowsSimultaneous(other) ||
+    // A watcher (claimsTouches false) prevents nothing and nothing
+    // prevents it.
+    !winner.claimsTouches || !other.claimsTouches) {
       return false;
     }
     return winner.canPrevent(other) && other.canBePrevented(winner);
@@ -514,7 +534,7 @@ export class GestureArena {
 
   /** UIControl's rule: a control may veto an overlapping ancestor recognizer. */
   isVetoedByConsumer(recognizer) {
-    for (const id of recognizer.seenTouchIds) {
+    for (const id of internals(recognizer).seenTouchIds) {
       const consumer = this.records.get(id)?.consumer;
       if (consumer?.allowsAncestorRecognizer?.(recognizer) === false) {
         return true;
@@ -530,13 +550,9 @@ export class GestureArena {
       this.apply(recognizer, 'cancelled');
       return;
     }
-    recognizer.pending = null;
+    internals(recognizer).pending = null;
+    // apply() gives back any claim it held (releaseClaim), waiting or not.
     this.apply(recognizer, 'failed');
-    if (this.deferDepth > 0) {
-      // Inside `deferResolution`, the next pass settles.
-      this.owesResolution = true;
-      return;
-    }
     this.reviewPending();
   }
 
@@ -558,7 +574,7 @@ export class GestureArena {
       }
       // A recognized discrete gesture (`ended`, a swipe) still owns its
       // touches until they lift.
-      const isOwned = this.active.some(other => other !== recognizer && other.claimsTouches && (isActive(other.state) || other.state === 'ended' || other.pending != null) && other.trackedTouches.some(tracked => tracked.id === touch.id));
+      const isOwned = this.active.some(other => other !== recognizer && other.claimsTouches && (isActive(other.state) || other.state === 'ended' || internals(other).pending != null) && other.trackedTouches.some(tracked => tracked.id === touch.id));
       if (!isOwned) {
         record.isClaimed = false;
       }
@@ -566,7 +582,7 @@ export class GestureArena {
   }
   apply(recognizer, next) {
     const from = recognizer.state;
-    recognizer.applyState(next);
+    internals(recognizer).applyState(next);
     if (recognizer.state === next && from !== next) {
       this.options.onTransition?.(recognizer, from, next);
     } else if (next === 'changed' && from === 'changed') {
@@ -588,19 +604,23 @@ export class GestureArena {
    * settle in one pass.
    */
   reviewPending() {
+    if (this.deferDepth > 0) {
+      this.owesResolution = true;
+      return;
+    }
     let changed = true;
     while (changed) {
       changed = false;
       for (const recognizer of [...this.active]) {
-        const next = recognizer.pending;
+        const next = internals(recognizer).pending;
         if (next == null || recognizer.state !== 'possible') {
           continue;
         }
-        const blocked = this.active.some(other => other !== recognizer && recognizer.requiresFailureOf(other) && other.state === 'possible' && other.isInvolved());
+        const blocked = this.active.some(other => other !== recognizer && internals(recognizer).requiresFailureOf(other) && other.state === 'possible' && other.isInvolved());
         if (blocked) {
           continue;
         }
-        recognizer.pending = null;
+        internals(recognizer).pending = null;
         this.attemptRecognition(recognizer, next);
         changed = true;
       }
@@ -712,13 +732,13 @@ export class GestureArena {
     }
   }
   beginDelayers(record) {
-    return record.participants.some(recognizer => recognizer.delaysTouchesBegan && recognizer.state === 'possible' && recognizer.isInvolved() && recognizer.seenTouchIds.has(record.touch.id));
+    return record.participants.some(recognizer => recognizer.delaysTouchesBegan && recognizer.state === 'possible' && recognizer.isInvolved() && internals(recognizer).seenTouchIds.has(record.touch.id));
   }
   endDelayers(record) {
-    return record.participants.some(recognizer => recognizer.delaysTouchesEnded && recognizer.state === 'possible' && recognizer.isInvolved() && recognizer.seenTouchIds.has(record.touch.id));
+    return record.participants.some(recognizer => recognizer.delaysTouchesEnded && recognizer.state === 'possible' && recognizer.isInvolved() && internals(recognizer).seenTouchIds.has(record.touch.id));
   }
   cancelViewTouchesOf(recognizer) {
-    for (const id of recognizer.seenTouchIds) {
+    for (const id of internals(recognizer).seenTouchIds) {
       const record = this.records.get(id);
       if (record == null) {
         continue;
@@ -792,6 +812,13 @@ export class GestureArena {
   run(time, body) {
     this.depth += 1;
     try {
+      if (this.depth === 1 && this.deferDepth === 0 && this.owesResolution) {
+        // A deferred stop resolves before anything newer: input that comes
+        // ahead of its microtask (a nested dispatch) sees settled state.
+        this.owesResolution = false;
+        this.currentTime = this.clampTime(this.lastEventTime());
+        this.settle();
+      }
       this.flushTimers(time);
       this.currentTime = this.clampTime(time);
       body();
@@ -855,7 +882,7 @@ export class GestureArena {
       }
       this.active = this.active.filter(other => other !== recognizer);
       const from = recognizer.state;
-      recognizer.resetToPossible();
+      internals(recognizer).resetToPossible();
       didReset = true;
       if (from !== 'possible') {
         this.options.onTransition?.(recognizer, from, 'possible');
@@ -866,11 +893,16 @@ export class GestureArena {
       // touch from its view; release it now, not at the next input.
       this.reviewHeld();
     }
+    let dropped = false;
     for (const [id, record] of this.records) {
       if (record.isLifted && record.view !== 'held' && record.view !== 'endHeld' && !record.deferredClick) {
         this.records.delete(id);
+        dropped = true;
       }
     }
+    if (dropped && this.records.size === 0) {
+      this.options.onIdle?.();
+    }
   }
   scheduleRealTimer() {
     let earliest = Number.POSITIVE_INFINITY;
@@ -908,8 +940,8 @@ export class GestureArena {
   }
 }
 function sharesTouches(a, b) {
-  for (const id of a.seenTouchIds) {
-    if (b.seenTouchIds.has(id)) {
+  for (const id of internals(a).seenTouchIds) {
+    if (internals(b).seenTouchIds.has(id)) {
       return true;
     }
   }