@astryxdesign/core 0.7.5 → 0.7.6-canary.0bd3b37

package/dist/gestures/PressTracker.js

@@ -0,0 +1,267 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file PressTracker.ts
+ * @input Touches the arena delivers to a pressable view (TouchConsumer)
+ * @output Exports createPressTracker and its PressTracker interface
+ *   (UIControl's touch tracking, built by a factory per
+ *   architecture:react-component-runtime INV13), its options, the
+ *   control event type, and PRESS_PROFILES (a control's and a table cell's
+ *   tracking and release clock)
+ * @position View-level consumer of packages/core/src/gestures: what a
+ *   UIControl does with the touches no gesture recognizer took
+ *
+ * UIControl semantics, event for event:
+ *
+ * - `touchDown` when the finger lands; the highlight comes on in the same
+ *   frame, unless the control sits in a scroller, where it waits
+ *   `contentTouchDelay` (UIScrollView.delaysContentTouches) so a flick
+ *   paints nothing.
+ * - `touchDragInside` / `touchDragOutside` on every move, `touchDragExit` /
+ *   `touchDragEnter` when the finger crosses the control's bounds EXPANDED
+ *   by `trackingExpansion` (a fingertip dragged a little off a button is
+ *   still on it). The highlight follows inside / outside.
+ * - `touchUpInside` / `touchUpOutside` at the lift. A tap quicker than the
+ *   scroller delay shows the highlight at the lift for `quickTapFlash`.
+ * - `touchCancel` when a recognizer took the touch (`cancelsTouchesInView`)
+ *   or the browser took it to scroll: the highlight goes at once, with no
+ *   release, one frame before the content moves.
+ *
+ * Two profiles (PRESS_PROFILES) cover what UIKit does:
+ *
+ * - `control` (a button, a switch): as above.
+ * - `cell` (a table or collection row): the highlight waits the
+ *   content-touch delay inside a scroll view and comes on at once outside one
+ *   (`spec:AST-094` FR11), travel past the pan hysteresis cancels the press
+ *   for good (the scroll view took the touch), and a quicker tap highlights
+ *   at the lift straight into the release, with no flash.
+ *
+ * And UIControl's iOS 6 rule: a single-finger single tap recognizer on an
+ * ANCESTOR does not beat the control's own action for a touch on it (the
+ * default veto; `vetoesAncestorRecognizer` replaces it, as a slider vetoes a
+ * pan along its track).
+ *
+ * The bounds are read once, when the finger lands; nothing reads layout
+ * during the press. Activation stays the browser's click, which the arena
+ * swallows for a touch a recognizer took.
+ */
+
+import { UIKIT_GESTURES } from "../motion/uikit/gestures.js";
+import { timing } from "../motion/uikit/timing.js";
+import { travel } from "./geometry.js";
+const PRESS = UIKIT_GESTURES.press;
+
+/**
+ * How a kind of pressable tracks a finger and how long its release takes.
+ */
+
+export const PRESS_PROFILES = {
+  /** UIControl: same-frame highlight outside scrollers, 70 pt tracking. */
+  control: {
+    highlightDelay: 'inScrollers',
+    quickTapFlash: PRESS.quickTapFlash.value,
+    // The shared press styles release every surface on the deselect clock
+    // until a control runs its own release (UIButton's 250 ms), so a
+    // painter's `fading` never outlasts the fade it shows.
+    releaseMs: timing.press.highlightOutMs
+  },
+  /**
+   * A table or collection cell: inside a scroll view it highlights after the
+   * content-touch delay, outside one at once (AST-094 FR11: the delay applies
+   * only inside scroll views); cancelled by the scroll.
+   */
+  cell: {
+    highlightDelay: 'inScrollers',
+    cancelTravel: UIKIT_GESTURES.pan.hysteresis.value,
+    quickTapFlash: 0,
+    releaseMs: timing.press.highlightOutMs
+  }
+};
+/**
+ * UIButton's rule, the tracker's default ancestor veto: an ancestor's
+ * single-finger single tap. A tap is told apart by its `kind`
+ * (`architecture:react-component-runtime` INV13).
+ */
+export function vetoesSingleTap(recognizer) {
+  if (recognizer.kind !== 'tap') {
+    return false;
+  }
+  const tap = recognizer;
+  return tap.numberOfTapsRequired === 1 && tap.numberOfTouchesRequired === 1;
+}
+
+/**
+ * A control's touch tracking, the gesture host's consumer for one element
+ * (UIControl's `beginTracking` / `continueTracking` / `endTracking`): it
+ * reports control events and the highlight. Built by
+ * {@link createPressTracker}.
+ */
+
+/** Track a control's touches (see {@link PressTracker}). */
+export function createPressTracker(options) {
+  let touchId = null;
+  let bounds = null;
+  let highlightTimer = null;
+  let flashTimer = null;
+  /** A pending highlight whose finger travelled: it will never paint. */
+  let isPendingDead = false;
+  const state = {
+    isHighlighted: false,
+    isTracking: false,
+    isTouchInside: false
+  };
+  const contains = touch => {
+    if (bounds == null) {
+      return true;
+    }
+    const margin = tracker.trackingExpansion;
+    return touch.x >= bounds.left - margin && touch.x <= bounds.right + margin && touch.y >= bounds.top - margin && touch.y <= bounds.bottom + margin;
+  };
+  const emit = (event, touch) => {
+    options.onControlEvent?.(event, touch);
+  };
+  const setHighlighted = value => {
+    if (state.isHighlighted === value) {
+      return;
+    }
+    state.isHighlighted = value;
+    options.onHighlightChange?.(value);
+  };
+  const clearHighlightTimer = () => {
+    if (highlightTimer != null) {
+      clearTimeout(highlightTimer);
+      highlightTimer = null;
+    }
+  };
+  const clearFlash = () => {
+    if (flashTimer != null) {
+      clearTimeout(flashTimer);
+      flashTimer = null;
+    }
+  };
+  const finish = () => {
+    touchId = null;
+    state.isTracking = false;
+    state.isTouchInside = false;
+    bounds = null;
+  };
+  const touchCancelled = touch => {
+    if (touch.id !== touchId) {
+      return;
+    }
+    clearHighlightTimer();
+    emit('touchCancel', touch);
+    setHighlighted(false);
+    finish();
+  };
+  const tracker = {
+    get isHighlighted() {
+      return state.isHighlighted;
+    },
+    get isTracking() {
+      return state.isTracking;
+    },
+    get isTouchInside() {
+      return state.isTouchInside;
+    },
+    trackingExpansion: options.trackingExpansion ?? UIKIT_GESTURES.control.trackingExpansion.value,
+    isEnabled() {
+      return options.isEnabled?.() !== false;
+    },
+    touchBegan(touch) {
+      if (touchId != null || options.isEnabled?.() === false ||
+      // The scroll brake is a finger's (`spec:AST-094` FR11, DEC-21).
+      touch.pointerType === 'touch' && options.isBraking?.(touch) === true) {
+        return;
+      }
+      clearFlash();
+      touchId = touch.id;
+      bounds = options.getBounds();
+      state.isTracking = true;
+      state.isTouchInside = true;
+      isPendingDead = false;
+      emit('touchDown', touch);
+      const delay = options.highlightDelay ?? 'inScrollers';
+      const delays = touch.pointerType === 'touch' && (delay === 'always' || delay === 'inScrollers' && touch.scroll?.isInsideScroller === true);
+      if (delays) {
+        highlightTimer = setTimeout(() => {
+          highlightTimer = null;
+          if (state.isTouchInside) {
+            setHighlighted(true);
+          }
+        }, PRESS.contentTouchDelay.value);
+      } else {
+        setHighlighted(true);
+      }
+    },
+    touchMoved(touch) {
+      if (touch.id !== touchId) {
+        return;
+      }
+      const cancelTravel = options.cancelTravel;
+      if (cancelTravel != null && travel(touch) > cancelTravel) {
+        // A cell's scroll view took the touch: the press is over.
+        touchCancelled(touch);
+        return;
+      }
+      if (highlightTimer != null && travel(touch) > PRESS.slop.value) {
+        // A finger travelling before the delay ran out is scrolling: the
+        // press it began never paints, as a flick on a list paints nothing.
+        clearTimeout(highlightTimer);
+        highlightTimer = null;
+        isPendingDead = true;
+      }
+      const inside = contains(touch);
+      if (inside !== state.isTouchInside) {
+        state.isTouchInside = inside;
+        emit(inside ? 'touchDragEnter' : 'touchDragExit', touch);
+        if (highlightTimer == null && !isPendingDead) {
+          setHighlighted(inside);
+        }
+      }
+      emit(inside ? 'touchDragInside' : 'touchDragOutside', touch);
+    },
+    touchEnded(touch) {
+      if (touch.id !== touchId) {
+        return;
+      }
+      const inside = contains(touch);
+      const wasPending = highlightTimer != null;
+      clearHighlightTimer();
+      emit(inside ? 'touchUpInside' : 'touchUpOutside', touch);
+      const flash = options.quickTapFlash ?? PRESS.quickTapFlash.value;
+      if (wasPending && inside) {
+        // Quicker than the delay: the highlight shows at the lift, for the
+        // flash, or (a cell) straight into the release.
+        setHighlighted(true);
+        if (flash > 0) {
+          flashTimer = setTimeout(() => {
+            flashTimer = null;
+            setHighlighted(false);
+          }, flash);
+        } else {
+          setHighlighted(false);
+        }
+      } else {
+        setHighlighted(false);
+      }
+      finish();
+    },
+    touchCancelled,
+    allowsAncestorRecognizer(recognizer) {
+      const candidate = recognizer;
+      if (candidate.view != null && candidate.view === options.view) {
+        return true;
+      }
+      const vetoes = options.vetoesAncestorRecognizer ?? vetoesSingleTap;
+      return !vetoes(candidate);
+    },
+    dispose() {
+      clearHighlightTimer();
+      clearFlash();
+      setHighlighted(false);
+      finish();
+    }
+  };
+  return tracker;
+}

package/dist/gestures/ScreenEdgePanGestureRecognizer.d.ts

@@ -0,0 +1,71 @@
+import { type NativeTouchBehavior } from './GestureRecognizer.js';
+import { PanGestureRecognizer, type PanGestureRecognizerOptions } from './PanGestureRecognizer.js';
+import type { GestureEventContext, GestureTouch } from './types.js';
+/**
+ * An edge by writing direction: under RTL the leading edge is the right one.
+ * Top and bottom edges land with their first user.
+ */
+export type ScreenEdge = 'leading' | 'trailing';
+/** A physical horizontal edge of the viewport. */
+type PhysicalEdge = 'left' | 'right';
+/**
+ * A screen-edge pan is a finger's: it takes no `allowedPointerTypes`
+ * (`spec:AST-094` FR43).
+ */
+export interface ScreenEdgePanGestureRecognizerOptions extends Omit<PanGestureRecognizerOptions, 'direction' | 'allowedPointerTypes'> {
+    /** The edges a touch may start from. @default ['leading'] */
+    edges?: ReadonlyArray<ScreenEdge>;
+    /** Width of the band at each edge, px. */
+    edgeRegion?: number;
+}
+export declare class ScreenEdgePanGestureRecognizer extends PanGestureRecognizer {
+    get kind(): PanGestureRecognizer['kind'];
+    edges: ReadonlyArray<ScreenEdge>;
+    edgeRegion: number;
+    /** The physical edge the current gesture started from. */
+    activeEdge: PhysicalEdge | null;
+    /**
+     * @internal Set by the host while attached: called when the edge-zone
+     * answer changes, so the element's `touch-action` follows it
+     * (spec:AST-094 FR19, DEC-22).
+     */
+    onTouchBehaviorChange: (() => void) | null;
+    /** The hysteresis where the pan takes its axis (UIKit's 15 px). */
+    private readonly edgeHysteresis;
+    /** What the pan measured of its view (see EdgeLayout), until a layout change. */
+    private layout;
+    constructor(options?: ScreenEdgePanGestureRecognizerOptions);
+    /**
+     * The pan takes the horizontal axis only in its edge zone, a view within
+     * the band of an edge it watches; elsewhere it leaves the browser every
+     * touch behavior, so the author's scrolling is untouched (spec:AST-094
+     * FR18), never claiming across a whole wider element.
+     */
+    get nativeTouchBehavior(): NativeTouchBehavior;
+    /**
+     * @internal Whether the edge zone depends on the viewport's width: the pan
+     * watches the right side, whose band moves with the viewport, so the host
+     * reports a viewport resize to it as well as its own box's (FR19, FR24).
+     */
+    get watchesViewport(): boolean;
+    /**
+     * @internal The view's box may have changed (a resize): its edges' sides
+     * and the edge zone are measured again, and a changed answer calls
+     * onTouchBehaviorChange.
+     */
+    layoutChanged(): void;
+    protected touchesBegan(touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    /**
+     * The physical sides the pan's edges resolve to under the view's writing
+     * direction, and the sides whose band the view lies within, measured
+     * together once until a layout change: the view starts at that side and
+     * reaches no farther than `edgeRegion` from it, within layout's rounding
+     * (a strip authored at the 40.2 px region lays out at 40.203 px, on
+     * 1/64 px). A view that cannot be measured lies within none.
+     */
+    private measured;
+    protected reset(): void;
+    private edgeAt;
+}
+export {};
+//# sourceMappingURL=ScreenEdgePanGestureRecognizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScreenEdgePanGestureRecognizer.d.ts","sourceRoot":"","sources":["../../src/gestures/ScreenEdgePanGestureRecognizer.ts"],"names":[],"mappings":"AAsCA,OAAO,EAAmB,KAAK,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AAC/E,OAAO,EACL,oBAAoB,EACpB,KAAK,2BAA2B,EACjC,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAC,mBAAmB,EAAE,YAAY,EAAC,MAAM,SAAS,CAAC;AAS/D;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,UAAU,CAAC;AAEhD,kDAAkD;AAClD,KAAK,YAAY,GAAG,MAAM,GAAG,OAAO,CAAC;AAarC;;;GAGG;AACH,MAAM,WAAW,qCAAsC,SAAQ,IAAI,CACjE,2BAA2B,EAC3B,WAAW,GAAG,qBAAqB,CACpC;IACC,6DAA6D;IAC7D,KAAK,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IAClC,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,8BAA+B,SAAQ,oBAAoB;IACtE,IAAa,IAAI,IAAI,oBAAoB,CAAC,MAAM,CAAC,CAEhD;IAED,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,UAAU,EAAE,YAAY,GAAG,IAAI,CAAQ;IACvC;;;;OAIG;IACH,qBAAqB,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAQ;IAClD,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,iFAAiF;IACjF,OAAO,CAAC,MAAM,CAA2B;gBAE7B,OAAO,GAAE,qCAA0C;IAe/D;;;;;OAKG;IACH,IAAa,mBAAmB,IAAI,mBAAmB,CAWtD;IAED;;;;OAIG;IACH,IAAI,eAAe,IAAI,OAAO,CAE7B;IAED;;;;OAIG;IACH,aAAa,IAAI,IAAI;cAcF,YAAY,CAC7B,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,KAAK,EAAE,mBAAmB,GACzB,IAAI;IAiCP;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ;cAyBG,KAAK,IAAI,IAAI;IAKhC,OAAO,CAAC,MAAM;CAaf"}

package/dist/gestures/ScreenEdgePanGestureRecognizer.js

@@ -0,0 +1,223 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file ScreenEdgePanGestureRecognizer.ts
+ * @input Touches from a GestureArena; the viewport size and writing
+ *   direction from its environment
+ * @output Exports ScreenEdgePanGestureRecognizer
+ *   (UIScreenEdgePanGestureRecognizer), its options and edge type
+ * @position Continuous recognizer of packages/core/src/gestures, a pan that
+ *   only starts from a band at the edge of the viewport
+ *
+ * A touch that lands outside every requested band fails at once, so a
+ * recognizer that requires this one to fail is not held up by a touch in the
+ * middle of the screen. Inside a band, the pan begins on movement away from
+ * that edge. `leading` and `trailing` resolve against the view's writing
+ * direction: under RTL the leading edge is the right one, as the
+ * interactive pop gesture's is.
+ *
+ * Attach it to the edge zone: an element that lies within the band at its
+ * edge. There the pan takes the horizontal axis from the browser, which has
+ * nothing to scroll in so thin a band, so a touch in the band decides at
+ * UIKit's 15 px screen-edge hysteresis. On any other view, whose
+ * `touch-action` cannot claim per touch, it leaves the browser every touch
+ * behavior, so the author's scrolling there is untouched, and a touch in the
+ * band decides at FR19's 10 px like every other claim (spec:AST-094 FR18,
+ * DEC-22). The edges' physical sides and the edge zone are measured once,
+ * together, and serve both the element's `touch-action` and the touch-down
+ * decision; the host reports a layout change (layoutChanged), and a changed
+ * answer is announced (onTouchBehaviorChange) so `touch-action` follows it
+ * (FR19). The writing direction is read again at each touch-down: a view
+ * switched to RTL in place, with no resize, is measured again there and the
+ * change announced, so a `leading` back swipe follows the new leading edge
+ * (`design:bidirectionality` DR13). That touch landed under the touch-action
+ * from before, so it decides at FR19's 10 px unless that one claimed the
+ * axis.
+ */
+
+import { UIKIT_PAN, UIKIT_SCREEN_EDGE_PAN } from "../motion/uikit/gestures.js";
+import { ALL_NATIVE_TOUCH } from "./GestureRecognizer.js";
+import { PanGestureRecognizer } from "./PanGestureRecognizer.js";
+/**
+ * How far past `edgeRegion` a view still counts as the edge zone, px: layout
+ * snaps sizes to 1/64 px, so a strip authored at the region measures a hair
+ * wider; half a pixel takes that and nothing a pixel wider.
+ */
+const EDGE_ZONE_TOLERANCE = 0.5;
+
+/**
+ * An edge by writing direction: under RTL the leading edge is the right one.
+ * Top and bottom edges land with their first user.
+ */
+
+/** A physical horizontal edge of the viewport. */
+
+/**
+ * What the pan measures of its view, once until a layout change: the
+ * writing direction it read, the physical sides its edges resolve to under
+ * that direction, and the sides whose band the view lies within.
+ */
+
+/**
+ * A screen-edge pan is a finger's: it takes no `allowedPointerTypes`
+ * (`spec:AST-094` FR43).
+ */
+
+export class ScreenEdgePanGestureRecognizer extends PanGestureRecognizer {
+  get kind() {
+    return 'screenEdgePan';
+  }
+  /** The physical edge the current gesture started from. */
+  activeEdge = null;
+  /**
+   * @internal Set by the host while attached: called when the edge-zone
+   * answer changes, so the element's `touch-action` follows it
+   * (spec:AST-094 FR19, DEC-22).
+   */
+  onTouchBehaviorChange = null;
+  /** The hysteresis where the pan takes its axis (UIKit's 15 px). */
+
+  /** What the pan measured of its view (see EdgeLayout), until a layout change. */
+  layout = null;
+  constructor(options = {}) {
+    super({
+      maximumNumberOfTouches: 1,
+      hysteresis: UIKIT_SCREEN_EDGE_PAN.hysteresis.value,
+      ...options,
+      // A finger's only: under a mouse, a trackpad or a pen the screen-edge
+      // pan stays off (`spec:AST-094` FR43), whatever a caller passes.
+      allowedPointerTypes: ['touch']
+    });
+    this.edges = options.edges ?? ['leading'];
+    this.edgeRegion = options.edgeRegion ?? UIKIT_SCREEN_EDGE_PAN.edgeRegion.value;
+    this.edgeHysteresis = this.hysteresis;
+  }
+
+  /**
+   * The pan takes the horizontal axis only in its edge zone, a view within
+   * the band of an edge it watches; elsewhere it leaves the browser every
+   * touch behavior, so the author's scrolling is untouched (spec:AST-094
+   * FR18), never claiming across a whole wider element.
+   */
+  get nativeTouchBehavior() {
+    const {
+      watched,
+      zone
+    } = this.measured();
+    if (!watched.some(edge => zone.has(edge))) {
+      return ALL_NATIVE_TOUCH;
+    }
+    return {
+      panX: false,
+      panY: true,
+      pinchZoom: true,
+      doubleTapZoom: false
+    };
+  }
+
+  /**
+   * @internal Whether the edge zone depends on the viewport's width: the pan
+   * watches the right side, whose band moves with the viewport, so the host
+   * reports a viewport resize to it as well as its own box's (FR19, FR24).
+   */
+  get watchesViewport() {
+    return this.measured().watched.includes('right');
+  }
+
+  /**
+   * @internal The view's box may have changed (a resize): its edges' sides
+   * and the edge zone are measured again, and a changed answer calls
+   * onTouchBehaviorChange.
+   */
+  layoutChanged() {
+    const before = this.layout;
+    this.layout = null;
+    const after = this.measured();
+    if (before == null || before.watched.join() !== after.watched.join() || before.zone.size !== after.zone.size || [...after.zone].some(edge => !before.zone.has(edge))) {
+      this.onTouchBehaviorChange?.();
+    }
+  }
+  touchesBegan(touches, event) {
+    if (this.numberOfTouches === touches.length) {
+      // The touch-action the browser applies to this touch was derived from
+      // the layout in force as it landed: whether that claimed the axis.
+      const inForce = this.measured();
+      const claimedAxis = inForce.watched.some(side => inForce.zone.has(side));
+      // A direction switched in place (no resize) moves the leading edge:
+      // measure again, and announce it so touch-action follows for the next
+      // touch (DR13).
+      if (inForce.isRtl !== this.environment.isRtl(this.view)) {
+        this.layoutChanged();
+      }
+      const edge = this.edgeAt(touches[0]);
+      if (edge == null) {
+        this.setState('failed');
+        return;
+      }
+      this.activeEdge = edge;
+      // On an element within the band, which takes the axis across the edge,
+      // a touch decides at UIKit's 15 px; on any other, which leaves the
+      // browser that axis, at FR19's 10 px, before the browser commits to a
+      // scroll (spec:AST-094 FR18, DEC-22). The answer is the one this
+      // touch's touch-action was derived from: a touch that measured again
+      // decides at 10 px unless the layout in force claimed the axis.
+      const offZone = !claimedAxis || !this.measured().zone.has(edge);
+      this.hysteresis = offZone ? Math.min(this.edgeHysteresis, UIKIT_PAN.hysteresis.value) : this.edgeHysteresis;
+      this.direction = edge === 'left' ? 'right' : 'left';
+    }
+    super.touchesBegan(touches, event);
+  }
+
+  /**
+   * The physical sides the pan's edges resolve to under the view's writing
+   * direction, and the sides whose band the view lies within, measured
+   * together once until a layout change: the view starts at that side and
+   * reaches no farther than `edgeRegion` from it, within layout's rounding
+   * (a strip authored at the 40.2 px region lays out at 40.203 px, on
+   * 1/64 px). A view that cannot be measured lies within none.
+   */
+  measured() {
+    if (this.layout != null) {
+      return this.layout;
+    }
+    const isRtl = this.environment.isRtl(this.view);
+    const watched = this.edges.map(edge => edge === 'leading' !== isRtl ? 'left' : 'right');
+    const zone = new Set();
+    const rect = this.environment.viewRect?.(this.view);
+    if (rect != null && rect.width > 0) {
+      const {
+        width
+      } = this.environment.viewportSize();
+      const right = rect.left + rect.width;
+      const band = this.edgeRegion + EDGE_ZONE_TOLERANCE;
+      if (rect.left >= -EDGE_ZONE_TOLERANCE && right <= band) {
+        zone.add('left');
+      }
+      if (rect.left >= width - band && right <= width + EDGE_ZONE_TOLERANCE) {
+        zone.add('right');
+      }
+    }
+    this.layout = {
+      isRtl,
+      watched,
+      zone
+    };
+    return this.layout;
+  }
+  reset() {
+    super.reset();
+    this.activeEdge = null;
+  }
+  edgeAt(touch) {
+    const {
+      width
+    } = this.environment.viewportSize();
+    for (const physical of this.measured().watched) {
+      const inBand = physical === 'left' ? touch.startX <= this.edgeRegion : touch.startX >= width - this.edgeRegion;
+      if (inBand) {
+        return physical;
+      }
+    }
+    return null;
+  }
+}

package/dist/gestures/SwipeGestureRecognizer.d.ts

@@ -0,0 +1,37 @@
+import { GestureRecognizer, type GestureRecognizerOptions, type NativeTouchBehavior } from './GestureRecognizer.js';
+import type { GestureEventContext, GestureTouch } from './types.js';
+export type SwipeDirection = 'left' | 'right' | 'up' | 'down';
+export interface SwipeGestureRecognizerOptions extends GestureRecognizerOptions<SwipeGestureRecognizer> {
+    /** @default ['right'] */
+    direction?: SwipeDirection | ReadonlyArray<SwipeDirection>;
+    /** @default 1 */
+    numberOfTouchesRequired?: number;
+    minimumDistance?: number;
+    maximumDuration?: number;
+    maximumSecondaryMovement?: number;
+}
+export declare class SwipeGestureRecognizer extends GestureRecognizer {
+    get kind(): GestureRecognizer['kind'];
+    directions: ReadonlyArray<SwipeDirection>;
+    numberOfTouchesRequired: number;
+    minimumDistance: number;
+    maximumDuration: number;
+    maximumSecondaryMovement: number;
+    /** The direction of the recognized swipe. */
+    recognizedDirection: SwipeDirection | null;
+    private origin;
+    /** Directions this touch's path has ruled out. */
+    private readonly ruledOut;
+    /** The centroid at the previous move. */
+    private last;
+    constructor(options?: SwipeGestureRecognizerOptions);
+    get isDiscrete(): boolean;
+    get nativeTouchBehavior(): NativeTouchBehavior;
+    protected touchesBegan(touches: ReadonlyArray<GestureTouch>, event: GestureEventContext): void;
+    protected touchesMoved(): void;
+    /** Travel along and across `direction` from the origin to `point`. */
+    private project;
+    protected touchesEnded(): void;
+    protected reset(): void;
+}
+//# sourceMappingURL=SwipeGestureRecognizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SwipeGestureRecognizer.d.ts","sourceRoot":"","sources":["../../src/gestures/SwipeGestureRecognizer.ts"],"names":[],"mappings":"AAqBA,OAAO,EACL,iBAAiB,EACjB,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACzB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAC,mBAAmB,EAAE,YAAY,EAAQ,MAAM,SAAS,CAAC;AAEtE,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,CAAC;AAE9D,MAAM,WAAW,6BAA8B,SAAQ,wBAAwB,CAAC,sBAAsB,CAAC;IACrG,yBAAyB;IACzB,SAAS,CAAC,EAAE,cAAc,GAAG,aAAa,CAAC,cAAc,CAAC,CAAC;IAC3D,iBAAiB;IACjB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACnC;AAID,qBAAa,sBAAuB,SAAQ,iBAAiB;IAC3D,IAAa,IAAI,IAAI,iBAAiB,CAAC,MAAM,CAAC,CAE7C;IAED,UAAU,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IAC1C,uBAAuB,EAAE,MAAM,CAAC;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,wBAAwB,EAAE,MAAM,CAAC;IACjC,6CAA6C;IAC7C,mBAAmB,EAAE,cAAc,GAAG,IAAI,CAAQ;IAElD,OAAO,CAAC,MAAM,CAAuB;IACrC,kDAAkD;IAClD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,yCAAyC;IACzC,OAAO,CAAC,IAAI,CAAsB;gBAEtB,OAAO,GAAE,6BAAkC;IAavD,IAAa,UAAU,IAAI,OAAO,CAEjC;IAED,IAAa,mBAAmB,IAAI,mBAAmB,CAatD;cAEkB,YAAY,CAC7B,OAAO,EAAE,aAAa,CAAC,YAAY,CAAC,EACpC,KAAK,EAAE,mBAAmB,GACzB,IAAI;cAmBY,YAAY,IAAI,IAAI;IAyCvC,sEAAsE;IACtE,OAAO,CAAC,OAAO;cAYI,YAAY,IAAI,IAAI;cAOpB,KAAK,IAAI,IAAI;CAMjC"}