Repository navigation
feat(core): one rect morph for touch presentations that grow out of a source rect #9769
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
base: main
Are you sure you want to change the base?
Changes from all commits
3dd581e
3cfb3b1
273da1e
f1149cd
131ca14
f19df27
e3a43d0
c99210a
3272828
df642e0
8c8f726
3fdca8f
d4903e2
1b794af
5dd6a6a
3bfa524
ad7f8fb
99d352d
33a3ee8
2bf8f8a
822013a
2651e17
6354fa3
dcfa346
6b6310c
78442d4
09bb9c2
b24c23c
9d40852
6c17632
18fcf70
6176b9d
f082fe6
b957453
File filter
Filter by extension
Conversations
Jump to
Diff view
Diff view
There are no files selected for viewing
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,7 @@ | ||
| --- | ||
| '@astryxdesign/core': patch | ||
| --- | ||
|
|
||
| [chore] Internal: the rect morph's paths, the geometry touch presentations share when they grow out of a source rect and shrink back into it. `lerpPath` (a straight line between two rects) and `edgeGrowPath` (UIKit's popover, growing out of a point on its edge) name the rect an element shows at each progress, and say how an interrupted motion continues in their own law; `morphCurves` turns a path into compositor curves (`translate`, `scale` and a companion `opacity`). Not exported from the package entry point; no component uses them yet. | ||
|
|
||
| @vjeux |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,7 @@ | ||
| --- | ||
| '@astryxdesign/core': patch | ||
| --- | ||
|
|
||
| [chore] Internal: the rect morph, one way for a touch presentation to grow out of a source rect and shrink back into it. `createRectMorph` presents an element along a path (`lerpPath`, `edgeGrowPath`) and dismisses it back on a copy or on itself, each continuing the other from the rect on screen. Each play takes the timing the component's motion record names (AST-094 FR45): a duration and easing, or a spring, starting from the velocity it is given. Reduced Motion is left to the animator. `easedProgress` moves to the progress helpers with the same values. `timedCurve` joins them: a timed motion that keeps a retargeted velocity, for the pager and the rect morph. Not exported from the package entry point; no component uses it yet. | ||
|
|
||
| @vjeux |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -36,6 +36,7 @@ verified_by: | |
| "packages/core/src/Layer/inputHold.ts", | ||
| "packages/core/src/gestures/tapWobble.ts", | ||
| "packages/core/src/hooks/usePager.ts", | ||
| "packages/core/src/motion/rectMorph.ts", | ||
| "packages/core/src/motion/uikit/segmented.ts", | ||
| "packages/core/src/motion/uikit/slider.ts" | ||
| ] | ||
|
|
@@ -650,7 +651,13 @@ under a finger, and a mouse follows `module:DropdownMenu/useMenuPress` FR3 and | |
| shrink plays on the theme's exit duration and easing (FR7). The shrink plays in full after the surface has | ||
| closed. This is its exit under FR7 (`family:overlay-dismissal` AV6); under | ||
| reduced motion FR8 applies. A menu or popover presented as a bottom sheet | ||
| follows the sheet instead. | ||
| follows the sheet instead. `motion/morphPath.ts` gives the rect a grow-out | ||
| presentation shows at each progress (a straight line, or a popover's edge | ||
| grow); `motion/rectMorph.ts` imports it; no other motion module maps a | ||
| progress to a rect. `motion/rectMorph.ts` grows a touch presentation out of | ||
| its source rect along that path and shrinks it back, each continuing the | ||
| other, so every grow-out presentation shares one path, timing and | ||
|
Comment on lines
+657
to
+659
Contributor
There was a problem hiding this comment. Choose a reason for hiding this commentThe reason will be displayed to describe this comment to others. Learn more. Non-blocking: Popover still plays its own edge growth ( |
||
| interruption. | ||
| - **FR32 — A pan outside dismisses.** Under a finger, an open anchored menu MUST close as a touch outside it | ||
| begins to pan, and at the lift of a tap or hold outside it. A Popover's | ||
| dismissal is unchanged. A pinch stays available over it: its surface | ||
|
|
||
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,220 @@ | ||
| // Copyright (c) Meta Platforms, Inc. and affiliates. | ||
|
|
||
| /** | ||
| * @file callerMotionValues.test.ts | ||
| * @input vitest, easedProgress and solveAnimatedPageScroll, and copies of | ||
| * their earlier versions, on a fixed grid of easings, durations, moves and | ||
| * retarget velocities | ||
| * @output Checks that each position and velocity is the same number, bit for | ||
| * bit, as the earlier version gives on the same platform | ||
| * @position Testing; guards the values that Popover, SegmentedControl and the | ||
| * pager read from the progress module | ||
| */ | ||
|
|
||
| import {describe, expect, it} from 'vitest'; | ||
| import type {MotionCurve} from '../animator'; | ||
| import {cubicBezier, type BezierPoints} from '../bezier'; | ||
| import {solveAnimatedPageScroll} from '../paging'; | ||
| import {easedProgress} from '../progress'; | ||
| import {paging} from '../uikit/paging'; | ||
|
|
||
| // The two reference functions below are copies of main at ebb9ddec. Their | ||
| // float results can change with the platform's math library, so the test | ||
| // compares them with the shipped functions on one platform, not with a | ||
| // stored hash. | ||
|
|
||
| /** easedProgress, copied from themeTiming.ts. */ | ||
| function referenceEasedProgress( | ||
| seconds: number, | ||
| ease: (x: number) => number, | ||
| {jumps = false}: {readonly jumps?: boolean} = {}, | ||
| ): MotionCurve { | ||
| const at = (t: number) => | ||
| seconds <= 0 || t >= seconds ? 1 : ease(Math.max(0, t) / seconds); | ||
| // A central difference, one step inside the curve at either end. | ||
| const step = Math.min(1e-3, seconds / 100); | ||
| return { | ||
| duration: seconds, | ||
| at, | ||
| velocity: t => { | ||
| if (seconds <= 0 || t >= seconds) { | ||
| return 0; | ||
| } | ||
| const before = Math.max(0, t - step); | ||
| const after = Math.min(seconds, t + step); | ||
| if (!jumps) { | ||
| return (at(after) - at(before)) / (after - before); | ||
| } | ||
| const here = at(t); | ||
| const slopes: number[] = []; | ||
| if (t > before) { | ||
| slopes.push((here - at(before)) / (t - before)); | ||
| } | ||
| if (after > t) { | ||
| slopes.push((at(after) - here) / (after - t)); | ||
| } | ||
| return slopes.reduce((a, b) => (Math.abs(b) < Math.abs(a) ? b : a)); | ||
| }, | ||
| }; | ||
| } | ||
|
|
||
| /** solveAnimatedPageScroll, copied from paging.ts. */ | ||
| function referenceAnimatedPageScroll({ | ||
| from, | ||
| to, | ||
| durationMs = paging.animatedScroll.durationMs, | ||
| curve = paging.animatedScroll.curve, | ||
| velocity, | ||
| }: { | ||
| from: number; | ||
| to: number; | ||
| durationMs?: number; | ||
| curve?: BezierPoints; | ||
| velocity?: number; | ||
| }): MotionCurve { | ||
| const duration = durationMs / 1000; | ||
| const distance = to - from; | ||
| const ease = cubicBezier(curve); | ||
| const progress = (u: number) => ease(Math.min(1, Math.max(0, u))); | ||
| // The carry, in px: the retargeted velocity over the whole duration, less | ||
| // what the curve's own starting slope already gives. | ||
| const startSlope = progress(1e-4) / 1e-4; | ||
| const carry = | ||
| velocity == null ? 0 : velocity * duration - distance * startSlope; | ||
| const at = (t: number) => { | ||
| const u = Math.min(1, Math.max(0, t / duration)); | ||
| return from + distance * progress(u) + carry * u * (1 - u) * (1 - u); | ||
| }; | ||
| return { | ||
| duration, | ||
| at, | ||
| velocity: t => { | ||
| if (t <= 0) { | ||
| return velocity ?? 0; | ||
| } | ||
| if (t >= duration) { | ||
| return 0; | ||
| } | ||
| const h = Math.min(1e-4, t / 2, (duration - t) / 2); | ||
| return (at(t + h) - at(t - h)) / (2 * h); | ||
| }, | ||
| }; | ||
| } | ||
|
|
||
| const EASINGS: ReadonlyArray<BezierPoints> = [ | ||
| [0, 0, 1, 1], | ||
| [0.25, 0.1, 0.25, 1], | ||
| [0.42, 0, 1, 1], | ||
| [0, 0, 0.58, 1], | ||
| [0.42, 0, 0.58, 1], | ||
| [0.2, 0, 0, 1], | ||
| [0.24, 1, 0.4, 1], | ||
| ]; | ||
|
|
||
| /** | ||
| * 1,005 times, in steps of 1/1000 of `duration`, from 2 steps before it, and | ||
| * 10 µs, 0.1 ms and 1 ms in from each end. | ||
| */ | ||
| function sampleTimes(duration: number): number[] { | ||
| const times: number[] = []; | ||
| for (let i = 0; i < 1005; i++) { | ||
| times.push(((i - 2) / 1000) * duration); | ||
| } | ||
| for (const inset of [1e-5, 1e-4, 1e-3]) { | ||
| times.push(inset, duration - inset); | ||
| } | ||
| return times; | ||
| } | ||
|
|
||
| /** Collects each sample whose shipped value is not the reference's. */ | ||
| function differences() { | ||
| let compared = 0; | ||
| const found: string[] = []; | ||
| return { | ||
| compare(label: string, shipped: number, reference: number) { | ||
| compared++; | ||
| if (!Object.is(shipped, reference) && found.length < 5) { | ||
| found.push(`${label}: ${shipped} is not ${reference}`); | ||
| } | ||
| }, | ||
| get compared() { | ||
| return compared; | ||
| }, | ||
| found, | ||
| }; | ||
| } | ||
|
|
||
| describe('the values Popover, SegmentedControl and the pager read', () => { | ||
| it('easedProgress gives the same positions and velocities as before', () => { | ||
| const quarterSteps = (x: number) => Math.floor(4 * x) / 4; | ||
| const eases = [ | ||
| ...EASINGS.map(points => ({ | ||
| name: points.join(','), | ||
| ease: cubicBezier(points), | ||
| })), | ||
| {name: 'steps(4)', ease: quarterSteps}, | ||
| {name: 'linear', ease: (x: number) => x}, | ||
| ]; | ||
| const positions = differences(); | ||
| const velocities = differences(); | ||
| for (const {name, ease} of eases) { | ||
| for (const seconds of [0, 0.001, 0.1, 0.15, 0.2, 0.3, 0.5]) { | ||
| for (const jumps of [false, true]) { | ||
| const shipped = easedProgress(seconds, ease, {jumps}); | ||
| const reference = referenceEasedProgress(seconds, ease, {jumps}); | ||
| for (const t of sampleTimes(seconds)) { | ||
| const label = `${name} ${seconds} s jumps=${jumps} t=${t}`; | ||
| positions.compare(label, shipped.at(t), reference.at(t)); | ||
| velocities.compare( | ||
| label, | ||
| shipped.velocity(t), | ||
| reference.velocity(t), | ||
| ); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| expect(positions.compared).toBe(9 * 7 * 2 * 1011); | ||
| expect(positions.found).toEqual([]); | ||
| expect(velocities.found).toEqual([]); | ||
| }); | ||
|
|
||
| // From rest, the velocity at t <= 0 is the one value that changes: | ||
| // paging.test.ts holds it to the curve's starting slope. | ||
| it('the pager gives the same positions, and each velocity but the first from rest', () => { | ||
| const positions = differences(); | ||
| const velocities = differences(); | ||
| for (const curve of [undefined, ...EASINGS]) { | ||
| for (const durationMs of [150, 300, 350]) { | ||
| for (const [from, to] of [ | ||
| [0, 402], | ||
| [0, 804], | ||
| [0, 2010], | ||
| [804, 402], | ||
| [100, -200], | ||
| [100, 100], | ||
| ]) { | ||
| for (const velocity of [undefined, 900, -900, 0, 2500]) { | ||
| const move = {from, to, durationMs, curve, velocity}; | ||
| const shipped = solveAnimatedPageScroll(move); | ||
| const reference = referenceAnimatedPageScroll(move); | ||
| for (const t of sampleTimes(reference.duration)) { | ||
| const label = `${JSON.stringify(move)} t=${t}`; | ||
| positions.compare(label, shipped.at(t), reference.at(t)); | ||
| if (t > 0 || velocity != null) { | ||
| velocities.compare( | ||
| label, | ||
| shipped.velocity(t), | ||
| reference.velocity(t), | ||
| ); | ||
| } | ||
| } | ||
| } | ||
| } | ||
| } | ||
| } | ||
| expect(positions.compared).toBe(8 * 3 * 6 * 5 * 1011); | ||
| expect(positions.found).toEqual([]); | ||
| expect(velocities.found).toEqual([]); | ||
| }); | ||
| }); |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Non-blocking (records carry no temporary status): now that Core has the morph, "once Core has that morph; until then, the module plays its own compositor translate" is sequencing that the gap sentence already covers. Suggested: "…played through the shared rectangle morph (
architecture:layer-runtimeINV15;spec:AST-094FR5). (Implementation gap: the size-change glide still plays its own compositor translate.)"