@n-uf/motion 26.11.4 → 26.11.6

package/CHANGELOG.md

@@ -3,6 +3,62 @@
 Versions are calendar versions, `YY.M.R` (year, month of the release, counter
 within the month), the same scheme as `@n-uf/hypr-tiling`.
 
+## 26.11.6
+
+- `@n-uf/motion/drag`: the README shows a drag on a scaled page (a zoomed
+  canvas, a fitted preview): the intent works in the coordinate space of its
+  targets and home, so each pointer sample goes in as `(p − origin) / scale`.
+- Docs: `item.retarget` is optional on a `LayoutItem` (`holdItem` falls back
+  to `moveTo`); the paged swipe's state diagram shows `cancel` from settling
+  back to idle.
+- Released together with `@n-uf/placement` 26.11.6 (keyboard stops, slots,
+  `allows`, keep priority, stored arrangements).
+
+## 26.11.5
+
+- `@n-uf/motion/drag`: `placeOf(target, point, previous)` is told the place
+  it gave that target on the last sample (null if none), so a place can hold
+  near its boundary (hysteresis lives in the consumer's `placeOf`). It may
+  return null: no drop at that point of the target. There the target is no
+  target: it isn't picked or held, a shown one hides at once (a target beneath
+  with a place can show instead), no room opens, and a release lands on a
+  target beneath, else goes home. A two-argument `placeOf` works as before.
+  `@n-uf/placement/targets`' `paneZone` is made for it. Near the current
+  target's edge (within the band or the gap grace) answer its nearest place:
+  null there would drop the band and the grace.
+  - Changed: `placeOf` is now called on every sample for each target under
+    the pointer and for the current one; in 26.11.4 it was called only for
+    the shown target. Keep it cheap and free of side effects.
+- `@n-uf/motion/layout`: what a tiling host's own leaf motion did, on
+  `createLayoutMotion`:
+  - `onDraw(batch)`: every item that moved is drawn in one pass per frame and
+    handed over once; an item at rest is not drawn;
+  - `reducedMotion` (a boolean or the host's query), read on every new target
+    and show or hide: items are placed and shown at once, no glide or fade;
+  - `flush()` draws a batched change made between frames now, so the paint
+    right after a host's commit shows no frame at the new box;
+  - `retain(ids)` removes every item not listed;
+  - `onActiveChange(active)`, once when the frames start and once when they
+    stop;
+  - `item.retarget(rect)`: a settle that keeps the content laid out while the
+    size is unchanged. The held drag's glide back to the pointer uses it, so
+    it no longer lays the item out on every frame. It is optional on
+    `LayoutItem`: `holdItem` falls back to `moveTo` for an item without it (a
+    26.11.4 item or a test double).
+- Changed: the `LayoutMotion` interface gains `retain` and `flush`, so an
+  implementation of it written outside this package needs both.
+  `createLayoutMotion` has them.
+- `@n-uf/motion/gestures`: `touchPressReducer` / `createTouchPress`, a touch
+  on something draggable in a scrolling page: travel mostly along the scroll
+  direction is never a lift: it is a scroll from 10 px, so a finger scroll
+  reported a few px at a time never lifts on the way. `pagedSwipeReducer` /
+  `createPagedSwipe`, swiping between pages with a wheel run or a finger: it
+  arms only along the swipe, tracks progress over the page size, commits by
+  share or speed and locks out the trackpad's momentum after a commit;
+  `cancel` while it settles goes back to idle, so a host that stops its
+  transition can't leave it stuck. Both from hypr-tiling's public engine, with
+  generic names.
+
 ## 26.11.4
 
 - New entry `@n-uf/motion/drag`: the drag intent model, pure and DOM-free.

package/README.md

@@ -198,8 +198,12 @@ drop targets) is the caller's layout.
 
 | | |
 |---|---|
-| `createLayoutMotion({ loop, omega?, phase?, popFrom? })` | The surface: `add(id, drawable, at, { shown? })`, `get`, `remove`, `items`; `task(fn)` runs before the items step each frame, `onFrame(fn)` after; `onIdle`, `idle()`, `running`, `wake()`, `configure({ omega })`, `dispose()`. |
+| `createLayoutMotion({ loop, omega?, phase?, popFrom?, reducedMotion?, onDraw?, onActiveChange? })` | The surface: `add(id, drawable, at, { shown? })`, `get`, `remove`, `retain(ids)` (removes every item not listed), `items`; `task(fn)` runs before the items step each frame, `onFrame(fn)` after; `onIdle`, `idle()`, `running`, `wake()`, `configure({ omega })`, `flush()`, `dispose()`. |
+| `reducedMotion` | A boolean or the host's query (the reduced-motion media query), read on every new target and every show or hide: while true, items are placed and shown at once, with no glide and no fade. |
+| `onDraw(batch)`, `flush()` | Batched drawing: every item that moved is drawn in one pass per frame (its drawable, then `onDraw` once with all their frames); an item at rest is not drawn. A change made between frames waits for the next frame, or `flush()` draws it now, which a host calls right after it commits a layout so the next paint shows no frame at the new box. |
+| `onActiveChange(active)` | Called once when the frames start and once when they stop. |
 | `item.moveTo(rect)` | Settle there from wherever it is drawn (a retarget mid-flight goes on from the drawn rect). The content is laid out at the new box once, and the item redrawn at once, so no frame shows the old offset from the new box. A size change is revealed, never scaled. |
+| `item.retarget(rect)` | Optional on a `LayoutItem`. Settle there like `moveTo`, but keep the content laid out where it is while the size is unchanged: for chasing a moving point (the held drag's glide back to the pointer uses it), which would otherwise lay the content out on every frame. `holdItem` falls back to `moveTo` for an item without it. |
 | `item.jumpTo(rect)`, `item.hold(rect)`, `item.glideFrom(from, to)` | At once; held exactly where a pointer puts it (the content moves with it); drawn at `from`, then settle to `to`. |
 | `item.show(on, { now? })` | Appear or disappear with a uniform-scale fade (`popIn`); folding is a `moveTo` to the folded size, revealed. |
 | `item.drawn`, `target`, `box`, `settled`, `shown`, `showing`, `shownSettled` | Where it is drawn, where it is heading, where its content is laid out. |
@@ -225,6 +229,27 @@ clock.runUntilIdle();
 console.log(panel.drawn); // { x: 0, y: 0, width: 200, height: 100 }
 ```
 
+A host that draws every item itself, once per frame:
+
+```ts
+import { createFakeClock, createFrameLoop } from "@n-uf/motion";
+import { createLayoutMotion } from "@n-uf/motion/layout";
+
+const clock = createFakeClock();
+const loop = createFrameLoop({ clock });
+const batches: string[][] = [];
+const host = createLayoutMotion({ loop, onDraw: (batch) => batches.push(batch.map((e) => e.id)) });
+const noop = { layOut: () => {}, draw: () => {} };
+const a = host.add("a", noop, { x: 0, y: 0, width: 100, height: 100 });
+host.add("b", noop, { x: 0, y: 200, width: 100, height: 100 });
+host.flush(); // both drawn now, in one batch: ["a", "b"]
+a.moveTo({ x: 300, y: 0, width: 100, height: 100 });
+host.flush(); // right after the host's commit: ["a"], at the rect it is drawn at
+clock.runUntilIdle(); // one batch per frame, each ["a"] (b is at rest)
+host.retain(["a"]); // b left the layout
+console.log(host.items.size); // 1
+```
+
 ## testing/
 
 `@n-uf/motion/testing` checks recorded frames against the rules. Record what
@@ -255,6 +280,8 @@ The motion lab in the [n-uf/motion repository](https://github.com/n-uf/motion)
 | `createFrameCoalescer(onFrame, frames, { merge? })` | `schedule(sample)`, `flush()`, `cancel()`, `pending`. One delivery per frame with the latest sample (or `merge`d ones) and how many were folded. Same shape as hypr-tiling's. |
 | `dwellReducer`, `DWELL_IDLE`, `dwellDeadline`, `createDwellMachine` | `idle → dwelling → fired`, for spring-loaded targets: hold over the same key long enough and it fires once. |
 | `createMachine({ reducer, initial, clock, deadline? })` | Runs a pure reducer on a clock: arms the timer the state's deadline asks for and sends its input when it fires. `state` is reactive. |
+| `touchPressReducer`, `TOUCH_PRESS_IDLE`, `touchPressDeadline`, `createTouchPress`, `TOUCH_PRESS_DEFAULTS` | A touch on something draggable in a scrolling page, `idle → pressed → lifted \| scrolled`: before the hold (220 ms), travel mostly along the page's scroll direction (`scroll: "y"` or `"x"`) past 10 px is a scroll, which never lifts (short of 10 px it waits, so a finger scroll reported a few px at a time never lifts on the way); travel past 6 px mostly across it lifts where the finger is; a still finger lifts where it was pressed after the hold. |
+| `pagedSwipeReducer`, `PAGED_SWIPE_IDLE`, `pagedSwipeDeadline`, `createPagedSwipe`, `PAGED_SWIPE_DEFAULTS`, `swipeProgress` | Swiping between pages with a trackpad's wheel run or a finger, `idle → armed → tracking → settling → lockout`. It arms only along the swipe (more than twice the cross movement), without Ctrl, with the configured modifier, when nothing under the pointer scrolls further and a page is there; a run that breaks a rule belongs to scrolling until the wheel rests 120 ms. Past 24 px it tracks: `progress` is the travel over the page size, −1 to 1, held at 0 towards a missing page. At the end it commits at 35 % of the page or a peak of 0.6 px/ms towards it (the peak starts over when the travel crosses zero); the host sends `settled` after its transition, and a 350 ms lockout swallows the trackpad's momentum. On x or y (`along`). |
 
 The recogniser takes plain objects the host copies out of DOM events, with
 their timestamps; nothing in it touches the DOM. Mouse, pen and touch share
@@ -277,6 +304,22 @@ clock.tick(500); // longPress
 recognizer.feed({ ...finger, type: "pointerup", buttons: 0, time: clock.now() }); // release, click: false
 ```
 
+A paged swipe, its timers on a clock:
+
+```ts
+import { createFakeClock, createPagedSwipe, NO_MODIFIERS } from "@n-uf/motion";
+
+const clock = createFakeClock();
+const swipe = createPagedSwipe({ clock });
+swipe.send({ type: "context", hasPrev: true, hasNext: true, size: 1000 });
+swipe.send({ type: "wheel", dx: 400, dy: 0, t: clock.now(), modifiers: NO_MODIFIERS });
+console.log(swipe.state.phase, swipe.state.progress); // tracking 0.4
+clock.tick(120); // the wheel rests: past 35 %, it commits
+console.log(swipe.state.phase, swipe.state.target); // settling next
+swipe.send({ type: "settled" }); // the host's page transition is done: momentum is locked out
+console.log(swipe.state.phase); // lockout
+```
+
 ## drag/
 
 `@n-uf/motion/drag` decides, from the pointer's path, when a drop indicator
@@ -305,6 +348,14 @@ a large area 3). The rules:
   new target has held 150 ms, so no indicator ever shows for less.
 - Room is made once the shown target, and the place in it (`placeOf`: a tab
   index, say), have held 160 ms; never for a `free` target.
+- `placeOf(target, point, previous)` gets the place it gave that target on the
+  last sample, so a place can hold near its boundary. A null place is no
+  target: nothing shows there (a target beneath with a place can), no room
+  opens, and a release there lands on a target beneath, else goes home.
+  `placeOf` is also asked about the current target just outside its zone
+  (within the band or the gap grace): answer the nearest place there, and
+  return null only for a part of the target that takes no drop. It runs on
+  every sample for each target under the pointer, so keep it cheap.
 - A release lands on the shown target whenever one shows (drop = shown), else
   on the target under the pointer, else nowhere. A release over home does
   nothing.
@@ -319,6 +370,30 @@ const intent = createDragIntent({ home: { x: 300, y: 300, width: 100, height: 50
 for (let t = 0; t <= 300; t += 16) intent.update({ x: 100, y: 50 }, t, [slot]); // held still over the slot
 console.log(intent.state.shown?.id); // "slot"
 console.log(intent.release({ x: 100, y: 50 }, [slot])?.id); // "slot"
+
+// A pane that takes drops on its right half only; that half holds 6 px past the line.
+const pane: DragTarget = { id: "pane", priority: 2, hit: { x: 0, y: 0, width: 200, height: 100 } };
+const zones = createDragIntent<DragTarget>({
+  home: { x: 300, y: 300, width: 100, height: 50 },
+  placeOf: (_t, p, previous) => (p.x >= (previous === "right" ? 94 : 100) ? "right" : null),
+});
+for (let t = 0; t <= 300; t += 16) zones.update({ x: 50, y: 50 }, t, [pane]); // held over its left half
+console.log(zones.state.shown, zones.release({ x: 50, y: 50 }, [pane])); // null null: nothing shows, the item goes home
+```
+
+The intent works in one coordinate space: the one its targets and home are in. On a page drawn scaled (a zoomed
+canvas, a fitted preview), convert each pointer sample into page coordinates first, `(p − origin) / scale`, and the
+band, breakthrough and stillness distances stay page px:
+
+```ts
+// The page is drawn at half size, its top-left corner at (300, 200) on screen; targets are in page px.
+const origin = { x: 300, y: 200 };
+const scale = 0.5;
+const toPage = (p: { x: number; y: number }) => ({ x: (p.x - origin.x) / scale, y: (p.y - origin.y) / scale });
+const onPage = createDragIntent({ home: { x: 600, y: 600, width: 100, height: 50 } });
+const screen = { x: 350, y: 225 }; // the pointer, as the browser reports it
+for (let t = 0; t <= 300; t += 16) onPage.update(toPage(screen), t, [slot]); // page (100, 50): over the slot
+console.log(onPage.state.shown?.id, onPage.release(toPage(screen), [slot])?.id); // "slot" "slot"
 ```
 
 ## @n-uf/motion/browser

package/dist/{chunk-C4M62FUT.js → chunk-KVFX5V4Y.js}

@@ -571,6 +571,218 @@ function createDwellMachine(options) {
   });
 }
 
+// src/gestures/touch-press.ts
+var TOUCH_PRESS_DEFAULTS = { lift: 6, scrollEscape: 10, scroll: "y", holdMs: 220 };
+var TOUCH_PRESS_IDLE = { phase: "idle" };
+function touchPressReducer(state, event, config = TOUCH_PRESS_DEFAULTS) {
+  switch (event.type) {
+    case "release":
+      return state.phase === "idle" ? state : TOUCH_PRESS_IDLE;
+    case "press":
+      return state.phase === "idle" ? { phase: "pressed", from: { x: event.point.x, y: event.point.y }, since: event.t } : state;
+    case "tick":
+      if (state.phase !== "pressed" || event.t - state.since < config.holdMs) return state;
+      return { phase: "lifted", from: state.from, at: state.from };
+    case "move": {
+      if (state.phase !== "pressed") return state;
+      const dx = event.point.x - state.from.x;
+      const dy = event.point.y - state.from.y;
+      const along = Math.abs(config.scroll === "y" ? dy : dx);
+      const across = Math.abs(config.scroll === "y" ? dx : dy);
+      if (along > across) return along >= config.scrollEscape ? { phase: "scrolled", from: state.from } : state;
+      if (Math.hypot(dx, dy) >= config.lift) return { phase: "lifted", from: state.from, at: { x: event.point.x, y: event.point.y } };
+      return state;
+    }
+    default:
+      return state;
+  }
+}
+function touchPressDeadline(state, config = TOUCH_PRESS_DEFAULTS) {
+  if (state.phase !== "pressed") return null;
+  return { at: state.since + config.holdMs, event: (t) => ({ type: "tick", t }) };
+}
+function createTouchPress(options) {
+  const config = { ...TOUCH_PRESS_DEFAULTS, ...options.config };
+  return createMachine({
+    reducer: (state, event) => touchPressReducer(state, event, config),
+    initial: TOUCH_PRESS_IDLE,
+    clock: options.clock,
+    deadline: (state) => touchPressDeadline(state, config)
+  });
+}
+
+// src/gestures/paged-swipe.ts
+var PAGED_SWIPE_DEFAULTS = {
+  thresholdPx: 24,
+  commitFraction: 0.35,
+  commitVelocity: 0.6,
+  idleMs: 120,
+  lockoutMs: 350,
+  wrap: false,
+  size: 800,
+  modifier: null,
+  along: "x"
+};
+var PAGED_SWIPE_EMPTY_CONTEXT = { hasPrev: false, hasNext: false, size: null, blocked: false };
+var PAGED_SWIPE_IDLE = { phase: "idle", context: PAGED_SWIPE_EMPTY_CONTEXT, progress: 0, target: null, lastWheel: null, claimed: false };
+var idle = (context, lastWheel = null, claimed = false) => ({ phase: "idle", context, progress: 0, target: null, lastWheel, claimed });
+var sideOf = (travel) => travel > 0 ? "next" : travel < 0 ? "prev" : null;
+var hasPage = (c, side, wrap) => wrap ? c.hasPrev || c.hasNext : side === "next" ? c.hasNext : c.hasPrev;
+var withSize = (c, size) => size === void 0 || size === c.size ? c : { ...c, size };
+var sizeOf = (c, size, config) => size ?? c.size ?? config.size;
+function arming(c, main, cross, config, gates) {
+  if (c.blocked || gates.ctrl || gates.canScrollFurther || !gates.modifierHeld) return null;
+  if (Math.abs(main) <= 2 * Math.abs(cross)) return null;
+  const side = sideOf(main);
+  return side && hasPage(c, side, config.wrap) ? side : null;
+}
+function swipeProgress(travel, size, c, wrap) {
+  const p = Math.max(-1, Math.min(1, travel / Math.max(1, size)));
+  if (wrap) return p;
+  if (p < 0 && !c.hasPrev || p > 0 && !c.hasNext) return 0;
+  return p;
+}
+var towards = (delta, dt, side) => {
+  if (dt <= 0 || side === null) return 0;
+  const v = (side === "next" ? delta : -delta) / dt;
+  return v > 0 ? v : 0;
+};
+function track(c, input, origin, travel, t, peak, size, config) {
+  const progress = swipeProgress(travel, size, c, config.wrap);
+  return { phase: "tracking", context: c, input, origin, travel, last: t, peak, progress, target: sideOf(progress) };
+}
+function end(s, t, config) {
+  const commit = s.target !== null && (Math.abs(s.progress) >= config.commitFraction || s.peak >= config.commitVelocity);
+  return { phase: "settling", context: s.context, input: s.input, outcome: commit ? "commit" : "cancel", ended: t, lastWheel: t, progress: s.progress, target: commit ? s.target : null };
+}
+var giveUp = (s, c) => ({
+  phase: "settling",
+  context: c,
+  input: s.input,
+  outcome: "cancel",
+  ended: s.last,
+  lastWheel: s.last,
+  progress: s.progress,
+  target: null
+});
+function pagedSwipeReducer(state, event, config = PAGED_SWIPE_DEFAULTS) {
+  const y = config.along === "y";
+  if (event.type === "context") {
+    return { ...state, context: { ...state.context, hasPrev: event.hasPrev, hasNext: event.hasNext, size: event.size ?? state.context.size } };
+  }
+  if (event.type === "block") {
+    const c = state.context.blocked === event.on ? state.context : { ...state.context, blocked: event.on };
+    if (event.on && state.phase === "armed") return idle(c);
+    if (event.on && state.phase === "tracking") return giveUp(state, c);
+    return c === state.context ? state : { ...state, context: c };
+  }
+  if (event.type === "cancel") {
+    if (state.phase === "armed" || state.phase === "lockout" || state.phase === "settling") return idle(state.context);
+    if (state.phase === "tracking") return giveUp(state, state.context);
+    return state;
+  }
+  switch (state.phase) {
+    case "idle": {
+      if (event.type === "wheel") {
+        if (state.context.blocked) return state;
+        const fresh = state.lastWheel === null || event.t - state.lastWheel >= config.idleMs;
+        if (!fresh && state.claimed) return { ...state, lastWheel: event.t };
+        const main = y ? event.dy : event.dx;
+        const cross = y ? event.dx : event.dy;
+        const side = arming(state.context, main, cross, config, wheelGates(event, config));
+        const c = withSize(state.context, event.size);
+        if (side === null) return idle(c, event.t, true);
+        if (Math.abs(main) >= config.thresholdPx) return track(c, "wheel", { x: 0, y: 0 }, main, event.t, 0, sizeOf(c, event.size, config), config);
+        return { phase: "armed", context: c, input: "wheel", origin: { x: 0, y: 0 }, travel: main, cross, last: event.t, progress: 0, target: null };
+      }
+      if (event.type === "touch-start") {
+        if (state.context.blocked) return state;
+        return { phase: "armed", context: withSize(state.context, event.size), input: "touch", origin: { x: event.x, y: event.y }, travel: 0, cross: 0, last: event.t, progress: 0, target: null };
+      }
+      return state;
+    }
+    case "armed": {
+      if (event.type === "wheel") {
+        if (state.input !== "wheel") return state;
+        const main = y ? event.dy : event.dx;
+        const cross = y ? event.dx : event.dy;
+        if (arming(state.context, main, cross, config, wheelGates(event, config)) === null) return idle(state.context, event.t, true);
+        const c = withSize(state.context, event.size);
+        const travel = state.travel + main;
+        const crossTravel = state.cross + cross;
+        if (Math.abs(crossTravel) > Math.abs(travel) / 2) return idle(c, event.t, true);
+        if (Math.abs(travel) < config.thresholdPx) return { ...state, context: c, travel, cross: crossTravel, last: event.t };
+        return track(c, "wheel", state.origin, travel, event.t, towards(main, event.t - state.last, sideOf(travel)), sizeOf(c, event.size, config), config);
+      }
+      if (event.type === "touch-move") {
+        if (state.input !== "touch") return state;
+        const main = y ? state.origin.y - event.y : state.origin.x - event.x;
+        const cross = y ? event.x - state.origin.x : event.y - state.origin.y;
+        if (Math.hypot(main, cross) < config.thresholdPx) return { ...state, last: event.t };
+        const side = arming(state.context, main, cross, config, { ctrl: false, modifierHeld: true, canScrollFurther: event.canScrollFurther ?? false });
+        if (side === null) return idle(state.context);
+        const c = withSize(state.context, event.size);
+        return track(c, "touch", state.origin, main, event.t, towards(main, event.t - state.last, side), sizeOf(c, event.size, config), config);
+      }
+      if (event.type === "tick") return state.input === "wheel" && event.t - state.last >= config.idleMs ? idle(state.context) : state;
+      if (event.type === "touch-end") return state.input === "touch" ? idle(state.context) : state;
+      if (event.type === "touch-start") return { ...state, context: withSize(state.context, event.size), input: "touch", origin: { x: event.x, y: event.y }, travel: 0, cross: 0, last: event.t };
+      return state;
+    }
+    case "tracking": {
+      if (event.type === "wheel" || event.type === "touch-move") {
+        if (state.input !== (event.type === "wheel" ? "wheel" : "touch")) return state;
+        const travel = event.type === "wheel" ? state.travel + (y ? event.dy : event.dx) : y ? state.origin.y - event.y : state.origin.x - event.x;
+        const side = sideOf(travel);
+        const v = towards(travel - state.travel, event.t - state.last, side);
+        const peak = side === sideOf(state.travel) ? Math.max(state.peak, v) : v;
+        const c = withSize(state.context, event.size);
+        return track(c, state.input, state.origin, travel, event.t, peak, sizeOf(c, event.size, config), config);
+      }
+      if (event.type === "tick") return state.input === "wheel" && event.t - state.last >= config.idleMs ? end(state, event.t, config) : state;
+      if (event.type === "touch-end") return state.input === "touch" ? end(state, event.t, config) : state;
+      return state;
+    }
+    case "settling": {
+      if (event.type === "settled") {
+        if (state.outcome === "commit") return { phase: "lockout", context: state.context, until: state.ended + config.lockoutMs, lastWheel: state.lastWheel, progress: 0, target: null };
+        return idle(state.context, state.lastWheel, false);
+      }
+      if (event.type === "wheel") return { ...state, lastWheel: event.t };
+      return state;
+    }
+    case "lockout": {
+      if (event.type === "wheel") return event.t >= state.until ? idle(state.context, event.t, true) : { ...state, lastWheel: event.t };
+      if (event.type === "tick") {
+        if (event.t < state.until) return state;
+        return event.t - state.lastWheel < config.idleMs ? idle(state.context, state.lastWheel, true) : idle(state.context);
+      }
+      if (event.type === "touch-start") return pagedSwipeReducer(idle(state.context), event, config);
+      return state;
+    }
+    default:
+      return state;
+  }
+}
+function wheelGates(event, config) {
+  return { ctrl: event.modifiers.ctrl, modifierHeld: config.modifier === null || event.modifiers[config.modifier], canScrollFurther: event.canScrollFurther ?? false };
+}
+function pagedSwipeDeadline(state, config = PAGED_SWIPE_DEFAULTS) {
+  const tick = (t) => ({ type: "tick", t });
+  if ((state.phase === "armed" || state.phase === "tracking") && state.input === "wheel") return { at: state.last + config.idleMs, event: tick };
+  if (state.phase === "lockout") return { at: state.until, event: tick };
+  return null;
+}
+function createPagedSwipe(options) {
+  const config = { ...PAGED_SWIPE_DEFAULTS, ...options.config };
+  return createMachine({
+    reducer: (state, event) => pagedSwipeReducer(state, event, config),
+    initial: PAGED_SWIPE_IDLE,
+    clock: options.clock,
+    deadline: (state) => pagedSwipeDeadline(state, config)
+  });
+}
+
 export {
   NO_MODIFIERS,
   toModifiers,
@@ -592,6 +804,18 @@ export {
   DWELL_IDLE,
   dwellReducer,
   dwellDeadline,
-  createDwellMachine
+  createDwellMachine,
+  TOUCH_PRESS_DEFAULTS,
+  TOUCH_PRESS_IDLE,
+  touchPressReducer,
+  touchPressDeadline,
+  createTouchPress,
+  PAGED_SWIPE_DEFAULTS,
+  PAGED_SWIPE_EMPTY_CONTEXT,
+  PAGED_SWIPE_IDLE,
+  swipeProgress,
+  pagedSwipeReducer,
+  pagedSwipeDeadline,
+  createPagedSwipe
 };
-//# sourceMappingURL=chunk-C4M62FUT.js.map
+//# sourceMappingURL=chunk-KVFX5V4Y.js.map