@astryxdesign/core 0.7.7 → 0.7.8-canary.0588a13

package/src/motion/MEASUREMENTS.md

@@ -268,6 +268,16 @@ match the probe.
 | M-SH21  | SheetProbe on iPad, iOS 27 `preferredPlacement` each case, RTL                                                         | present                                                                                                                             | placement geometry and motion                                                                                                                           | B, C    |
 | M-SH22  | SheetProbe iOS 26 `preferredTransition = .zoom` from a bar button                                                      | present, dismiss                                                                                                                    | morph geometry per frame                                                                                                                                | A, C    |
 
+## Date picker (UIDatePicker)
+
+Rules the DateInput, DateTimeInput and TimeInput touch sheets follow, in their
+own table (`uikit/datePicker.ts`). The wheels' physics are UIPickerView's: the
+table only names them, and their values belong to the wheel's own table.
+
+Done (UIKit lab, iOS 26.2 simulator, Oct 23 2026; in the date picker's table):
+the month/year wheels changing the date, the AM/PM column following the hour,
+the turn back onto a bound, and the day clamped to the month.
+
 ## Context menu (UIContextMenuInteraction)
 
 Values the context menu reads from its own table, which lands with the
@@ -286,3 +296,21 @@ fades in, with Prefer Cross-Fade Transitions on or off.
 | M-CM4 | Reduce Motion press feedback    | Probe app with Reduce Motion on: long press, then dismiss                                                                   | press feedback, lift and dismiss animations under Reduce Motion                                                                                                                           | A, B   |
 | M-CM5 | Commit haptic stand-in          | An Android device: `navigator.vibrate` patterns against the platform's HapticFeedbackConstants for the context-click moment | the pattern that matches; not a UIKit parity value (as M-G18)                                                                                                                             | H      |
 | M-CM6 | Press thresholds                | Probe app: repeated long presses at random vsync phases                                                                     | from touch receipt and from the HID timestamp, the tick before and the tick at the press observer's began and at the click commit; the intersection pins the 150 ms and 400 ms thresholds | C      |
+
+## Picker (UIPickerView)
+
+Values the Wheel reads from its own table (`uikit/picker.ts`).
+
+The recordings are of a 402 × 216 pt UIPickerView with two columns of 24 and
+60 rows. It runs in an instrumented host app on the iOS 26.2 simulator
+(iPhone 17 Pro), driven by real HID touches. They hold per-frame offsets, the
+table views' and cells' layers, the delegate calls and the haptics.
+
+Done (UIKit lab, iOS 26.2 simulator, Oct 23 2026; in the picker's table): the
+row pitch, the picker's height, the rubber band's dimension, the coast's stop
+speed, the velocity floor, the snap at rest, the tap spin and the selection
+tick. Measured and kept by the gesture system instead: the
+scroll view coasts with 0.25 × the pan's velocity plus 0.75 × its value one
+event earlier (four HID releases; `velocity.scrollReleaseWeight`, which a
+pan's `scrollVelocity()` reads). On UIKit, Reduce Motion with Prefer Cross-Fade changes
+nothing on a picker; the Wheel follows design:reduced-motion instead.

package/src/motion/README.md

@@ -19,11 +19,15 @@ roles through `resolveMotion`.
 | `uikit/scroll.ts`                                | UIScrollView: deceleration rates, rubber band, bounce-back spring, `delaysContentTouches`, scroll to top.                                                            |
 | `uikit/timing.ts`                                | Non-spring clocks and curves: press highlight, Core Animation's named curves, keyboard, Reduced Motion cross-fade.                                                   |
 | `uikit/paging.ts`                                | A paging UIScrollView: the integrator that settles a release on its page, the page rule, the catch, `setContentOffset(animated:)`.                                   |
+| `uikit/alert.ts`                                 | UIAlertController: how a finger is tracked across the actions (highlight onset and bounds).                                                                          |
 | `uikit/navigation.ts`                            | UINavigationController: push velocity, parallax, dimming, transition clock, interactive pop finish rule.                                                             |
 | `uikit/progressBar.ts`                           | UIProgressView's fill: the whole-track duration and curve, its minimum length and empty alpha; the reduced-motion pulse (three roles).                               |
 | `uikit/gestures.ts`                              | Gesture recognizer thresholds, the velocity filter and haptic stand-ins, as `{value, unit}` entries (sources in JSDoc).                                              |
+| `uikit/picker.ts`                                | UIPickerView: row pitch, height and rubber band, velocity floor, the coast's stop speed, snap at rest, tap spin, tick.                                               |
 | `uikit/segmented.ts`                             | UISegmentedControl: the selection indicator's spring; under Reduce Motion the animator's cross-fade replaces it.                                                     |
 | `uikit/switch.ts`                                | UISwitch on iOS 26.2: geometry, the lift, settle, travel and tracking springs, the flip distance, the track colour.                                                  |
+| `uikit/datePicker.ts`                            | UIDatePicker: the rules it adds to its wheels.                                                                                                                       |
+| `android/keyboard.ts`                            | Android's software keyboard (Chrome with Gboard): its slides' durations and curves (no theme's) and when they start against Chrome's report and a blur.              |
 | `roles.ts`                                       | The internal motion roles: the springs, durations and curves `spec:AST-094` FR4 names, registered by the shared tables, and a role's CSS form read back.             |
 | `roleValue.ts`                                   | A role's CSS form, written: a spring's duration and bounce, a duration in ms, a curve's `cubic-bezier()`.                                                            |
 | `resolveMotion.ts`                               | A role's value: its table value, as the per-role tables stay internal (`spec:AST-094` DEC-15).                                                                       |
@@ -37,6 +41,7 @@ roles through `resolveMotion`.
 | `resolveSnapPoint.ts`                            | Release policy: the snap point a release lands on (flick, back-out cancel, step limit), on `selectSnapPoint`. Internal.                                              |
 | `bezier.ts`                                      | Cubic-bézier timing functions (Core Animation's named curves).                                                                                                       |
 | `animator.ts`                                    | Compositor animator: springs, coasts and any closed-form curve compiled to Web Animations, read back analytically.                                                   |
+| `progress.ts`                                    | A spring's progress, one curve mapped from another (companions, clamped ranges), the velocity that continues a motion.                                               |
 | `presentation.ts`                                | Where each moving element is drawn relative to where the engine hit-tests it, reported by the animator while translate runs; read by the gesture host at touch-down. |
 | `reducedMotionPlan.ts`                           | The animator's Reduce Motion planner: what one call becomes, a cross-fade whose travel lands while transparent or at once.                                           |
 | `__tests__/animator.interaction.browser.spec.ts` | Browser proofs on the interaction harness (Chromium and WebKit): busy main thread, end state through a block, no Layout / Paint, seeked curves, a dialog's backdrop. |
@@ -64,7 +69,7 @@ the timings that decide who gets a touch are not roles.
 ## Animator
 
 ```
-import {createAnimator} from '../motion/animator';
+import {createMotionAnimator} from '../motion/animator';
 import {coast} from '../motion/coast';
 import {solveSpringTowardRamp, toSpring} from '../motion/spring';
 import {resolveMotion} from '../motion/resolveMotion';
@@ -73,7 +78,7 @@ import {registerSpringsTable, springs} from '../motion/uikit';
 // Once, so the springs are registered as their roles:
 registerSpringsTable();
 
-const animator = createAnimator(sheet);
+const animator = createMotionAnimator(sheet);
 // The animator plays a motion role (spec:AST-094 FR4), its table value, as the
 // per-role tables stay internal (DEC-15); math on a spring reads the role with
 // resolveMotion.
@@ -138,8 +143,10 @@ await handle.finished; // true if it ran to the end, false if interrupted
   presented call's second frame) runs on over two frames, the start moves to
   the call's first read after it, with every call of that task. Everything
   the call starts shares that start
-  (`handle.started`); a retarget keeps an explicit one, and `{at}` puts
-  several animators on one clock. `{start: 'commit'}` lets the browser date
+  (`handle.started`); a retarget of a curve that still moves keeps an
+  explicit one, while one on a tail that already shows as at rest (within two
+  sample tolerances of its target, and slower than one a frame) counts as a
+  call from rest. `{at}` puts several animators on one clock. `{start: 'commit'}` lets the browser date
   a retarget too; `{start: 'presented'}` waits two frames, until the
   element at rest has been presented. `handle.curve(property)` is the curve
   a call plays, for a companion to follow. `{additive: true}` retargets the
@@ -168,7 +175,7 @@ await handle.finished; // true if it ran to the end, false if interrupted
 - `animatorFor(element)` returns the one animator for an element, so code
   that animates it from several places (a swipe on x, a removal on y)
   composes in one `translate` track.
-- `createAnimator(dialog, {pseudoElement: '::backdrop'})` drives a
+- `createMotionAnimator(dialog, {pseudoElement: '::backdrop'})` drives a
   pseudo-element; with no inline style to hold it, a static filling animation
   holds its end value until the next animation replaces it, while the
   pseudo-element exists. A dialog's `::backdrop` is made again each time the

package/src/motion/android/index.ts

@@ -0,0 +1,18 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file index.ts
+ * @input The domain files of the Android constants table
+ * @output Re-exports `keyboard`
+ * @position Entry of the Android constants table (motion/android). It is
+ *   internal to core, not exported from the package entry point.
+ *
+ * Where a touch presentation follows something Android draws itself, such as
+ * the software keyboard, its numbers come from here with their sources. The
+ * UIKit table does the same for iOS.
+ *
+ * SYNC: When you add a domain file, re-export it here and list it in
+ * /packages/core/src/motion/README.md.
+ */
+
+export {keyboard} from './keyboard';

package/src/motion/android/keyboard.ts

@@ -0,0 +1,96 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file keyboard.ts
+ * @input None
+ * @output `keyboard`: how the software keyboard moves on Android, in Chrome
+ *   with Gboard, as the page sees it. It holds the slides' durations and
+ *   curves, and when they start against Chrome's report and a blur.
+ * @position The keyboard domain of the Android constants table, read by
+ *   keyboard/keyboardModel.ts. The UIKit table holds iOS's keyboard.
+ *
+ * SYNC: When modified, update /packages/core/src/keyboard/README.md
+ */
+
+// Chrome reports the keyboard once per slide, through the visual viewport,
+// just after the slide starts, never per frame. Content that rides the
+// keyboard plays these curves from the slide's start, so it moves in step
+// with Gboard. They are Gboard's own motion, with no motion role. The system
+// moves the keyboard on them whatever the page does, so any other curve
+// would leave the content out of step.
+//
+// The values come from the Android 15 emulator with Chromium 158 and Gboard.
+// A screen recording at 540 × 1200 gives Gboard's top in every frame, beside
+// a marker the page paints on each report. Every leaf carries one or more
+// `@source`, and android.test.ts enforces it.
+export const keyboard = {
+  /**
+   * How long Gboard takes to slide up, in ms: from its first moved frame to
+   * its resting top.
+   *
+   * @source measured: Chromium 158 with Gboard on Android 15 (API 35
+   *   emulator); 20 shows recorded frame by frame: 250 to 282 ms, 18 of
+   *   them 264 to 268 ms, Oct 25 2026
+   */
+  showMs: 267,
+  /**
+   * The curve of Gboard's slide up, cubic-bézier control points: fast out,
+   * a long settle.
+   *
+   * @source measured: Chromium 158 with Gboard on Android 15 (API 35
+   *   emulator); the same 20 shows fit this curve over `showMs` within
+   *   2.4 px rms, Oct 25 2026
+   */
+  showCurve: [0.1, 0, 0, 1],
+  /**
+   * How long after Gboard starts to slide up Chrome's report of it fires, in
+   * ms. A show rides from the report dated back by this, joining the slide
+   * where it is.
+   *
+   * @source measured: Chromium 158 with Gboard on Android 15 (API 35
+   *   emulator); twelve shows: the first frame the page painted after the
+   *   visual viewport's resize came 14 to 35 ms (median 33) after Gboard's
+   *   first moved frame, less the 8 ms an event takes on average to reach
+   *   the screen, Oct 25 2026
+   */
+  showReportLagMs: 25,
+  /**
+   * How long Gboard takes to slide down out of the page, in ms.
+   *
+   * @source measured: Chromium 158 with Gboard on Android 15 (API 35
+   *   emulator); 21 hides recorded frame by frame, from Gboard's first
+   *   moved frame until it leaves the screen: 148 to 153 ms in 20 of them;
+   *   this length with `hideCurve` fits them within 7.7 px rms,
+   *   Oct 25 2026
+   */
+  hideMs: 167,
+  /**
+   * The curve of Gboard's slide down, cubic-bézier control points: a slow
+   * first frame, then fast.
+   *
+   * @source measured: Chromium 158 with Gboard on Android 15 (API 35
+   *   emulator); the same 21 hides, a free fit over `hideMs`, Oct 25 2026
+   */
+  hideCurve: [0.3, 0.1, 0.2, 0.9],
+  /**
+   * How long after the focused field blurs (to nothing that brings up a
+   * keyboard) Gboard starts to slide down, in ms.
+   *
+   * @source measured: Chromium 158 with Gboard on Android 15 (API 35
+   *   emulator); five scripted blurs with a marker the page paints on the
+   *   blur: Gboard's first moved frame came from a frame before the marker
+   *   to 33 ms after it (median 16), Oct 25 2026
+   */
+  hideAfterBlurMs: 16,
+  /**
+   * How long after Gboard starts to slide down Chrome's report of the hide
+   * fires, in ms, measured on blurs. A hide nothing predicts, such as Back,
+   * reuses it, though Chrome can report Back later in the slide.
+   *
+   * @source measured: Chromium 158 with Gboard on Android 15 (API 35
+   *   emulator); twelve scripted blurs: the visual viewport's resize came
+   *   42 to 52 ms after the blur (median 49), less `hideAfterBlurMs`,
+   *   Oct 25 2026
+   */
+  hideReportLagMs: 33,
+} as const;