@astryxdesign/core 0.7.5-canary.fccd771 → 0.7.5

package/dist/gestures/GestureRecognizer.js

@@ -0,0 +1,487 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file GestureRecognizer.ts
+ * @input Touches delivered by a GestureArena
+ * @output Exports GestureRecognizer, the base every recognizer extends
+ *   (UIGestureRecognizer), and its options and listener types
+ * @position Core of packages/core/src/gestures: subclasses interpret touches
+ *   and request state changes; the arena decides whether a change is allowed
+ *   (require-to-fail, exclusivity, should-begin) and applies it
+ *
+ * The state machine is UIKit's:
+ *
+ *   possible ─► began ─► changed* ─► ended | cancelled     (continuous)
+ *   possible ─► ended                                       (discrete: "recognized")
+ *   possible ─► failed
+ *
+ * A recognizer in a terminal state ignores the touches it still has and
+ * returns to `possible` (its `reset()` runs) once all of them have ended,
+ * exactly as UIKit resets a recognizer before the next touch sequence.
+ *
+ * Listeners (UIKit's target-action) fire for `began`, `changed`, `ended` and
+ * `cancelled`, never for `failed`. They run synchronously inside the input
+ * event, so a listener that writes a transform writes it in the same frame
+ * as the input, with no React render in between.
+ *
+ * SYNC: When modified, update GestureArena.ts.
+ */
+
+import { DEFAULT_ENVIRONMENT } from "./types.js";
+const ACTION_STATES = new Set(['began', 'changed', 'ended', 'cancelled']);
+
+/** Transitions UIKit allows; anything else is a recognizer bug. */
+const ALLOWED = {
+  possible: ['began', 'ended', 'failed'],
+  began: ['changed', 'ended', 'cancelled'],
+  changed: ['changed', 'ended', 'cancelled'],
+  ended: ['possible'],
+  cancelled: ['possible'],
+  failed: ['possible']
+};
+export function isTransitionAllowed(from, to) {
+  return ALLOWED[from].includes(to);
+}
+export function isTerminal(state) {
+  return state === 'ended' || state === 'cancelled' || state === 'failed';
+}
+export function isActive(state) {
+  return state === 'began' || state === 'changed';
+}
+
+/** The browser behaviors `touch-action` can keep or remove. */
+
+export const ALL_NATIVE_TOUCH = {
+  panX: true,
+  panY: true,
+  pinchZoom: true,
+  doubleTapZoom: true
+};
+
+/** A tap-like recognizer only needs double-tap zoom gone (no click delay). */
+export const MANIPULATION = {
+  panX: true,
+  panY: true,
+  pinchZoom: true,
+  doubleTapZoom: false
+};
+let nextRecognizerId = 1;
+export class GestureRecognizer {
+  /** Stable id, for ordering and debugging. */
+  id = nextRecognizerId++;
+  /**
+   * The element (or any object) the recognizer is attached to. The DOM host
+   * sets it; the arena treats it as opaque.
+   */
+  view = null;
+
+  /** @internal The arena delivering touches to this recognizer, if any. */
+  arena = null;
+  /** @internal A recognition waiting for a failure requirement. */
+  pending = null;
+
+  /**
+   * The delegate functions. Typed against the base so a subclass stays
+   * assignable to GestureRecognizer; each is only ever called with `this`.
+   */
+
+  stateValue = 'possible';
+  // Typed against the base so a subclass stays assignable to
+  // GestureRecognizer; every listener is only ever called with `this`.
+  listeners = new Set();
+  transitionListeners = new Set();
+  failureRequirements = new Set();
+  simultaneousWith = new Set();
+  /** Touches currently tracked, by id. */
+  touches = new Map();
+  /** @internal Every touch id received since the last reset. */
+  seenTouchIds = new Set();
+  lastLocation = {
+    x: 0,
+    y: 0
+  };
+  constructor(options = {}) {
+    this.options = options;
+    this.name = options.name ?? this.constructor.name;
+    this.isEnabled = options.isEnabled ?? true;
+    this.cancelsTouchesInView = options.cancelsTouchesInView ?? true;
+    this.delaysTouchesBegan = options.delaysTouchesBegan ?? false;
+    this.delaysTouchesEnded = options.delaysTouchesEnded ?? true;
+    this.allowedPointerTypes = options.allowedPointerTypes == null ? null : new Set(options.allowedPointerTypes);
+    this.requiresExclusiveTouchType = options.requiresExclusiveTouchType ?? true;
+  }
+
+  /** Discrete recognizers go from `possible` straight to `ended`. */
+  get isDiscrete() {
+    return false;
+  }
+
+  /**
+   * Whether recognizing takes the touches from the browser: while a claiming
+   * recognizer owns a touch, the host cancels the browser's pan and zoom for
+   * it. Every touch recognizer claims; hover has no touches to claim.
+   */
+  get claimsTouches() {
+    return true;
+  }
+  get state() {
+    return this.stateValue;
+  }
+
+  /**
+   * What the browser may still do natively on this recognizer's view: the
+   * host intersects these across a view's recognizers into its
+   * `touch-action`. A recognizer that takes no touches constrains nothing.
+   */
+  get nativeTouchBehavior() {
+    return ALL_NATIVE_TOUCH;
+  }
+
+  /** @internal Whether this recognizer listens to touch at all. */
+  get acceptsTouchInput() {
+    return this.allowedPointerTypes == null || this.allowedPointerTypes.has('touch');
+  }
+
+  /** How many touches the recognizer is tracking right now. */
+  get numberOfTouches() {
+    return this.touches.size;
+  }
+
+  /** The touches being tracked, in the order they began. */
+  get trackedTouches() {
+    return [...this.touches.values()];
+  }
+
+  /**
+   * The centroid of the tracked touches in client coordinates; after they
+   * end, where they were last.
+   */
+  location() {
+    if (this.touches.size === 0) {
+      return this.lastLocation;
+    }
+    let x = 0;
+    let y = 0;
+    for (const touch of this.touches.values()) {
+      x += touch.x;
+      y += touch.y;
+    }
+    this.lastLocation = {
+      x: x / this.touches.size,
+      y: y / this.touches.size
+    };
+    return this.lastLocation;
+  }
+
+  /** Facts about the page (viewport, writing direction). */
+  get environment() {
+    return this.arena?.environment ?? DEFAULT_ENVIRONMENT;
+  }
+
+  // --- Relationships -------------------------------------------------------
+
+  /** UIKit's `require(toFail:)`: recognize only once `other` has failed. */
+  requireToFail(other) {
+    this.failureRequirements.add(other);
+    return this;
+  }
+
+  /** Let this and `others` be recognized at the same time (both directions). */
+  recognizeSimultaneouslyWith(...others) {
+    for (const other of others) {
+      this.simultaneousWith.add(other);
+      other.simultaneousWith.add(this);
+    }
+    return this;
+  }
+
+  /** @internal Whether this recognizer must wait for `other` to fail. */
+  requiresFailureOf(other) {
+    return this.failureRequirements.has(other) || this.options.shouldRequireFailureOf?.(this, other) === true || other.options.shouldBeRequiredToFailBy?.(other, this) === true;
+  }
+
+  /**
+   * @internal Whether this and `other` may be active together: both allow it
+   * (`recognizeSimultaneouslyWith` sets both sides; each delegate answers for
+   * its own recognizer), so one delegate alone keeps them exclusive (FR15).
+   */
+  allowsSimultaneous(other) {
+    return this.simultaneousWith.has(other) || this.options.shouldRecognizeSimultaneously?.(this, other) === true && other.options.shouldRecognizeSimultaneously?.(other, this) === true;
+  }
+
+  /** @internal The delegate's should-begin answer. */
+  shouldBegin() {
+    return this.options.shouldBegin?.(this) ?? true;
+  }
+
+  /** UIKit's `canPrevent(_:)`: whether recognizing fails `other`. */
+  canPrevent(_other) {
+    return true;
+  }
+
+  /** UIKit's `canBePrevented(by:)`. */
+  canBePrevented(_other) {
+    return true;
+  }
+
+  /**
+   * Whether this recognizer is still part of the current interaction: it
+   * tracks touches, is waiting on a requirement, or (a multi-tap between
+   * taps) expects more input. An idle `possible` recognizer cannot recognize
+   * and so does not hold up anything that requires it to fail.
+   */
+  isInvolved() {
+    return this.touches.size > 0 || this.pending != null;
+  }
+
+  // --- Listeners -----------------------------------------------------------
+
+  /** Called on began, changed, ended (recognized) and cancelled. */
+  addListener(listener) {
+    const stored = listener;
+    this.listeners.add(stored);
+    return () => {
+      this.listeners.delete(stored);
+    };
+  }
+
+  /** Called on every transition, including failed and the reset to possible. */
+  addTransitionListener(listener) {
+    const stored = listener;
+    this.transitionListeners.add(stored);
+    return () => {
+      this.transitionListeners.delete(stored);
+    };
+  }
+
+  // --- Subclass API --------------------------------------------------------
+
+  /** New touches for this recognizer. */
+  touchesBegan(_touches, _event) {}
+  touchesMoved(_touches, _event) {}
+
+  /** Touches lifted; they are removed from `touches` after this returns. */
+  touchesEnded(_touches, _event) {}
+
+  /**
+   * The system or the browser took these touches. By default an active
+   * gesture is cancelled and a possible one fails.
+   */
+  touchesCancelled(_touches, _event) {
+    if (isActive(this.state)) {
+      this.setState('cancelled');
+    } else if (this.state === 'possible') {
+      this.setState('failed');
+    }
+  }
+
+  /**
+   * The browser took these touches for its own pan or zoom (their pointer
+   * stream is gone). Return true to keep observing them; by default they are
+   * treated as cancelled. An observer never claims them: a drag the browser
+   * took stays the browser's (FR14).
+   */
+  touchesTakenByBrowser(touches, event) {
+    this.touchesCancelled(touches, event);
+    return false;
+  }
+
+  /**
+   * A touch began elsewhere (off this recognizer's hit path) while this
+   * recognizer tracks touches of its own. It is not this recognizer's touch
+   * and is never delivered as one; a recognizer that a foreign finger should
+   * end (a menu's press slide) cancels itself here. By default nothing
+   * happens.
+   */
+  touchBeganElsewhere(_touches, _event) {}
+
+  /** Clear per-gesture state before the next attempt. */
+  reset() {}
+
+  /**
+   * Whether a touch may join. The base checks enabled, pointer kind and
+   * exclusivity of kind; subclasses narrow it (a one-finger pan ignores a
+   * second finger once it is moving).
+   */
+  acceptsTouch(touch) {
+    if (!this.isEnabled) {
+      return false;
+    }
+    if (this.allowedPointerTypes != null && !this.allowedPointerTypes.has(touch.pointerType)) {
+      return false;
+    }
+    if (this.requiresExclusiveTouchType) {
+      for (const existing of this.touches.values()) {
+        if (existing.pointerType !== touch.pointerType) {
+          return false;
+        }
+      }
+    }
+    return this.options.shouldReceiveTouch?.(this, touch) ?? true;
+  }
+
+  /**
+   * Ask for a state change. The arena may refuse (the recognizer fails
+   * instead) or defer it until a failure requirement resolves.
+   */
+  setState(next) {
+    if (this.arena != null) {
+      this.arena.requestTransition(this, next);
+    } else {
+      this.applyState(next);
+    }
+  }
+
+  /** Arm the recognizer's one timer at an absolute time on the event clock. */
+  setTimer(deadline, callback) {
+    this.arena?.setTimer(this, deadline, callback);
+  }
+  clearTimer() {
+    this.arena?.clearTimer(this);
+  }
+
+  /** The event clock's current time. */
+  now() {
+    return this.arena?.now() ?? 0;
+  }
+
+  // --- Arena hooks (internal) ----------------------------------------------
+
+  /** @internal Whether this recognizer takes `touch` right now. */
+  wantsTouch(touch) {
+    if (this.state !== 'possible' && !isActive(this.state)) {
+      return false;
+    }
+    if (this.pending != null) {
+      return false;
+    }
+    return this.acceptsTouch(touch);
+  }
+
+  /** @internal */
+  deliverBegan(touches, event) {
+    for (const touch of touches) {
+      this.touches.set(touch.id, touch);
+      this.seenTouchIds.add(touch.id);
+    }
+    this.location();
+    this.touchesBegan(touches, event);
+  }
+
+  /** @internal */
+  deliverBeganElsewhere(touches, event) {
+    if (isTerminal(this.state)) {
+      return;
+    }
+    this.touchBeganElsewhere(touches, event);
+  }
+
+  /** @internal */
+  deliverMoved(touches, event) {
+    const own = touches.filter(touch => this.touches.has(touch.id));
+    if (own.length === 0 || isTerminal(this.state)) {
+      return;
+    }
+    this.location();
+    this.touchesMoved(own, event);
+  }
+
+  /** @internal */
+  deliverEnded(touches, event) {
+    const own = touches.filter(touch => this.touches.has(touch.id));
+    if (own.length === 0) {
+      return;
+    }
+    this.location();
+    if (!isTerminal(this.state)) {
+      this.touchesEnded(own, event);
+    }
+    for (const touch of own) {
+      this.touches.delete(touch.id);
+    }
+  }
+
+  /** @internal */
+  deliverCancelled(touches, event) {
+    const own = touches.filter(touch => this.touches.has(touch.id));
+    if (own.length === 0) {
+      return;
+    }
+    if (!isTerminal(this.state)) {
+      this.touchesCancelled(own, event);
+    }
+    for (const touch of own) {
+      this.touches.delete(touch.id);
+    }
+  }
+
+  /** @internal */
+  deliverTakenByBrowser(touches, event) {
+    const own = touches.filter(touch => this.touches.has(touch.id));
+    if (own.length === 0) {
+      return;
+    }
+    if (!isTerminal(this.state) && this.touchesTakenByBrowser(own, event)) {
+      return;
+    }
+    for (const touch of own) {
+      this.touches.delete(touch.id);
+    }
+  }
+
+  /**
+   * UIKit's `isEnabled` setter: turning a recognizer off mid-gesture cancels
+   * the gesture (an active one) or fails it (a possible one).
+   */
+  setEnabled(value) {
+    this.isEnabled = value;
+    if (!value && (this.state !== 'possible' || this.isInvolved())) {
+      this.cancel();
+    }
+  }
+
+  /** Cancel this recognizer if it is active, or fail it if it is possible. */
+  cancel() {
+    if (this.arena != null) {
+      this.arena.stop(this);
+    } else if (isActive(this.state)) {
+      this.applyState('cancelled');
+    } else if (this.state === 'possible' && this.isInvolved()) {
+      // An idle recognizer stays `possible`: nothing would ever reset it.
+      this.applyState('failed');
+    }
+  }
+
+  /** @internal Apply a transition the arena has approved. */
+  applyState(next) {
+    const from = this.stateValue;
+    if (from === next && next !== 'changed') {
+      return;
+    }
+    if (!isTransitionAllowed(from, next)) {
+      return;
+    }
+    this.stateValue = next;
+    if (next !== 'possible') {
+      this.pending = null;
+    }
+    for (const listener of [...this.transitionListeners]) {
+      listener(this, from, next);
+    }
+    if (ACTION_STATES.has(next)) {
+      for (const listener of [...this.listeners]) {
+        listener(this);
+      }
+    }
+  }
+
+  /** @internal Return to `possible` for the next attempt. */
+  resetToPossible() {
+    this.clearTimer();
+    this.pending = null;
+    this.touches.clear();
+    this.seenTouchIds.clear();
+    this.reset();
+    this.applyState('possible');
+  }
+}

package/dist/gestures/LongPressGestureRecognizer.d.ts

@@ -0,0 +1,32 @@
+import { GestureRecognizer, type GestureRecognizerOptions, type NativeTouchBehavior } from './GestureRecognizer.js';
+import type { GestureEventContext, GestureTouch } from './types.js';
+export interface LongPressGestureRecognizerOptions extends GestureRecognizerOptions<LongPressGestureRecognizer> {
+    minimumPressDuration?: number;
+    allowableMovement?: number;
+    /** Quick taps before the press. @default 0 */
+    numberOfTapsRequired?: number;
+    /** @default 1 */
+    numberOfTouchesRequired?: number;
+}
+export declare class LongPressGestureRecognizer extends GestureRecognizer {
+    minimumPressDuration: number;
+    allowableMovement: number;
+    numberOfTapsRequired: number;
+    numberOfTouchesRequired: number;
+    private tapsDone;
+    /** The taps phase's current tap: when it landed and its most fingers. */
+    private tapStartedAt;
+    private tapMostTouches;
+    private isPressTimerArmed;
+    /** When the gesture began, on the event clock. */
+    beganAt: number | null;
+    constructor(options?: LongPressGestureRecognizerOptions);
+    isInvolved(): boolean;
+    get nativeTouchBehavior(): NativeTouchBehavior;
+    protected acceptsTouch(touch: GestureTouch): boolean;
+    protected touchesBegan(_touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    protected touchesMoved(touches: ReadonlyArray<GestureTouch>): void;
+    protected touchesEnded(touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    protected reset(): void;
+}
+//# sourceMappingURL=LongPressGestureRecognizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LongPressGestureRecognizer.d.ts","sourceRoot":"","sources":["../../src/gestures/LongPressGestureRecognizer.ts"],"names":[],"mappings":"AAwBA,OAAO,EACL,iBAAiB,EAGjB,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACzB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAC,mBAAmB,EAAE,YAAY,EAAC,MAAM,SAAS,CAAC;AAE/D,MAAM,WAAW,iCAAkC,SAAQ,wBAAwB,CAAC,0BAA0B,CAAC;IAC7G,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,8CAA8C;IAC9C,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iBAAiB;IACjB,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAClC;AAED,qBAAa,0BAA2B,SAAQ,iBAAiB;IAC/D,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,uBAAuB,EAAE,MAAM,CAAC;IAEhC,OAAO,CAAC,QAAQ,CAAK;IACrB,yEAAyE;IACzE,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,iBAAiB,CAAS;IAClC,kDAAkD;IAClD,OAAO,EAAE,MAAM,GAAG,IAAI,CAAQ;gBAElB,OAAO,GAAE,iCAAsC;IAWlD,UAAU,IAAI,OAAO;IAI9B,IAAa,mBAAmB,IAAI,mBAAmB,CAEtD;cAEkB,YAAY,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO;cAQ1C,YAAY,CAC7B,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,EACrC,KAAK,EAAE,mBAAmB,GACzB,IAAI;cAsCY,YAAY,CAAC,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,GAAG,IAAI;cAYxD,YAAY,CAC7B,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,KAAK,EAAE,mBAAmB,GACzB,IAAI;cAuCY,KAAK,IAAI,IAAI;CAOjC"}

package/dist/gestures/LongPressGestureRecognizer.js

@@ -0,0 +1,135 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file LongPressGestureRecognizer.ts
+ * @input Touches from a GestureArena
+ * @output Exports LongPressGestureRecognizer (UILongPressGestureRecognizer)
+ *   and its options
+ * @position Continuous recognizer of packages/core/src/gestures
+ *
+ * Begins once `numberOfTouchesRequired` fingers have stayed down for
+ * `minimumPressDuration` without any of them travelling further than
+ * `allowableMovement` (after `numberOfTapsRequired` quick taps, when set).
+ * After it begins, movement is unlimited and reports `changed`; lifting a
+ * finger ends it. Lifting or travelling before the duration fails it. With a
+ * duration of zero it begins on the touch itself, in the same event, as
+ * UIKit's does: the selection tracker of an alert's, a menu's or an action
+ * sheet's actions (highlight under the finger, act on the lift).
+ *
+ * The begin time is exact: the duration is a deadline on the event clock, so
+ * a blocked main thread delays the callback, not the moment it reports.
+ */
+
+import { UIKIT_LONG_PRESS, UIKIT_TAP } from "../motion/uikit/gestures.js";
+import { travel } from "./geometry.js";
+import { GestureRecognizer, isActive, MANIPULATION } from "./GestureRecognizer.js";
+export class LongPressGestureRecognizer extends GestureRecognizer {
+  tapsDone = 0;
+  /** The taps phase's current tap: when it landed and its most fingers. */
+  tapStartedAt = null;
+  tapMostTouches = 0;
+  isPressTimerArmed = false;
+  /** When the gesture began, on the event clock. */
+  beganAt = null;
+  constructor(options = {}) {
+    super(options);
+    this.minimumPressDuration = options.minimumPressDuration ?? UIKIT_LONG_PRESS.minimumPressDuration.value;
+    this.allowableMovement = options.allowableMovement ?? UIKIT_LONG_PRESS.allowableMovement.value;
+    this.numberOfTapsRequired = options.numberOfTapsRequired ?? 0;
+    this.numberOfTouchesRequired = options.numberOfTouchesRequired ?? 1;
+  }
+  isInvolved() {
+    return super.isInvolved() || this.tapsDone > 0;
+  }
+  get nativeTouchBehavior() {
+    return MANIPULATION;
+  }
+  acceptsTouch(touch) {
+    // Extra fingers after the press began do not end or move it.
+    if (isActive(this.state)) {
+      return false;
+    }
+    return super.acceptsTouch(touch);
+  }
+  touchesBegan(_touches, event) {
+    if (this.numberOfTouches > this.numberOfTouchesRequired) {
+      this.setState('failed');
+      return;
+    }
+    if (this.tapsDone > 0) {
+      // The next tap (or the press) landed in time.
+      this.clearTimer();
+    }
+    if (this.tapsDone < this.numberOfTapsRequired) {
+      this.tapStartedAt ??= event.time;
+      this.tapMostTouches = Math.max(this.tapMostTouches, this.numberOfTouches);
+    }
+    if (this.numberOfTouches === this.numberOfTouchesRequired && this.tapsDone >= this.numberOfTapsRequired) {
+      if (this.minimumPressDuration <= 0) {
+        // UIKit's zero-duration press begins on the touch itself, in the
+        // same event (a selection tracker over a group of actions).
+        this.beganAt = event.time;
+        this.setState('began');
+        return;
+      }
+      this.isPressTimerArmed = true;
+      this.setTimer(event.time + this.minimumPressDuration, () => {
+        this.isPressTimerArmed = false;
+        if (this.state === 'possible' && this.numberOfTouches === this.numberOfTouchesRequired) {
+          this.beganAt = this.now();
+          this.setState('began');
+        }
+      });
+    }
+  }
+  touchesMoved(touches) {
+    if (this.state === 'possible') {
+      if (touches.some(touch => travel(touch) > this.allowableMovement)) {
+        this.setState('failed');
+      }
+      return;
+    }
+    if (isActive(this.state)) {
+      this.setState('changed');
+    }
+  }
+  touchesEnded(touches, event) {
+    if (isActive(this.state)) {
+      this.setState('ended');
+      return;
+    }
+    if (this.isPressTimerArmed || this.tapsDone >= this.numberOfTapsRequired) {
+      // Lifted before the duration: not a long press.
+      this.setState('failed');
+      return;
+    }
+    if (this.numberOfTouches - touches.length > 0) {
+      return;
+    }
+    // A completed tap of the taps phase: quick, and with the press's finger
+    // count, as a tap recognizer's would be. GUESS: its hold limit and
+    // interval are the tap recognizer's (UIKit's measured
+    // `maximumTapDuration` and `maximumIntervalBetweenTaps`), until
+    // measurement M-G20 (motion/MEASUREMENTS.md) reads
+    // UILongPressGestureRecognizer's own.
+    const heldFor = event.time - (this.tapStartedAt ?? event.time);
+    const fingers = this.tapMostTouches;
+    this.tapStartedAt = null;
+    this.tapMostTouches = 0;
+    if (heldFor > UIKIT_TAP.maximumTapDuration.value || fingers !== this.numberOfTouchesRequired) {
+      this.setState('failed');
+      return;
+    }
+    this.tapsDone += 1;
+    this.setTimer(event.time + UIKIT_TAP.maximumIntervalBetweenTaps.value, () => {
+      this.setState('failed');
+    });
+  }
+  reset() {
+    this.tapsDone = 0;
+    this.tapStartedAt = null;
+    this.tapMostTouches = 0;
+    this.isPressTimerArmed = false;
+    this.beganAt = null;
+  }
+}