@astryxdesign/core 0.7.6 → 0.7.7-canary.0d1ddcd

package/dist/motion/animator.js

@@ -643,7 +643,7 @@ export function createAnimator(element, options = {}) {
     if (segment == null) {
       return null;
     }
-    if (time >= segment.start + segment.duration) {
+    if (time >= endOf(property, segment)) {
       return null;
     }
     return segment;
@@ -668,26 +668,84 @@ export function createAnimator(element, options = {}) {
   };
 
   /**
-   * The value on screen at `time`. A curve the browser has not started is at
-   * its start up to now; a later time reads the curve from its provisional
-   * start, the model's best guess until the browser's start moves it (a
-   * companion that samples a curve ahead follows its shape).
+   * A held curve's start once a frame dated its call, as the browser's start
+   * moves it: by that frame's lead over the call's own time.
+   */
+  const datedFromLatest = (segment, latest) => latest == null || segment.group == null ? null : {
+    latest,
+    start: segment.start + latest - segment.group.provisional
+  };
+
+  /**
+   * When a waiting curve's call had its first frame, which put the curve on
+   * screen. Undefined for a curve that does not wait, or whose call has had
+   * no first frame.
+   */
+  const shownSince = (property, segment) => segment.group?.resolved === false ? segment.group.latest?.get(CHANNEL_OF[property]) : undefined;
+
+  /** A curve's end, dated from its call's first frame while it waits. */
+  const endOf = (property, segment) => (datedFromLatest(segment, shownSince(property, segment))?.start ?? segment.start) + segment.duration;
+
+  /**
+   * Takes a curve on screen out of the call that still waits for the
+   * browser's start. The curve keeps its course, dated from the call's first
+   * frame. A call that has no channel left starts at that frame.
+   */
+  const leaveWaitingCall = (segment, channel, latest) => {
+    const group = segment.group;
+    if (group == null) {
+      return;
+    }
+    const index = group.segments.indexOf(segment);
+    if (index >= 0) {
+      group.segments.splice(index, 1);
+    }
+    segment.start += latest - group.provisional;
+    segment.group = undefined;
+    if (!CHANNELS[channel].some(p => segments.get(p)?.group === group)) {
+      group.latest?.delete(channel);
+      group.channels.delete(channel);
+    }
+    if (group.channels.size === 0 && group.segments.length === 0) {
+      resolveGroup(group, latest);
+    }
+  };
+
+  /**
+   * The value on screen at `time`. Until the browser reports its start, a
+   * held curve shows its first value. A frame that ran without that start
+   * dates the curve. Without that frame, a later time reads from the
+   * provisional start, so a companion that samples ahead follows the curve's
+   * shape.
    */
   const valueAt = (property, time) => {
     const segment = segments.get(property);
-    if (segment != null && isHeld(segment) && time <= now()) {
+    if (segment != null && isHeld(segment)) {
+      // The compositor starts the call near its first frame. The curve is
+      // dated as the browser's start would date it. A curve that joined by an
+      // older clock keeps its lead over the call's own time.
+      const latest = segment.group?.latest?.get(CHANNEL_OF[property]);
+      const dated = datedFromLatest(segment, latest);
+      if (dated != null) {
+        const elapsed = Math.max(time, dated.latest) - dated.start;
+        return elapsed >= segment.duration ? segment.target : segment.at(elapsed);
+      }
       // Nothing has moved on screen until the browser starts the call.
-      return segment.at(0);
+      if (time <= now()) {
+        return segment.at(0);
+      }
     }
     return curveAt(property, time);
   };
   const velocityAt = (property, time) => {
     const held = segments.get(property);
     if (held != null && isHeld(held)) {
-      // Still at its start on screen, but moving in the model: a retarget
-      // carries the velocity the curve has reached by now, so a flick whose
-      // moves all land before the browser starts any keeps its speed.
-      return held.speed(Math.max(0, time - held.start));
+      // Still at its start on screen, but moving in the model. A retarget
+      // carries the velocity the curve has reached by now. So a flick whose
+      // moves all land before the browser starts any keeps its speed. Past
+      // its first frame, it reads from that frame, as its value does.
+      const dated = datedFromLatest(held, held.group?.latest?.get(CHANNEL_OF[property]));
+      return held.speed(Math.max(0, dated != null && time > dated.latest ? time - dated.start : time - held.start));
     }
     const segment = segmentAt(property, time);
     if (segment == null || time < segment.start) {
@@ -854,12 +912,49 @@ export function createAnimator(element, options = {}) {
     // Settled curves become resting values.
     for (const property of properties) {
       const segment = segments.get(property);
-      if (segment != null && time >= segment.start + segment.duration) {
+      if (segment != null && time >= endOf(property, segment)) {
         resting[property] = segment.target;
         segments.delete(property);
       }
     }
     const moving = properties.filter(p => segments.has(p));
+    if (callGroup == null) {
+      // A call that starts now rebuilds a channel the compositor has moving
+      // since a first frame without a known start. The channel carries on
+      // from that frame, with a start of its own, instead of starting its
+      // curve again.
+      for (const property of moving) {
+        const segment = segments.get(property);
+        const latest = shownSince(property, segment);
+        if (latest != null) {
+          leaveWaitingCall(segment, channel, latest);
+        }
+      }
+    }
+    // An explicit call can rebuild a channel while one of its curves still
+    // waits for the browser's start. The animation then joins the current
+    // call, or else that waiting call, with no start of its own.
+    const waiting = callGroup ?? moving.map(p => segments.get(p).group).find(group => group != null && !group.resolved) ?? null;
+    const rebuiltAfterFirstFrame = waiting?.framed === true;
+    // The new animation starts at the frame that commits it, from its first
+    // keyframe. That holds for a waiting call it joins after that call's
+    // first frame, and for every waiting call it takes a curve from. So this
+    // channel's reads below, and until that frame, take that first value.
+    const restarted = new Set();
+    if (rebuiltAfterFirstFrame) {
+      restarted.add(waiting);
+    }
+    if (callGroup != null) {
+      for (const property of moving) {
+        const group = segments.get(property).group;
+        if (group != null && group !== callGroup && !group.resolved) {
+          restarted.add(group);
+        }
+      }
+    }
+    for (const group of restarted) {
+      group.latest?.delete(channel);
+    }
     if (channel === 'translate') {
       // The animation built below starts from the value at `time` (its first
       // keyframe); a rebase or a retarget builds a new one, so a new start.
@@ -887,10 +982,6 @@ export function createAnimator(element, options = {}) {
       previous?.cancel();
       return;
     }
-    // A channel rebuilt by an explicit call (set, rebase, a retarget of
-    // another axis) while one of its curves still waits for the browser's
-    // start keeps that start: no explicit start for this animation.
-    const waiting = callGroup ?? moving.map(p => segments.get(p).group).find(group => group != null && !group.resolved) ?? null;
     // The keyframes start where the animation will: at the waiting call's
     // own time, which its start moves to the browser's (resolveGroup), so a
     // write later in the task keeps the screen on the model's clock.
@@ -996,6 +1087,15 @@ export function createAnimator(element, options = {}) {
       waiting.channels.add(channel);
       // A cancel before the first frame rejects its ready promise.
       animation.ready?.catch(() => {});
+      if (rebuiltAfterFirstFrame) {
+        // The frame that commits it dates this channel's start again. The
+        // call's other channels keep their own.
+        requestFrame?.(() => {
+          if (!waiting.resolved && running.get(channel) === animation && animation.startTime == null && animation.playState === 'running') {
+            (waiting.latest ??= new Map()).set(channel, now());
+          }
+        });
+      }
     } else {
       // One clock: the keyframes were sampled from `time`.
       animation.startTime = time;
@@ -1445,7 +1545,9 @@ export function createAnimator(element, options = {}) {
     for (const channel of start === 'commit' ? [] : channels) {
       for (const property of CHANNELS[channel]) {
         const segment = segments.get(property);
-        if (segment != null && time < segment.start + segment.duration && (segment.group == null || segment.group.resolved)) {
+        // A call's first frame puts its channels on screen, even before the
+        // browser reports the start. So such a channel is not at rest either.
+        if (segment != null && time < endOf(property, segment) && (segment.group == null || segment.group.resolved || shownSince(property, segment) != null)) {
           return null;
         }
       }
@@ -1614,6 +1716,17 @@ export function createAnimator(element, options = {}) {
       if (!group.resolved && group.madeInFrame !== true && now() - (group.task?.first ?? group.provisional) <= LATE_START_MS && group.animations.some(animation => animation.startTime == null && animation.playState === 'running')) {
         resolveGroup(group, now());
       }
+      // The browser's start is still unread. The compositor starts the call
+      // near this frame, so each moving channel's reads take the curve from
+      // now until the browser tells its start.
+      if (!group.resolved) {
+        for (const channel of group.channels) {
+          const animation = running.get(channel);
+          if (animation != null && group.animations.includes(animation) && animation.startTime == null && animation.playState === 'running') {
+            (group.latest ??= new Map()).set(channel, now());
+          }
+        }
+      }
     });
     ready.then(() => syncGroup(group), () => settleCancelled(group));
   };
@@ -2822,8 +2935,10 @@ export function createAnimator(element, options = {}) {
         }
         owners.add(segment.owner);
         // A curve still waiting for the browser's start stays in its call:
-        // it starts with that call's commit.
-        const group = segment.group != null && !segment.group.resolved ? segment.group : undefined;
+        // it starts with that call's commit. A curve whose call had its first
+        // frame is on screen already, so it leaves the call (leaveWaitingCall).
+        const latest = shownSince(property, segment);
+        const group = latest == null && segment.group != null && !segment.group.resolved ? segment.group : undefined;
         const replace = next => {
           if (group != null) {
             const index = group.segments.indexOf(segment);
@@ -2838,6 +2953,9 @@ export function createAnimator(element, options = {}) {
         if (segment.spring != null) {
           const from = valueAt(property, time) + delta;
           const velocity = velocityAt(property, time);
+          if (latest != null) {
+            leaveWaitingCall(segment, CHANNEL_OF[property], latest);
+          }
           const curve = solveSpring(toSpring(segment.spring), {
             from,
             to: segment.target,
@@ -2857,6 +2975,9 @@ export function createAnimator(element, options = {}) {
             spring: segment.spring
           });
         } else {
+          if (latest != null) {
+            leaveWaitingCall(segment, CHANNEL_OF[property], latest);
+          }
           replace({
             ...segment,
             target: segment.target + delta,

package/dist/motion/paging.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @file paging.ts
+ * @input A release velocity, a settle's start, end and velocity, and the UIKit
+ *   paging constants
+ * @output Exports `pagingSettleVelocity`, `solvePaging` (UIKit's paging settle
+ *   as a curve the animator plays) and `solveAnimatedPageScroll`
+ * @position Pure math, with no DOM and no React
+ *
+ * SYNC: When modified, update:
+ * - /packages/core/src/motion/paging.test.ts
+ * - /packages/core/src/motion/README.md
+ */
+import type { MotionCurve } from './animator.js';
+/**
+ * The velocity a paging settle starts at. It is the release velocity that every
+ * gesture reads, zeroed below `velocityFloor`. The page choice reads the
+ * release velocity itself.
+ */
+export declare function pagingSettleVelocity(velocity: number): number;
+/** A paging settle: the curve and where it ends. */
+export interface PagingCurve extends MotionCurve {
+    readonly from: number;
+    readonly to: number;
+    /** Integration steps the settle took. */
+    readonly steps: number;
+}
+/**
+ * UIKit's paging settle from `from` (px), moving at `velocity` (px/s), onto
+ * `to`. It steps `paging.integrator` `stepsPerSecond` times a second and ends
+ * exactly on `to`. The same motion returns an overscrolled pager to its first
+ * or last page.
+ *
+ * Positions are content offsets along the paging axis, 0 at page 0 and growing
+ * toward later pages. Velocities are px/s of that offset.
+ *
+ * No closed form reproduces the per-frame stepping, so the settle integrates
+ * once into a table, and the curve reads the table. A release needs at most
+ * about 400 steps, well under a millisecond of work.
+ *
+ * The release velocity enters in px per millisecond per step, as UIKit hands it
+ * to the integrator. At 960 steps a second, the content starts at 96 % of the
+ * finger's speed, as in UIKit.
+ */
+export declare function solvePaging({ from, velocity, to, }: {
+    from: number;
+    velocity: number;
+    to: number;
+}): PagingCurve;
+/**
+ * `setContentOffset(_:animated:)`: `paging.animatedScroll.duration` on a
+ * sinusoidal ease-in-out, whatever the distance. UIKit starts it from the
+ * current offset and drops any velocity, as here.
+ */
+export declare function solveAnimatedPageScroll({ from, to, }: {
+    from: number;
+    to: number;
+}): MotionCurve;
+//# sourceMappingURL=paging.d.ts.map

package/dist/motion/paging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paging.d.ts","sourceRoot":"","sources":["../../src/motion/paging.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,YAAY,CAAC;AAG5C;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,oDAAoD;AACpD,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,yCAAyC;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,EAC1B,IAAI,EACJ,QAAQ,EACR,EAAE,GACH,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,GAAG,WAAW,CA6Cd;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,IAAI,EACJ,EAAE,GACH,EAAE;IACD,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,GAAG,WAAW,CAmBd"}

package/dist/motion/paging.js

@@ -0,0 +1,128 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file paging.ts
+ * @input A release velocity, a settle's start, end and velocity, and the UIKit
+ *   paging constants
+ * @output Exports `pagingSettleVelocity`, `solvePaging` (UIKit's paging settle
+ *   as a curve the animator plays) and `solveAnimatedPageScroll`
+ * @position Pure math, with no DOM and no React
+ *
+ * SYNC: When modified, update:
+ * - /packages/core/src/motion/paging.test.ts
+ * - /packages/core/src/motion/README.md
+ */
+
+import { paging } from "./uikit/paging.js";
+
+/**
+ * The velocity a paging settle starts at. It is the release velocity that every
+ * gesture reads, zeroed below `velocityFloor`. The page choice reads the
+ * release velocity itself.
+ */
+export function pagingSettleVelocity(velocity) {
+  return Math.abs(velocity) < paging.release.velocityFloor ? 0 : velocity;
+}
+
+/** A paging settle: the curve and where it ends. */
+
+/**
+ * UIKit's paging settle from `from` (px), moving at `velocity` (px/s), onto
+ * `to`. It steps `paging.integrator` `stepsPerSecond` times a second and ends
+ * exactly on `to`. The same motion returns an overscrolled pager to its first
+ * or last page.
+ *
+ * Positions are content offsets along the paging axis, 0 at page 0 and growing
+ * toward later pages. Velocities are px/s of that offset.
+ *
+ * No closed form reproduces the per-frame stepping, so the settle integrates
+ * once into a table, and the curve reads the table. A release needs at most
+ * about 400 steps, well under a millisecond of work.
+ *
+ * The release velocity enters in px per millisecond per step, as UIKit hands it
+ * to the integrator. At 960 steps a second, the content starts at 96 % of the
+ * finger's speed, as in UIKit.
+ */
+export function solvePaging({
+  from,
+  velocity,
+  to
+}) {
+  const {
+    springPull,
+    friction,
+    stepsPerSecond,
+    restDistance,
+    restSpeed
+  } = paging.integrator;
+  const xs = [from];
+  const vs = [velocity / 1000];
+  let x = from;
+  let v = velocity / 1000;
+  // ~10 s of steps: far beyond any settle (≈ 0.35 s from rest).
+  const maxSteps = stepsPerSecond * 10;
+  let steps = 0;
+  while (steps < maxSteps) {
+    if (Math.abs(to - x) < restDistance && Math.abs(v) < restSpeed) {
+      break;
+    }
+    v = (v + (to - x) * springPull) * friction;
+    x += v;
+    steps += 1;
+    xs.push(x);
+    vs.push(v);
+  }
+  xs[xs.length - 1] = to;
+  vs[vs.length - 1] = 0;
+  const duration = steps / stepsPerSecond;
+  const last = xs.length - 1;
+  const read = (table, t) => {
+    if (!(t > 0)) {
+      return table[0];
+    }
+    const s = t * stepsPerSecond;
+    if (s >= last) {
+      return table[last];
+    }
+    const i = Math.floor(s);
+    const f = s - i;
+    return table[i] + (table[i + 1] - table[i]) * f;
+  };
+  return {
+    from,
+    to,
+    steps,
+    duration,
+    at: t => read(xs, t),
+    // px per step × steps per second
+    velocity: t => read(vs, t) * stepsPerSecond
+  };
+}
+
+/**
+ * `setContentOffset(_:animated:)`: `paging.animatedScroll.duration` on a
+ * sinusoidal ease-in-out, whatever the distance. UIKit starts it from the
+ * current offset and drops any velocity, as here.
+ */
+export function solveAnimatedPageScroll({
+  from,
+  to
+}) {
+  const {
+    duration
+  } = paging.animatedScroll;
+  const distance = to - from;
+  return {
+    duration,
+    at: t => {
+      const u = Math.min(1, Math.max(0, t / duration));
+      return from + distance * (1 - Math.cos(Math.PI * u)) / 2;
+    },
+    velocity: t => {
+      if (t <= 0 || t >= duration) {
+        return 0;
+      }
+      return distance * Math.PI / (2 * duration) * Math.sin(Math.PI * t / duration);
+    }
+  };
+}

package/dist/motion/uikit/index.d.ts

@@ -2,7 +2,7 @@
  * @file index.ts
  * @input The domain files of the UIKit constants table
  * @output Re-exports `springs` and one constant per spring (`SHEET_PRESENT_SPRING`,
- *   …), `scroll`, `timing`, `navigation` and the
+ *   …), `scroll`, `timing`, `navigation`, the `slider` domain and the
  *   gesture thresholds (one `UIKIT_*` group per recognizer, their union
  *   `UIKIT_GESTURES`, and the haptic tables)
  * @position Entry of the UIKit constants table (motion/uikit). Internal to
@@ -19,6 +19,7 @@
 export { HAPTIC_FEEDBACK_KINDS, HAPTIC_VIBRATION_PATTERNS, UIKIT_CLICK, UIKIT_CONTROL, UIKIT_GESTURES, UIKIT_LONG_PRESS, UIKIT_PAN, UIKIT_PINCH, UIKIT_PRESS, UIKIT_ROTATION, UIKIT_SCREEN_EDGE_PAN, UIKIT_SWIPE, UIKIT_TAP, UIKIT_VELOCITY, type GestureConstant, type GestureConstantUnit, type HapticFeedbackKind, } from './gestures.js';
 export { navigation, registerNavigationTable } from './navigation.js';
 export { registerScrollTable, scroll } from './scroll.js';
+export { slider } from './slider.js';
 export { ACTION_SHEET_DISMISS_SPRING, ACTION_SHEET_PRESENT_SPRING, ALERT_DISMISS_SPRING, ALERT_PRESENT_SPRING, BANNER_SPRING, CONTEXT_MENU_DISMISS_SPRING, CONTEXT_MENU_LIFT_SPRING, CONTEXT_MENU_MORPH_SPRING, DIRECT_CHANGE_SPRING, EMPHASIS_SPRING, FINGER_TRACKING_SPRING, KEYBOARD_SPRING, MENU_CLOSE_SPRING, MENU_OPEN_SPRING, MENU_REDUCED_MOTION_SPRING, NAVIGATION_BAR_ELEMENTS_SPRING, NAVIGATION_INTERACTIVE_POP_FINISH_SPRING, NAVIGATION_POP_SPRING, NAVIGATION_PUSH_SPRING, QUICK_CHANGE_SPRING, SEGMENTED_THUMB_SPRING, SETTLE_SPRING, SHEET_DETENT_SPRING, SHEET_DISMISS_SPRING, SHEET_DISMISS_SWIPE_SPRING, SHEET_PRESENT_SPRING, SHEET_RELEASE_FAST_SPRING, STATE_CHANGE_SPRING, SUB_MENU_BACK_SPRING, SUB_MENU_OPEN_SPRING, SWITCH_THUMB_MOVE_SPRING, SWITCH_THUMB_STRETCH_SPRING, TIMED_CHANGE_SPRING, VIEW_CHANGE_SPRING, registerSpringsTable, springs, } from './springs.js';
 export { registerTimingTable, timing } from './timing.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/motion/uikit/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,WAAW,EACX,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,SAAS,EACT,WAAW,EACX,WAAW,EACX,cAAc,EACd,qBAAqB,EACrB,WAAW,EACX,SAAS,EACT,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,GACxB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAC,UAAU,EAAE,uBAAuB,EAAC,MAAM,cAAc,CAAC;AACjE,OAAO,EAAC,mBAAmB,EAAE,MAAM,EAAC,MAAM,UAAU,CAAC;AACrD,OAAO,EACL,2BAA2B,EAC3B,2BAA2B,EAC3B,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACb,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,eAAe,EACf,sBAAsB,EACtB,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,0BAA0B,EAC1B,8BAA8B,EAC9B,wCAAwC,EACxC,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACxB,2BAA2B,EAC3B,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,OAAO,GACR,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,mBAAmB,EAAE,MAAM,EAAC,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,WAAW,EACX,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,SAAS,EACT,WAAW,EACX,WAAW,EACX,cAAc,EACd,qBAAqB,EACrB,WAAW,EACX,SAAS,EACT,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,GACxB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAC,UAAU,EAAE,uBAAuB,EAAC,MAAM,cAAc,CAAC;AACjE,OAAO,EAAC,mBAAmB,EAAE,MAAM,EAAC,MAAM,UAAU,CAAC;AACrD,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAChC,OAAO,EACL,2BAA2B,EAC3B,2BAA2B,EAC3B,oBAAoB,EACpB,oBAAoB,EACpB,aAAa,EACb,2BAA2B,EAC3B,wBAAwB,EACxB,yBAAyB,EACzB,oBAAoB,EACpB,eAAe,EACf,sBAAsB,EACtB,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,0BAA0B,EAC1B,8BAA8B,EAC9B,wCAAwC,EACxC,qBAAqB,EACrB,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACxB,2BAA2B,EAC3B,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,OAAO,GACR,MAAM,WAAW,CAAC;AACnB,OAAO,EAAC,mBAAmB,EAAE,MAAM,EAAC,MAAM,UAAU,CAAC"}

package/dist/motion/uikit/index.js

@@ -4,7 +4,7 @@
  * @file index.ts
  * @input The domain files of the UIKit constants table
  * @output Re-exports `springs` and one constant per spring (`SHEET_PRESENT_SPRING`,
- *   …), `scroll`, `timing`, `navigation` and the
+ *   …), `scroll`, `timing`, `navigation`, the `slider` domain and the
  *   gesture thresholds (one `UIKIT_*` group per recognizer, their union
  *   `UIKIT_GESTURES`, and the haptic tables)
  * @position Entry of the UIKit constants table (motion/uikit). Internal to
@@ -22,5 +22,6 @@
 export { HAPTIC_FEEDBACK_KINDS, HAPTIC_VIBRATION_PATTERNS, UIKIT_CLICK, UIKIT_CONTROL, UIKIT_GESTURES, UIKIT_LONG_PRESS, UIKIT_PAN, UIKIT_PINCH, UIKIT_PRESS, UIKIT_ROTATION, UIKIT_SCREEN_EDGE_PAN, UIKIT_SWIPE, UIKIT_TAP, UIKIT_VELOCITY } from "./gestures.js";
 export { navigation, registerNavigationTable } from "./navigation.js";
 export { registerScrollTable, scroll } from "./scroll.js";
+export { slider } from "./slider.js";
 export { ACTION_SHEET_DISMISS_SPRING, ACTION_SHEET_PRESENT_SPRING, ALERT_DISMISS_SPRING, ALERT_PRESENT_SPRING, BANNER_SPRING, CONTEXT_MENU_DISMISS_SPRING, CONTEXT_MENU_LIFT_SPRING, CONTEXT_MENU_MORPH_SPRING, DIRECT_CHANGE_SPRING, EMPHASIS_SPRING, FINGER_TRACKING_SPRING, KEYBOARD_SPRING, MENU_CLOSE_SPRING, MENU_OPEN_SPRING, MENU_REDUCED_MOTION_SPRING, NAVIGATION_BAR_ELEMENTS_SPRING, NAVIGATION_INTERACTIVE_POP_FINISH_SPRING, NAVIGATION_POP_SPRING, NAVIGATION_PUSH_SPRING, QUICK_CHANGE_SPRING, SEGMENTED_THUMB_SPRING, SETTLE_SPRING, SHEET_DETENT_SPRING, SHEET_DISMISS_SPRING, SHEET_DISMISS_SWIPE_SPRING, SHEET_PRESENT_SPRING, SHEET_RELEASE_FAST_SPRING, STATE_CHANGE_SPRING, SUB_MENU_BACK_SPRING, SUB_MENU_OPEN_SPRING, SWITCH_THUMB_MOVE_SPRING, SWITCH_THUMB_STRETCH_SPRING, TIMED_CHANGE_SPRING, VIEW_CHANGE_SPRING, registerSpringsTable, springs } from "./springs.js";
 export { registerTimingTable, timing } from "./timing.js";

package/dist/motion/uikit/paging.d.ts

@@ -0,0 +1,160 @@
+/**
+ * @file paging.ts
+ * @input Nothing; data only
+ * @output Exports `paging`, the measured constants of a paging UIScrollView
+ * @position The paging domain of the UIKit constants table (motion/uikit). Only
+ *   core reads it, so the `uikit` namespace does not re-export it
+ *
+ * SYNC: When modified, update:
+ * - /packages/core/src/motion/MEASUREMENTS.md (measurement tasks)
+ * - /packages/core/src/motion/paging.ts and paging.test.ts
+ */
+export declare const paging: {
+    /**
+     * After the lift, one model moves the content: the settle onto the chosen
+     * page and the return from an overscroll. Each display frame runs floor(frame
+     * interval in ms) steps of 1 ms:
+     *
+     *   v = (v + (target − x) · springPull) · friction;  x += v  (v: pt per step)
+     *
+     * A 60 Hz frame runs 16 steps, not 16.67. With these values, the model
+     * replays eight captured releases to 0.20 pt RMS. It replays five overscroll
+     * returns to 0.16–0.33 pt RMS (402 pt pages, iOS 26.2, 3× screen). Without
+     * the floor, the error is 1.0 pt RMS, with a systematic shape.
+     */
+    readonly integrator: {
+        /**
+         * Velocity added per 1 ms step, per point of distance to the target page
+         * (pt per step²).
+         * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026.
+         *   `_pagingSpringPull` reads the same on a 402 pt paging UIScrollView and
+         *   on UIPageViewController's scroll view. It replays 8 captured settles to
+         *   0.20 pt RMS.
+         */
+        readonly springPull: 0.000284858;
+        /**
+         * Velocity kept per step after the pull (`_pagingFriction`, equal to
+         * `_defaultPagingFriction`).
+         * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. Both read
+         *   the same on the two scroll views of `springPull`, and they replay with
+         *   it.
+         */
+        readonly friction: 0.970815;
+        /**
+         * Integration steps per second: floor(16.67 ms) = 16 steps per 60 Hz frame,
+         * and floor(8.33 ms) = 8 per 120 Hz frame, so 960.
+         * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. In a 60 fps
+         *   log of 8 releases at rest, floored stepping fits to 0.20 pt RMS.
+         *   Unfloored stepping fits to 1.0 pt RMS.
+         */
+        readonly stepsPerSecond: 960;
+        /**
+         * A settle ends exactly on the page once the remaining distance is below
+         * this many points and the step velocity is below `restSpeed`.
+         * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. The
+         *   captured settles jump the last 0.33 pt onto the page about 0.35 s after
+         *   a release at rest.
+         */
+        readonly restDistance: 0.5;
+        /**
+         * Step velocity (pt per step) below which a settle may end.
+         * @source GUESS — the captured settles end at about 0.04 pt per step;
+         *   the threshold is not observable more finely at 60 fps
+         * @measure M-PG12
+         */
+        readonly restSpeed: 0.05;
+    };
+    readonly release: {
+        /**
+         * Released slower than `advanceSpeed`, the scroll view settles on the page
+         * nearest the content position: past half a page, the next one.
+         * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. In releases
+         *   at rest from page 1, content at 48.5 % of the page stays, and 57.5 %
+         *   goes to the next page. On a second 402 pt pager, 45 % stays and 55 %
+         *   advances.
+         */
+        readonly commitFraction: 0.5;
+        /**
+         * Released at least this fast (pt/s), the scroll view pages in the
+         * direction of the velocity, from any content position. A flick from 6 % of
+         * the page advances. The speed is UIPanGestureRecognizer's velocity at the
+         * last movement, and it never decays. The scroll view's
+         * `_horizontalVelocity` equals it at every sample. A drag held still for
+         * 397 ms before the lift still pages at the speed it had.
+         * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. Steady
+         *   releases at 10, 25 and 40 % of a 402 pt page: 292.7, 295.3 and 298.6
+         *   pt/s stay; 310.7, 316.4 and 329.9 advance. The result is the same at
+         *   every position: a threshold, not a projection.
+         */
+        readonly advanceSpeed: 300;
+        /**
+         * A settle velocity slower than this (pt/s) is zeroed, so the settle starts
+         * at rest. It is paging's own tuning on the one release velocity that every
+         * gesture reads.
+         * @source GUESS — the middle of the measured (200, 249] bracket. In the
+         *   UIKit lab (iOS 26.2 simulator, Oct 23 2026),
+         *   `scrollViewWillEndDragging` reads 0 for steady releases at 175 and 200
+         *   pt/s. It reads 0.249 pt/ms for a release at 249 pt/s.
+         * @measure M-PG13
+         */
+        readonly velocityFloor: 225;
+        /**
+         * Pages a release may travel from the page the drag started on, at any
+         * speed and drag distance.
+         * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. A drag of
+         *   1.5 pages from page 1 lands on page 2 at release speeds of 0, 600 and
+         *   3000 pt/s.
+         */
+        readonly maxPagesFromStart: 1;
+    };
+    /**
+     * A finger that lands on a settling pager does not stop it at once. The
+     * settle runs on for about this long, then the content holds under the
+     * finger. Lifted without a move, the content settles again on the nearest
+     * page.
+     * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. After
+     *   touch-downs 60 and 160 ms into a settle, the content moved on for 82.6
+     *   and 87.5 ms (5 frames), then held.
+     */
+    readonly catchStopMs: 85;
+    /**
+     * A horizontal pager's pan begins only for a drag within atan(1 ÷ this) of
+     * horizontal (26.6° for 2). A steeper drag goes to the vertical scroll around
+     * it. Between 26.6° and 45°, neither moves.
+     * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. A scroll
+     *   view's directional lock holds the major axis up to 25° and frees it from
+     *   30°. An inline calendar pager in a sheet pages at 20° from horizontal. At
+     *   35° and 45°, it moves neither itself nor the sheet, and it leaves 55° to
+     *   the sheet.
+     */
+    readonly panAxisRatio: 2;
+    readonly animatedScroll: {
+        /**
+         * `setContentOffset(_:animated:)` duration. It is the same for one page and
+         * for five, as for a page control's tap.
+         * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026.
+         *   `_contentOffsetAnimationDuration` reads 0.3, and five animated moves of
+         *   1 to 5 pages each last 0.30 s.
+         */
+        readonly duration: 0.3;
+        /**
+         * Its curve is a sinusoidal ease-in-out: x = from + (to − from) · (1 − cos
+         * πu) ÷ 2, for u = t ÷ duration.
+         * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. The five
+         *   moves fit the sinusoid to 0.14–0.51 pt RMS, and a 2010 pt move fits to
+         *   0.20 pt. The curve easeInEaseOut (0.42, 0, 0.58, 1) misses by 7.7 pt.
+         */
+        readonly curve: "sineInOut";
+    };
+    /**
+     * Past the first or last page, the content follows the finger through the
+     * scroll view's rubber band (scroll.rubberBand.coefficient), with d = the
+     * page width. It returns on the integrator above.
+     * @source measured: UIKit lab, iOS 26.2 simulator, Oct 23 2026. A pan of 90
+     *   pt past page 0 shows 42.7–45 pt, and 290 pt shows 114.3 pt. The formula
+     *   gives 44.1 and 114.2, with c 0.55 and d 402. The return replays on the
+     *   integrator to 0.16–0.33 pt RMS.
+     */
+    readonly rubberBandDimension: "pageWidth";
+};
+//# sourceMappingURL=paging.d.ts.map

package/dist/motion/uikit/paging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paging.d.ts","sourceRoot":"","sources":["../../../src/motion/uikit/paging.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,MAAM;IACjB;;;;;;;;;;;OAWG;;QAED;;;;;;;WAOG;;QAEH;;;;;;WAMG;;QAEH;;;;;;WAMG;;QAEH;;;;;;WAMG;;QAEH;;;;;WAKG;;;;QAIH;;;;;;;WAOG;;QAEH;;;;;;;;;;;WAWG;;QAEH;;;;;;;;;WASG;;QAEH;;;;;;WAMG;;;IAGL;;;;;;;;OAQG;;IAEH;;;;;;;;;OASG;;;QAGD;;;;;;WAMG;;QAEH;;;;;;WAMG;;;IAGL;;;;;;;;OAQG;;CAEK,CAAC"}