@astryxdesign/core 0.7.5-canary.fccd771 → 0.7.5

package/dist/gestures/PanGestureRecognizer.d.ts

@@ -0,0 +1,117 @@
+import { GestureRecognizer, type GestureRecognizerOptions, type NativeTouchBehavior } from './GestureRecognizer.js';
+import type { GestureEventContext, GestureTouch, Point } from './types.js';
+export type PanDirection = 'any' | 'horizontal' | 'vertical' | 'left' | 'right' | 'up' | 'down';
+export interface PanGestureRecognizerOptions extends GestureRecognizerOptions<PanGestureRecognizer> {
+    /** @default 1 */
+    minimumNumberOfTouches?: number;
+    /** @default Infinity */
+    maximumNumberOfTouches?: number;
+    hysteresis?: number;
+    /** Movement that may begin the pan; anything else fails it. @default 'any' */
+    direction?: PanDirection;
+    /**
+     * For a pan limited to an axis: how much the movement along the axis must
+     * exceed the movement across it to begin. Above 1, movement that is still
+     * between the two lines when the pan reaches its hysteresis fails it: a pan
+     * that competes with native scrolling decides within 10 px
+     * (`spec:AST-094` FR19). Below 1, the pan claims drags up to
+     * atan(1 / axisRatio) off its axis.
+     * @default 1
+     */
+    axisRatio?: number;
+    /**
+     * With `direction: 'any'`, report movement along the axis that dominated
+     * at the start only (UIScrollView's directional lock).
+     */
+    lockAxis?: boolean;
+    /** Begin only when the native scrollers under the touch are at the edge. */
+    scrollEdge?: boolean;
+}
+export declare class PanGestureRecognizer extends GestureRecognizer {
+    minimumNumberOfTouches: number;
+    maximumNumberOfTouches: number;
+    hysteresis: number;
+    direction: PanDirection;
+    axisRatio: number;
+    lockAxis: boolean;
+    scrollEdge: boolean;
+    /** The axis a `lockAxis` pan locked to when it began. */
+    lockedAxis: 'x' | 'y' | null;
+    /** The movement the begin threshold took (excluded from `translation()`). */
+    travelAtBegan: Point;
+    private readonly tracker;
+    /** The lift's event time once the pan ended: its release (AST-100 FR2). */
+    private releaseTime;
+    /** The centroid where the gesture started, in client px. */
+    private origin;
+    /** Re-basing that keeps the translation continuous across finger changes. */
+    private adjust;
+    /** Translation since touch-down, before `setTranslation` offsets. */
+    private raw;
+    private offset;
+    constructor(options?: PanGestureRecognizerOptions);
+    /**
+     * Movement since the pan began (or since `setTranslation`), client px; the
+     * movement since touch-down while it is still possible.
+     */
+    translation(): Point;
+    /**
+     * Change the allowed direction for the next gesture (a pan in progress
+     * keeps the one it began with). The element's touch-action is derived
+     * when the recognizer is attached: switching between directions that
+     * leave the browser the same touches (up and down) needs nothing more.
+     */
+    setDirection(direction: PanDirection): void;
+    /** UIKit's `setTranslation(_:in:)`: make the current translation read `value`. */
+    setTranslation(value: Point): void;
+    /** Movement since the fingers landed, threshold included, client px. */
+    totalTranslation(): Point;
+    /**
+     * Velocity in px/s, UIKit's way, for a dragged surface. At the release it
+     * is 0 when the finger rested longer than the stillness interval before
+     * lifting, or moved fewer than twice (spec:AST-100 FR2).
+     */
+    velocity(): Point;
+    /**
+     * A scrolling surface's release velocity in px/s (paging, a wheel): the
+     * scroll-view blend of the pan's last two values, with the same release
+     * rules (architecture:interaction-modality INV10).
+     */
+    scrollVelocity(): Point;
+    /**
+     * The browser keeps the axis a two-way pan does not use. A one-way pan,
+     * and a pan that coordinates with native scrolling, leave the browser
+     * everything: the other direction still scrolls (a toast dragged away from
+     * its edge scrolls the page), and the pan claims its own direction by
+     * cancelling `touchmove` when it begins, below the distance at which the
+     * browser decides to scroll. Pinch-zoom stays the browser's.
+     */
+    get nativeTouchBehavior(): NativeTouchBehavior;
+    protected acceptsTouch(touch: GestureTouch): boolean;
+    protected touchesBegan(touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    protected touchesMoved(_touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    protected touchesEnded(touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    protected reset(): void;
+    /**
+     * What this movement means for a pan limited to a direction: begin, fail,
+     * or undecided (between `axisRatio`'s lines), which fails it too once it
+     * reaches its hysteresis.
+     */
+    protected classify(translation: Point): 'begin' | 'fail' | 'wait';
+    private tryBegin;
+    /**
+     * Leave the threshold's travel out of the translation, as UIKit does at
+     * .began: up to `hysteresis` px per axis, so a slow drag starts at zero and
+     * a step that overshoots keeps the overshoot (measured: a slow diagonal
+     * that crossed at (10.67, 10.67) reads (0.67, 0.67); a 3:1 drag crossing at
+     * (11, 3.67) reads (1, 0)). Some fast first moves read zero in UIKit; that
+     * case is not modelled.
+     */
+    private startFromHere;
+    private nativeCanScroll;
+    private track;
+    /** Keep the translation continuous when fingers join or leave. */
+    private rebase;
+    private locked;
+}
+//# sourceMappingURL=PanGestureRecognizer.d.ts.map

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

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

package/dist/gestures/PanGestureRecognizer.js

@@ -0,0 +1,349 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file PanGestureRecognizer.ts
+ * @input Touches from a GestureArena, each with a probe of the native
+ *   scrollers under it
+ * @output Exports PanGestureRecognizer (UIPanGestureRecognizer), its options
+ *   and direction type
+ * @position Continuous recognizer of packages/core/src/gestures; the base of
+ *   ScreenEdgePanGestureRecognizer
+ *
+ * Begins once the touches' centroid has travelled `hysteresis` px along
+ * either axis (UIKit applies it per axis, not as a distance) with between
+ * `minimumNumberOfTouches` and `maximumNumberOfTouches` fingers down, in the
+ * allowed `direction`. As in UIKit, `translation()` is reset when the pan
+ * begins, so the travel spent on the threshold is not part of it and a
+ * dragged surface does not jump; `totalTranslation()` is the movement since
+ * the fingers landed, and `travelAtBegan` what the threshold took.
+ * `velocity()` is UIKit's own filter (see VelocityTracker), fed one sample
+ * per event; the lift's position updates neither, as in UIKit. Adding or
+ * lifting a finger never jumps the translation: the centroid is re-based so
+ * the gesture continues where it was. Once moving, fingers past the maximum
+ * are ignored, so a second finger never breaks a one-finger pan.
+ *
+ * NATIVE SCROLL COORDINATION, for a pan over content the browser scrolls
+ * (a sheet over its own list):
+ *
+ * - `scrollEdge`: the pan begins only if no scroller under the touch could
+ *   scroll for that movement — the finger landed at the edge and pulls away
+ *   from it. The browser has not committed yet, so beginning claims the
+ *   touch and the browser never scrolls.
+ *
+ * Who gets the drag is decided once, when it begins: a drag that began as
+ * the browser's scroll stays the browser's to the lift and rubber-bands at
+ * the content's edge, as a UIKit scroll view keeps it (`spec:AST-094` FR14).
+ */
+
+import { UIKIT_PAN } from "../motion/uikit/gestures.js";
+import { centroid } from "./geometry.js";
+import { ALL_NATIVE_TOUCH, GestureRecognizer, isActive } from "./GestureRecognizer.js";
+import { VelocityTracker } from "./VelocityTracker.js";
+const ZERO = {
+  x: 0,
+  y: 0
+};
+const DIRECTION_VECTORS = {
+  left: {
+    x: -1,
+    y: 0
+  },
+  right: {
+    x: 1,
+    y: 0
+  },
+  up: {
+    x: 0,
+    y: -1
+  },
+  down: {
+    x: 0,
+    y: 1
+  }
+};
+export class PanGestureRecognizer extends GestureRecognizer {
+  /** The axis a `lockAxis` pan locked to when it began. */
+  lockedAxis = null;
+  /** The movement the begin threshold took (excluded from `translation()`). */
+  travelAtBegan = ZERO;
+  /** The lift's event time once the pan ended: its release (AST-100 FR2). */
+  releaseTime = undefined;
+  /** The centroid where the gesture started, in client px. */
+  origin = ZERO;
+  /** Re-basing that keeps the translation continuous across finger changes. */
+  adjust = ZERO;
+  /** Translation since touch-down, before `setTranslation` offsets. */
+  raw = ZERO;
+  offset = ZERO;
+  constructor(options = {}) {
+    super(options);
+    this.minimumNumberOfTouches = options.minimumNumberOfTouches ?? 1;
+    this.maximumNumberOfTouches = options.maximumNumberOfTouches ?? Number.POSITIVE_INFINITY;
+    this.hysteresis = options.hysteresis ?? UIKIT_PAN.hysteresis.value;
+    this.direction = options.direction ?? 'any';
+    this.axisRatio = options.axisRatio ?? 1;
+    this.lockAxis = options.lockAxis ?? false;
+    this.scrollEdge = options.scrollEdge ?? false;
+    this.tracker = new VelocityTracker();
+  }
+
+  /**
+   * Movement since the pan began (or since `setTranslation`), client px; the
+   * movement since touch-down while it is still possible.
+   */
+  translation() {
+    return this.locked({
+      x: this.raw.x + this.offset.x,
+      y: this.raw.y + this.offset.y
+    });
+  }
+
+  /**
+   * Change the allowed direction for the next gesture (a pan in progress
+   * keeps the one it began with). The element's touch-action is derived
+   * when the recognizer is attached: switching between directions that
+   * leave the browser the same touches (up and down) needs nothing more.
+   */
+  setDirection(direction) {
+    this.direction = direction;
+  }
+
+  /** UIKit's `setTranslation(_:in:)`: make the current translation read `value`. */
+  setTranslation(value) {
+    this.offset = {
+      x: value.x - this.raw.x,
+      y: value.y - this.raw.y
+    };
+  }
+
+  /** Movement since the fingers landed, threshold included, client px. */
+  totalTranslation() {
+    return this.raw;
+  }
+
+  /**
+   * Velocity in px/s, UIKit's way, for a dragged surface. At the release it
+   * is 0 when the finger rested longer than the stillness interval before
+   * lifting, or moved fewer than twice (spec:AST-100 FR2).
+   */
+  velocity() {
+    return this.locked(this.tracker.velocity(this.releaseTime));
+  }
+
+  /**
+   * A scrolling surface's release velocity in px/s (paging, a wheel): the
+   * scroll-view blend of the pan's last two values, with the same release
+   * rules (architecture:interaction-modality INV10).
+   */
+  scrollVelocity() {
+    return this.locked(this.tracker.scrollVelocity(this.releaseTime ?? this.tracker.lastSample?.time ?? 0));
+  }
+
+  /**
+   * The browser keeps the axis a two-way pan does not use. A one-way pan,
+   * and a pan that coordinates with native scrolling, leave the browser
+   * everything: the other direction still scrolls (a toast dragged away from
+   * its edge scrolls the page), and the pan claims its own direction by
+   * cancelling `touchmove` when it begins, below the distance at which the
+   * browser decides to scroll. Pinch-zoom stays the browser's.
+   */
+  get nativeTouchBehavior() {
+    if (this.scrollEdge || DIRECTION_VECTORS[this.direction] != null) {
+      return ALL_NATIVE_TOUCH;
+    }
+    const horizontal = this.direction === 'horizontal' || this.direction === 'left' || this.direction === 'right';
+    const vertical = this.direction === 'vertical' || this.direction === 'up' || this.direction === 'down';
+    return {
+      panX: vertical,
+      panY: horizontal,
+      pinchZoom: true,
+      doubleTapZoom: false
+    };
+  }
+  acceptsTouch(touch) {
+    if (isActive(this.state) && this.numberOfTouches >= this.maximumNumberOfTouches) {
+      // A moving pan keeps its fingers: an extra one never fails it.
+      return false;
+    }
+    return super.acceptsTouch(touch);
+  }
+  touchesBegan(touches, event) {
+    if (this.numberOfTouches === touches.length) {
+      this.origin = centroid(this.touches.values());
+      this.adjust = ZERO;
+      this.raw = ZERO;
+      this.offset = ZERO;
+      this.tracker.reset();
+      this.tracker.add(this.origin.x, this.origin.y, event.time);
+    } else {
+      this.rebase(new Set(touches.map(touch => touch.id)), 'added');
+    }
+    if (this.state === 'possible' && this.numberOfTouches > this.maximumNumberOfTouches) {
+      this.setState('failed');
+    }
+  }
+  touchesMoved(_touches, event) {
+    this.track(event.time);
+    if (this.state === 'possible') {
+      this.tryBegin();
+    } else if (isActive(this.state)) {
+      this.setState('changed');
+    }
+  }
+  touchesEnded(touches, event) {
+    // UIKit reads neither the translation nor the velocity from the lift; the
+    // lift's time only decides whether the finger was still (AST-100 FR2).
+    const remaining = this.numberOfTouches - touches.length;
+    if (isActive(this.state)) {
+      if (remaining < this.minimumNumberOfTouches) {
+        this.releaseTime = event.time;
+        this.setState('ended');
+        return;
+      }
+      this.rebase(new Set(touches.map(touch => touch.id)), 'removed');
+      return;
+    }
+    if (remaining === 0 || remaining < this.minimumNumberOfTouches) {
+      this.setState('failed');
+      return;
+    }
+    this.rebase(new Set(touches.map(touch => touch.id)), 'removed');
+  }
+  reset() {
+    this.lockedAxis = null;
+    this.travelAtBegan = ZERO;
+    this.origin = ZERO;
+    this.adjust = ZERO;
+    this.raw = ZERO;
+    this.offset = ZERO;
+    this.releaseTime = undefined;
+    this.tracker.reset();
+  }
+
+  /**
+   * What this movement means for a pan limited to a direction: begin, fail,
+   * or undecided (between `axisRatio`'s lines), which fails it too once it
+   * reaches its hysteresis.
+   */
+  classify(translation) {
+    if (this.direction === 'any') {
+      return 'begin';
+    }
+    const isHorizontal = this.direction === 'horizontal' || this.direction === 'left' || this.direction === 'right';
+    const along = isHorizontal ? translation.x : translation.y;
+    const across = Math.abs(isHorizontal ? translation.y : translation.x);
+    const magnitude = Math.abs(along);
+    if (magnitude > this.axisRatio * across) {
+      // The axis is decided; a one-way pan also needs the right sign.
+      const vector = DIRECTION_VECTORS[this.direction];
+      const sign = vector == null ? 0 : vector.x + vector.y;
+      return sign === 0 || Math.sign(along) === sign ? 'begin' : 'fail';
+    }
+    return across * Math.min(1, this.axisRatio) > magnitude ? 'fail' : 'wait';
+  }
+  tryBegin() {
+    const count = this.numberOfTouches;
+    if (count < this.minimumNumberOfTouches) {
+      return;
+    }
+    if (count > this.maximumNumberOfTouches) {
+      this.setState('failed');
+      return;
+    }
+    const moved = this.raw;
+    if (Math.max(Math.abs(moved.x), Math.abs(moved.y)) < this.hysteresis) {
+      return;
+    }
+    const verdict = this.classify(moved);
+    if (verdict === 'fail') {
+      this.setState('failed');
+      return;
+    }
+    if (verdict === 'wait') {
+      // Past its 10 px begin and still no clear axis: a pan that competes
+      // with native scrolling must decide by then (`spec:AST-094` FR19), so
+      // it leaves the touch to the browser.
+      this.setState('failed');
+      return;
+    }
+    if (this.scrollEdge && this.nativeCanScroll(moved.x, moved.y)) {
+      // The content under the finger still scrolls this way: it is a scroll,
+      // the browser's to the lift (FR14).
+      this.setState('failed');
+      return;
+    }
+    if (this.lockAxis && this.direction === 'any') {
+      this.lockedAxis = Math.abs(moved.x) >= Math.abs(moved.y) ? 'x' : 'y';
+    }
+    this.startFromHere();
+    this.setState('began');
+  }
+
+  /**
+   * Leave the threshold's travel out of the translation, as UIKit does at
+   * .began: up to `hysteresis` px per axis, so a slow drag starts at zero and
+   * a step that overshoots keeps the overshoot (measured: a slow diagonal
+   * that crossed at (10.67, 10.67) reads (0.67, 0.67); a 3:1 drag crossing at
+   * (11, 3.67) reads (1, 0)). Some fast first moves read zero in UIKit; that
+   * case is not modelled.
+   */
+  startFromHere() {
+    const limit = this.hysteresis;
+    const swallowed = {
+      x: Math.sign(this.raw.x) * Math.min(Math.abs(this.raw.x), limit),
+      y: Math.sign(this.raw.y) * Math.min(Math.abs(this.raw.y), limit)
+    };
+    this.travelAtBegan = swallowed;
+    this.offset = {
+      x: -swallowed.x,
+      y: -swallowed.y
+    };
+  }
+  nativeCanScroll(dx, dy) {
+    for (const touch of this.touches.values()) {
+      if (touch.scroll?.canScroll(dx, dy) === true) {
+        return true;
+      }
+    }
+    return false;
+  }
+  track(time) {
+    const current = centroid(this.touches.values());
+    const virtual = {
+      x: current.x + this.adjust.x,
+      y: current.y + this.adjust.y
+    };
+    // UIKit's filter runs once per event.
+    this.tracker.add(virtual.x, virtual.y, time);
+    this.raw = {
+      x: virtual.x - this.origin.x,
+      y: virtual.y - this.origin.y
+    };
+  }
+
+  /** Keep the translation continuous when fingers join or leave. */
+  rebase(changedIds, kind) {
+    const all = centroid(this.touches.values());
+    const others = centroid(this.touches.values(), changedIds);
+    const [before, after] = kind === 'added' ? [others, all] : [all, others];
+    this.adjust = {
+      x: this.adjust.x + before.x - after.x,
+      y: this.adjust.y + before.y - after.y
+    };
+  }
+  locked(value) {
+    if (this.lockedAxis === 'x') {
+      return {
+        x: value.x,
+        y: 0
+      };
+    }
+    if (this.lockedAxis === 'y') {
+      return {
+        x: 0,
+        y: value.y
+      };
+    }
+    return value;
+  }
+}

package/dist/gestures/TapGestureRecognizer.d.ts

@@ -0,0 +1,39 @@
+import { GestureRecognizer, type GestureRecognizerOptions, type NativeTouchBehavior } from './GestureRecognizer.js';
+import type { GestureEventContext, GestureTouch } from './types.js';
+export interface TapGestureRecognizerOptions extends GestureRecognizerOptions<TapGestureRecognizer> {
+    /** @default 1 */
+    numberOfTapsRequired?: number;
+    /** @default 1 */
+    numberOfTouchesRequired?: number;
+    allowableMovement?: number;
+    maximumIntervalBetweenTaps?: number;
+    allowableSeparation?: number;
+    maximumTapDuration?: number;
+}
+export declare class TapGestureRecognizer extends GestureRecognizer {
+    numberOfTapsRequired: number;
+    numberOfTouchesRequired: number;
+    allowableMovement: number;
+    maximumIntervalBetweenTaps: number;
+    allowableSeparation: number;
+    maximumTapDuration: number;
+    private tapCount;
+    private isTapInProgress;
+    private maxTouchesThisTap;
+    /** Where the first tap's fingers lifted: their centroid. */
+    private firstTapLocation;
+    /** The current tap's fingers: where each landed and where each lifted. */
+    private tapStarts;
+    private tapLifts;
+    constructor(options?: TapGestureRecognizerOptions);
+    get isDiscrete(): boolean;
+    get nativeTouchBehavior(): NativeTouchBehavior;
+    /** Taps completed so far in the current sequence. */
+    get completedTaps(): number;
+    isInvolved(): 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=TapGestureRecognizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TapGestureRecognizer.d.ts","sourceRoot":"","sources":["../../src/gestures/TapGestureRecognizer.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,iBAAiB,EAEjB,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACzB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAC,mBAAmB,EAAE,YAAY,EAAQ,MAAM,SAAS,CAAC;AAEtE,MAAM,WAAW,2BAA4B,SAAQ,wBAAwB,CAAC,oBAAoB,CAAC;IACjG,iBAAiB;IACjB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iBAAiB;IACjB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAID,qBAAa,oBAAqB,SAAQ,iBAAiB;IACzD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,uBAAuB,EAAE,MAAM,CAAC;IAChC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,0BAA0B,EAAE,MAAM,CAAC;IACnC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAE3B,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,iBAAiB,CAAK;IAC9B,4DAA4D;IAC5D,OAAO,CAAC,gBAAgB,CAAsB;IAC9C,0EAA0E;IAC1E,OAAO,CAAC,SAAS,CAA4B;IAC7C,OAAO,CAAC,QAAQ,CAA4B;gBAEhC,OAAO,GAAE,2BAAgC;IAerD,IAAa,UAAU,IAAI,OAAO,CAEjC;IAED,IAAa,mBAAmB,IAAI,mBAAmB,CAEtD;IAED,qDAAqD;IACrD,IAAI,aAAa,IAAI,MAAM,CAE1B;IAEQ,UAAU,IAAI,OAAO;cAIX,YAAY,CAC7B,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,KAAK,EAAE,mBAAmB,GACzB,IAAI;cAoCY,YAAY,CAAC,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,GAAG,IAAI;cAMxD,YAAY,CAC7B,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,KAAK,EAAE,mBAAmB,GACzB,IAAI;cA6BY,KAAK,IAAI,IAAI;CAQjC"}

package/dist/gestures/TapGestureRecognizer.js

@@ -0,0 +1,151 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file TapGestureRecognizer.ts
+ * @input Touches from a GestureArena
+ * @output Exports TapGestureRecognizer (UITapGestureRecognizer) and its options
+ * @position Discrete recognizer of packages/core/src/gestures
+ *
+ * Recognizes when `numberOfTapsRequired` taps of `numberOfTouchesRequired`
+ * fingers each have lifted. A tap fails when a finger travels further than
+ * `allowableMovement`, when more fingers land than required, when the next
+ * tap does not land within `maximumIntervalBetweenTaps` of the previous lift
+ * or lands further than `allowableSeparation` from the first, or when a
+ * finger stays down longer than `maximumTapDuration`. With several fingers a
+ * tap is placed at their centroid: the first tap where its fingers lifted,
+ * the next where its fingers landed, once all of them have.
+ *
+ * Between taps the recognizer stays `possible` with no touches, so a single
+ * tap that requires a double tap to fail waits the interval out, as in UIKit.
+ */
+
+import { UIKIT_TAP } from "../motion/uikit/gestures.js";
+import { distance, travel } from "./geometry.js";
+import { GestureRecognizer, MANIPULATION } from "./GestureRecognizer.js";
+const TAP = UIKIT_TAP;
+export class TapGestureRecognizer extends GestureRecognizer {
+  tapCount = 0;
+  isTapInProgress = false;
+  maxTouchesThisTap = 0;
+  /** Where the first tap's fingers lifted: their centroid. */
+  firstTapLocation = null;
+  /** The current tap's fingers: where each landed and where each lifted. */
+  tapStarts = new Map();
+  tapLifts = new Map();
+  constructor(options = {}) {
+    super(options);
+    this.numberOfTapsRequired = options.numberOfTapsRequired ?? 1;
+    this.numberOfTouchesRequired = options.numberOfTouchesRequired ?? 1;
+    this.allowableMovement = options.allowableMovement ?? TAP.allowableMovement.value;
+    this.maximumIntervalBetweenTaps = options.maximumIntervalBetweenTaps ?? TAP.maximumIntervalBetweenTaps.value;
+    this.allowableSeparation = options.allowableSeparation ?? TAP.allowableSeparation.value;
+    this.maximumTapDuration = options.maximumTapDuration ?? TAP.maximumTapDuration.value;
+  }
+  get isDiscrete() {
+    return true;
+  }
+  get nativeTouchBehavior() {
+    return MANIPULATION;
+  }
+
+  /** Taps completed so far in the current sequence. */
+  get completedTaps() {
+    return this.tapCount;
+  }
+  isInvolved() {
+    return super.isInvolved() || this.tapCount > 0;
+  }
+  touchesBegan(touches, event) {
+    if (!this.isTapInProgress) {
+      this.isTapInProgress = true;
+      this.tapStarts.clear();
+      this.tapLifts.clear();
+      this.maxTouchesThisTap = 0;
+      this.clearTimer();
+      if (Number.isFinite(this.maximumTapDuration)) {
+        this.setTimer(event.time + this.maximumTapDuration, () => {
+          this.setState('failed');
+        });
+      }
+    }
+    for (const touch of touches) {
+      this.tapStarts.set(touch.id, {
+        x: touch.startX,
+        y: touch.startY
+      });
+    }
+    this.maxTouchesThisTap = Math.max(this.maxTouchesThisTap, this.numberOfTouches);
+    if (this.numberOfTouches > this.numberOfTouchesRequired) {
+      this.setState('failed');
+      return;
+    }
+    // A later tap must land near the first: compared once all of its
+    // fingers have landed, centroid to centroid.
+    if (this.firstTapLocation != null && this.tapStarts.size === this.numberOfTouchesRequired && distance(centerOf(this.tapStarts.values()), this.firstTapLocation) > this.allowableSeparation) {
+      this.setState('failed');
+    }
+  }
+  touchesMoved(touches) {
+    if (touches.some(touch => travel(touch) > this.allowableMovement)) {
+      this.setState('failed');
+    }
+  }
+  touchesEnded(touches, event) {
+    if (touches.some(touch => travel(touch) > this.allowableMovement)) {
+      this.setState('failed');
+      return;
+    }
+    for (const touch of touches) {
+      this.tapLifts.set(touch.id, {
+        x: touch.x,
+        y: touch.y
+      });
+    }
+    if (this.numberOfTouches - touches.length > 0) {
+      // Wait for every finger of this tap to lift.
+      return;
+    }
+    this.isTapInProgress = false;
+    this.clearTimer();
+    if (this.maxTouchesThisTap !== this.numberOfTouchesRequired) {
+      this.setState('failed');
+      return;
+    }
+    this.tapCount += 1;
+    this.firstTapLocation ??= centerOf(this.tapLifts.values());
+    if (this.tapCount >= this.numberOfTapsRequired) {
+      this.setState('ended');
+      return;
+    }
+    this.setTimer(event.time + this.maximumIntervalBetweenTaps, () => {
+      this.setState('failed');
+    });
+  }
+  reset() {
+    this.tapCount = 0;
+    this.isTapInProgress = false;
+    this.maxTouchesThisTap = 0;
+    this.firstTapLocation = null;
+    this.tapStarts.clear();
+    this.tapLifts.clear();
+  }
+}
+
+/** The centroid of some points. */
+function centerOf(points) {
+  let x = 0;
+  let y = 0;
+  let count = 0;
+  for (const point of points) {
+    x += point.x;
+    y += point.y;
+    count += 1;
+  }
+  return count === 0 ? {
+    x: 0,
+    y: 0
+  } : {
+    x: x / count,
+    y: y / count
+  };
+}