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

package/src/motion/bezier.test.ts

@@ -1,52 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file bezier.test.ts
- * @input vitest, the cubic-bézier timing function
- * @output Checks the solver against the curve's own parametric form and the
- *   properties every CSS / Core Animation timing curve has
- * @position Testing; validates bezier.ts without a browser
- */
-
-import {describe, expect, it} from 'vitest';
-import {cubicBezier, type BezierPoints} from './bezier';
-import {timing} from './uikit/timing';
-
-const CURVES: BezierPoints[] = [
-  timing.curves.viewChange,
-  timing.curves.move,
-  timing.curves.exit,
-  timing.curves.entrance,
-  [0.24, 1, 0.4, 1],
-  [0.3, 0, 0.6, 0.6],
-];
-
-describe('cubicBezier', () => {
-  it.each(CURVES)('matches the parametric curve (%s)', (...points) => {
-    const [x1, y1, x2, y2] = points;
-    const ease = cubicBezier(points);
-    const axis = (a: number, b: number, t: number) =>
-      3 * a * t * (1 - t) ** 2 + 3 * b * t * t * (1 - t) + t ** 3;
-    for (let t = 0; t <= 1; t += 1 / 256) {
-      expect(ease(axis(x1, x2, t))).toBeCloseTo(axis(y1, y2, t), 5);
-    }
-  });
-
-  it('runs from 0 to 1 and clamps outside', () => {
-    for (const points of CURVES) {
-      const ease = cubicBezier(points);
-      expect(ease(0)).toBe(0);
-      expect(ease(1)).toBe(1);
-      expect(ease(-0.5)).toBe(0);
-      expect(ease(1.5)).toBe(1);
-    }
-  });
-
-  it('ease-in-out is symmetric about its midpoint', () => {
-    const ease = cubicBezier(timing.curves.move);
-    expect(ease(0.5)).toBeCloseTo(0.5, 9);
-    for (let x = 0; x <= 0.5; x += 0.05) {
-      expect(ease(x) + ease(1 - x)).toBeCloseTo(1, 6);
-    }
-  });
-});

package/src/motion/coast.test.ts

@@ -1,99 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file coast.test.ts
- * @input vitest, coast.ts, and the decay and spring math it composes
- * @output Checks each momentum curve `coast` builds against the closed-form
- *   coast and edge spring: inside the bounds, through an edge, released past
- *   an edge, at rest, from the presentation value at the release time
- * @position Testing; pure, with a stand-in for the animator's `get`
- */
-
-import {describe, expect, it} from 'vitest';
-import type {Animator, MotionProperty} from './animator';
-import {coast} from './coast';
-import {solveDecay} from './decay';
-import {solveSpring, toSpring} from './spring';
-import {scroll} from './uikit/scroll';
-
-/** An animator whose presentation values are fixed, recording `get` times. */
-function at(values: Partial<Record<MotionProperty, number>>) {
-  const reads: (number | undefined)[] = [];
-  const animator = {
-    get(property: MotionProperty, time?: number) {
-      reads.push(time);
-      return values[property] ?? 0;
-    },
-  } as unknown as Animator;
-  return {animator, reads};
-}
-
-describe('coast', () => {
-  it('follows the coast from the presentation value and ends where it projects', () => {
-    const {animator} = at({y: 40});
-    const {y} = coast(animator, {y: -2400});
-    const glide = solveDecay({from: 40, velocity: -2400});
-    expect(y).toBeDefined();
-    for (const t of [0, 0.016, 0.1, 0.4, 1.2]) {
-      expect(y!.at(t)).toBeCloseTo(glide.value(t), 9);
-      expect(y!.velocity(t)).toBeCloseTo(glide.velocity(t), 9);
-    }
-    expect(y!.at(y!.duration)).toBe(glide.rest);
-  });
-
-  it('hands the coast\u2019s velocity to the edge spring where it reaches an edge', () => {
-    const {animator} = at({y: -100});
-    const {y} = coast(animator, {y: 3000}, {bounds: {y: {min: -2000, max: 0}}});
-    const glide = solveDecay({from: -100, velocity: 3000});
-    const hit = glide.timeToReach(0) as number;
-    expect(y!.at(hit)).toBeCloseTo(0, 6);
-    expect(y!.velocity(hit - 1e-9)).toBeCloseTo(y!.velocity(hit + 1e-9), 2);
-    // It overshoots past the edge, then comes back to it.
-    expect(y!.at(hit + 0.06)).toBeGreaterThan(0);
-    expect(y!.at(y!.duration)).toBe(0);
-  });
-
-  it('springs straight back with the release velocity when released past an edge', () => {
-    const {animator} = at({x: 60});
-    const {x} = coast(animator, {x: 400}, {bounds: {x: {min: -500, max: 0}}});
-    const back = solveSpring(toSpring(scroll.bounce), {
-      from: 60,
-      to: 0,
-      velocity: 400,
-    });
-    expect(x!.velocity(0)).toBeCloseTo(400, 6);
-    expect(x!.at(0.1)).toBeCloseTo(back.value(0.1), 9);
-    expect(x!.at(x!.duration)).toBe(0);
-  });
-
-  it('rests where it is at zero velocity inside its bounds', () => {
-    const {animator} = at({x: -30});
-    const {x} = coast(animator, {x: 0}, {bounds: {x: {min: -100, max: 0}}});
-    expect(x!.duration).toBe(0);
-    expect(x!.at(0)).toBe(-30);
-  });
-
-  it('reads the presentation value at the release time, on the translate axes only', () => {
-    const {animator, reads} = at({x: 0, y: 0});
-    const curves = coast(animator, {x: 500, y: 200}, {at: 1234});
-    expect(Object.keys(curves).sort()).toEqual(['x', 'y']);
-    expect(curves.x!.velocity(0)).toBeCloseTo(500, 9);
-    expect(curves.y!.velocity(0)).toBeCloseTo(200, 9);
-    expect(reads).toEqual([1234, 1234]);
-  });
-
-  it('coasts at the given rate', () => {
-    const {animator} = at({x: 0});
-    const {x} = coast(
-      animator,
-      {x: 1000},
-      {rate: scroll.decelerationRate.fast},
-    );
-    const glide = solveDecay({
-      from: 0,
-      velocity: 1000,
-      rate: scroll.decelerationRate.fast,
-    });
-    expect(x!.at(x!.duration)).toBe(glide.rest);
-  });
-});

package/src/motion/decay.test.ts

@@ -1,120 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file decay.test.ts
- * @input vitest, the decay model
- * @output Checks the continuous coast against an independent per-millisecond
- *   simulation of UIScrollView's deceleration, against WWDC18's projection,
- *   and every derived time (settle, speed, reach)
- * @position Testing; validates decay.ts without a browser
- */
-
-import {describe, expect, it} from 'vitest';
-import {decayRestDistance, solveDecay} from './decay';
-import {projectDistance} from './projection';
-import {scroll} from './uikit/scroll';
-
-/**
- * Independent reference: the deceleration rate applied literally, the
- * velocity multiplied by the rate once per millisecond and integrated
- * exactly over each millisecond step.
- */
-function perMillisecond(
-  from: number,
-  velocity: number,
-  rate: number,
-  ms: number,
-) {
-  let x = from;
-  let v = velocity / 1000; // units per ms
-  const k = -Math.log(rate);
-  for (let i = 0; i < ms; i++) {
-    // Within one ms the speed falls from v to v·rate exponentially.
-    x += (v * (1 - rate)) / k;
-    v *= rate;
-  }
-  return {value: x, velocity: v * 1000};
-}
-
-describe('solveDecay', () => {
-  for (const rate of [
-    scroll.decelerationRate.normal,
-    scroll.decelerationRate.fast,
-  ]) {
-    for (const velocity of [-3000, -400, 150, 2500, 8000]) {
-      it(`matches a per-millisecond simulation (rate ${rate}, ${velocity} units/s)`, () => {
-        const coast = solveDecay({from: 100, velocity, rate});
-        for (const ms of [0, 1, 16, 100, 250, 600, 1500, 4000]) {
-          const reference = perMillisecond(100, velocity, rate, ms);
-          expect(coast.value(ms / 1000)).toBeCloseTo(reference.value, 6);
-          expect(coast.velocity(ms / 1000)).toBeCloseTo(reference.velocity, 6);
-        }
-      });
-    }
-  }
-
-  it('rests where the coast ends, 0.1 % past WWDC18\u2019s geometric projection', () => {
-    const coast = solveDecay({from: 0, velocity: 2000});
-    expect(coast.rest).toBeCloseTo(2000 / (-1000 * Math.log(0.998)), 9);
-    expect(coast.value(60)).toBeCloseTo(coast.rest, 6);
-    // −1 ÷ ln(0.998) = 499.5 ms against 0.998 ÷ 0.002 = 499 ms.
-    expect(coast.rest / projectDistance(2000)).toBeCloseTo(499.5 / 499, 3);
-    expect(decayRestDistance(2000)).toBeCloseTo(coast.rest, 9);
-  });
-
-  it('a fast rate stops sooner and shorter', () => {
-    const normal = solveDecay({from: 0, velocity: 2000});
-    const fast = solveDecay({
-      from: 0,
-      velocity: 2000,
-      rate: scroll.decelerationRate.fast,
-    });
-    expect(fast.rest).toBeLessThan(normal.rest);
-    expect(fast.settleTime(0.5)).toBeLessThan(normal.settleTime(0.5));
-  });
-
-  it('settleTime bounds every later distance to rest', () => {
-    const coast = solveDecay({from: 0, velocity: -5000});
-    for (const threshold of [5, 0.5, 0.01]) {
-      const settle = coast.settleTime(threshold);
-      expect(Math.abs(coast.value(settle) - coast.rest)).toBeCloseTo(
-        threshold,
-        9,
-      );
-      expect(Math.abs(coast.value(settle + 0.5) - coast.rest)).toBeLessThan(
-        threshold,
-      );
-    }
-    expect(solveDecay({from: 0, velocity: 0.1}).settleTime(0.5)).toBe(0);
-  });
-
-  it('timeToSpeed lands on the asked speed', () => {
-    const coast = solveDecay({from: 0, velocity: 3000});
-    const t = coast.timeToSpeed(100);
-    expect(coast.velocity(t)).toBeCloseTo(100, 9);
-    expect(coast.timeToSpeed(5000)).toBe(0);
-    expect(coast.timeToSpeed(0)).toBe(Infinity);
-  });
-
-  it('timeToReach finds the crossing, or null when the coast never gets there', () => {
-    const coast = solveDecay({from: 0, velocity: 2000});
-    const t = coast.timeToReach(400);
-    expect(t).not.toBeNull();
-    expect(coast.value(t ?? 0)).toBeCloseTo(400, 9);
-    expect(coast.timeToReach(-10)).toBeNull();
-    expect(coast.timeToReach(coast.rest)).toBeNull();
-    expect(coast.timeToReach(coast.rest + 1)).toBeNull();
-    const back = solveDecay({from: 0, velocity: -2000});
-    expect(back.value(back.timeToReach(-400) ?? 0)).toBeCloseTo(-400, 9);
-    expect(solveDecay({from: 3, velocity: 0}).timeToReach(3)).toBe(0);
-  });
-
-  it('rejects a rate outside (0, 1)', () => {
-    expect(() => solveDecay({from: 0, velocity: 1, rate: 1})).toThrow(
-      RangeError,
-    );
-    expect(() => solveDecay({from: 0, velocity: 1, rate: 0})).toThrow(
-      RangeError,
-    );
-  });
-});

package/src/motion/projection.test.ts

@@ -1,107 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file projection.test.ts
- * @input vitest, the projection functions
- * @output Checks WWDC18's projection verbatim and the release-target rules
- *   (nearest projected rest, step limits)
- * @position Testing; validates projection.ts without a browser
- */
-
-import {describe, expect, it} from 'vitest';
-import {project, projectDistance, selectSnapPoint} from './projection';
-import {scroll} from './uikit/scroll';
-
-describe('projectDistance', () => {
-  it('is WWDC18\u2019s (v ÷ 1000)·r ÷ (1 − r)', () => {
-    for (const velocity of [-2500, -1, 0, 640, 3000]) {
-      for (const rate of [0.998, 0.99]) {
-        expect(projectDistance(velocity, rate)).toBeCloseTo(
-          ((velocity / 1000) * rate) / (1 - rate),
-          9,
-        );
-      }
-    }
-  });
-
-  it('projects 499 ms of the release speed at the normal rate (the sheet\u2019s prior art)', () => {
-    expect(projectDistance(1000)).toBeCloseTo(499, 9);
-    expect(projectDistance(1000, scroll.decelerationRate.fast)).toBeCloseTo(
-      99,
-      9,
-    );
-  });
-
-  it('a release at rest projects onto itself', () => {
-    expect(project(321, 0)).toBe(321);
-  });
-
-  it('rejects a rate outside (0, 1)', () => {
-    expect(() => projectDistance(10, 1)).toThrow(RangeError);
-  });
-});
-
-describe('selectSnapPoint', () => {
-  const detents = [0, 300, 600];
-
-  it('goes to the point nearest the projected rest, not the release point', () => {
-    // Released nearer 300, but thrown toward 600.
-    expect(selectSnapPoint(detents, {position: 320, velocity: 900}).value).toBe(
-      600,
-    );
-    // A slow release places.
-    expect(selectSnapPoint(detents, {position: 320, velocity: 20}).value).toBe(
-      300,
-    );
-    // Thrown the other way.
-    expect(
-      selectSnapPoint(detents, {position: 320, velocity: -900}).value,
-    ).toBe(0);
-  });
-
-  it('a projection past the ends lands on the end', () => {
-    expect(
-      selectSnapPoint(detents, {position: 580, velocity: 6000}).value,
-    ).toBe(600);
-    expect(
-      selectSnapPoint(detents, {position: 10, velocity: -6000}).index,
-    ).toBe(0);
-  });
-
-  it('reports the projection it chose from', () => {
-    const choice = selectSnapPoint(detents, {position: 100, velocity: 400});
-    expect(choice.projected).toBeCloseTo(100 + 0.4 * 499, 9);
-  });
-
-  it('limits the travel to maxSteps points from fromIndex', () => {
-    const pages = [0, 100, 200, 300, 400];
-    expect(selectSnapPoint(pages, {position: 110, velocity: 5000}).value).toBe(
-      400,
-    );
-    expect(
-      selectSnapPoint(pages, {
-        position: 110,
-        velocity: 5000,
-        fromIndex: 1,
-        maxSteps: 1,
-      }).value,
-    ).toBe(200);
-  });
-
-  it('breaks an exact tie toward the direction of travel', () => {
-    expect(
-      selectSnapPoint([0, 100], {position: 50, velocity: 0.0001, rate: 0.5})
-        .value,
-    ).toBe(100);
-    expect(
-      selectSnapPoint([0, 100], {position: 50, velocity: -0.0001, rate: 0.5})
-        .value,
-    ).toBe(0);
-  });
-
-  it('needs at least one point', () => {
-    expect(() => selectSnapPoint([], {position: 0, velocity: 0})).toThrow(
-      RangeError,
-    );
-  });
-});

package/src/motion/reducedMotion.test.ts

@@ -1,129 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file reducedMotion.test.ts
- * @input reducedMotion.ts, reducedMotion.stylex.ts, the timing table, and
- *   every StyleX source file in core
- * @output Proof that the Reduced Motion policy for code beside the animator
- *   fades 200 ms at most on a coarse pointer or a touch release and completes
- *   at once elsewhere, that its CSS constants match the table, and that every
- *   StyleX key splitting Reduce Motion by pointer spells the two queries
- * @position Testing for /packages/core/src/motion/reducedMotion.ts
- */
-
-import {readdirSync, readFileSync} from 'node:fs';
-import {join, resolve} from 'node:path';
-import {afterEach, describe, expect, it, vi} from 'vitest';
-import {
-  REDUCED_MOTION_FADE_QUERY,
-  REDUCED_MOTION_INSTANT_QUERY,
-  reducedMotionFade,
-} from './reducedMotion';
-import {
-  reducedMotionFadeConsts,
-  reducedMotionKeys,
-} from './reducedMotion.stylex';
-import {timing} from './uikit/timing';
-
-/** The person's settings, through `matchMedia`: no option overrides them. */
-function settings(reduced: boolean, coarse: boolean) {
-  vi.stubGlobal('matchMedia', (query: string) => ({
-    matches: query.includes('prefers-reduced-motion')
-      ? reduced
-      : query.includes('pointer: coarse')
-        ? coarse
-        : false,
-    media: query,
-  }));
-}
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-describe('reducedMotionFade', () => {
-  it('is null when motion is not reduced', () => {
-    settings(false, true);
-    expect(reducedMotionFade(null)).toBeNull();
-  });
-
-  it('fades 200 ms at most on easeInOut on a coarse pointer', () => {
-    settings(true, true);
-    const fade = reducedMotionFade(null);
-    expect(fade).toEqual({
-      duration: timing.reducedMotionCrossFadeMs,
-      easing: 'cubic-bezier(0.42, 0, 0.58, 1)',
-    });
-    expect(fade?.duration).toBeGreaterThan(0);
-    expect(fade?.duration).toBeLessThanOrEqual(200);
-  });
-
-  it('completes at once on any other pointer, unless a touch release started it', () => {
-    settings(true, false);
-    expect(reducedMotionFade(null)).toEqual({duration: 0, easing: 'linear'});
-    expect(reducedMotionFade(null, {touchRelease: true})?.duration).toBe(
-      timing.reducedMotionCrossFadeMs,
-    );
-  });
-});
-
-describe('the CSS side of the policy', () => {
-  it('holds the same fade as the table', () => {
-    expect(reducedMotionFadeConsts.duration).toBe(
-      `${timing.reducedMotionCrossFadeMs}ms`,
-    );
-    expect(reducedMotionFadeConsts.easing).toBe(
-      `cubic-bezier(${timing.curves.move.join(', ')})`,
-    );
-  });
-
-  it('spells the two media keys from the queries', () => {
-    expect(reducedMotionKeys.fade).toBe(`@media ${REDUCED_MOTION_FADE_QUERY}`);
-    expect(reducedMotionKeys.instant).toBe(
-      `@media ${REDUCED_MOTION_INSTANT_QUERY}`,
-    );
-  });
-
-  it('every key that splits Reduce Motion by pointer is one of the two constants, spelled exactly', () => {
-    const allowed = new Set<string>([
-      reducedMotionKeys.fade,
-      reducedMotionKeys.instant,
-    ]);
-    const root = resolve(__dirname, '..');
-    const offenders: string[] = [];
-    const walk = (dir: string) => {
-      for (const entry of readdirSync(dir, {withFileTypes: true})) {
-        const path = join(dir, entry.name);
-        if (entry.isDirectory()) {
-          if (entry.name !== 'node_modules' && entry.name !== '__tests__') {
-            walk(path);
-          }
-        } else if (
-          /\.tsx?$/.test(entry.name) &&
-          !/\.(test|spec|stories)\.tsx?$/.test(entry.name)
-        ) {
-          for (const match of readFileSync(path, 'utf8').matchAll(
-            /'(@media[^']*prefers-reduced-motion: reduce[^']*pointer[^']*)'/g,
-          )) {
-            if (!allowed.has(match[1])) {
-              offenders.push(`${path.slice(root.length)}: ${match[1]}`);
-            }
-          }
-          // A constant as a computed key lands in a later priority layer.
-          if (
-            !/[/\\]motion[/\\]reducedMotion\.ts$/.test(path) &&
-            /\[reducedMotionKeys\.(fade|instant)\]/.test(
-              readFileSync(path, 'utf8'),
-            )
-          ) {
-            offenders.push(
-              `${path.slice(root.length)}: a computed reducedMotionKeys key`,
-            );
-          }
-        }
-      }
-    };
-    walk(root);
-    expect(offenders).toEqual([]);
-  });
-});

package/src/motion/reducedMotionPlan.test.ts

@@ -1,182 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file reducedMotionPlan.test.ts
- * @input planReducedMotion and a stand-in view of the animator
- * @output Tests of the Reduce Motion planner on its own (the animator's
- *   behavior under the plan is in animator.test.ts)
- * @position Testing for /packages/core/src/motion/reducedMotionPlan.ts
- */
-
-import {describe, expect, it} from 'vitest';
-import type {MotionProperty} from './animator';
-import {planReducedMotion, type ReducedMotionView} from './reducedMotionPlan';
-import {reducedMotionCrossFade} from './uikit/timing';
-
-const MS = reducedMotionCrossFade.durationMs;
-
-function view(overrides: Partial<ReducedMotionView> = {}): ReducedMotionView {
-  const values: Partial<Record<MotionProperty, number>> = {opacity: 1};
-  return {
-    valueAt: property => values[property] ?? 0,
-    opacityHeading: () => 1,
-    ownOpacity: () => 1,
-    writesOwnOpacity: () => false,
-    borrowedOpacity: null,
-    hasOpacityCurve: false,
-    restingOpacity: 1,
-    hasPendingLanding: false,
-    ...overrides,
-  };
-}
-
-describe('planReducedMotion', () => {
-  it('without a fade (a fine primary pointer), writes everything at once (DR3)', () => {
-    const plan = planReducedMotion(
-      view(),
-      0,
-      {x: 100, opacity: 0},
-      ['x', 'opacity'],
-      false,
-    );
-    expect(plan.atOnce).toEqual(['x', 'opacity']);
-    expect(plan.opacityFade).toBeNull();
-    expect(plan.landing).toBeNull();
-  });
-
-  it('an entrance lands at once and fades in over the cross-fade (DR2)', () => {
-    const plan = planReducedMotion(
-      view({valueAt: p => (p === 'opacity' ? 0 : 0)}),
-      0,
-      {x: 100, opacity: 1},
-      ['x', 'opacity'],
-      true,
-    );
-    expect(plan.atOnce).toEqual(['x']);
-    expect(plan.opacityFade).toEqual([
-      {at: 0, value: 0},
-      {at: MS, value: 1},
-    ]);
-    expect(plan.landing).toBeNull();
-  });
-
-  it('an exit fades out in place, then lands its travel', () => {
-    const plan = planReducedMotion(
-      view(),
-      0,
-      {x: 100, opacity: 0},
-      ['x', 'opacity'],
-      true,
-    );
-    expect(plan.opacityFade).toEqual([
-      {at: 0, value: 1},
-      {at: MS, value: 0},
-    ]);
-    expect(plan.landing?.at).toBe(MS);
-    expect([...(plan.landing?.values ?? [])]).toEqual([['x', 100]]);
-    expect(plan.holds).toEqual({x: 0});
-  });
-
-  it('a move whose opacity rises from a visible value dips rather than landing in view', () => {
-    const plan = planReducedMotion(
-      view({valueAt: p => (p === 'opacity' ? 0.5 : 0)}),
-      0,
-      {x: 100, opacity: 1},
-      ['x', 'opacity'],
-      true,
-    );
-    expect(plan.opacityFade).toEqual([
-      {at: 0, value: 0.5},
-      {at: MS / 2, value: 0},
-    ]);
-    expect(plan.landing?.at).toBe(MS / 2);
-    expect(plan.landing?.fadeIn).toEqual({
-      to: 1,
-      ms: MS / 2,
-      isBorrowed: false,
-    });
-  });
-
-  it('a move whose opacity falls to a visible value dips rather than landing in view', () => {
-    const plan = planReducedMotion(
-      view(),
-      0,
-      {x: 100, opacity: 0.5},
-      ['x', 'opacity'],
-      true,
-    );
-    expect(plan.landing?.at).toBe(MS / 2);
-    expect(plan.landing?.fadeIn).toEqual({
-      to: 0.5,
-      ms: MS / 2,
-      isBorrowed: false,
-    });
-  });
-
-  it('a move alone dips on the stylesheet opacity it borrows, and lands at the bottom', () => {
-    const plan = planReducedMotion(
-      view({ownOpacity: () => 0.6}),
-      0,
-      {x: 100},
-      ['x'],
-      true,
-    );
-    expect(plan.borrowed).toBe(0.6);
-    expect(plan.opacityFade).toEqual([
-      {at: 0, value: 0.6},
-      {at: MS / 2, value: 0},
-    ]);
-    expect(plan.landing?.at).toBe(MS / 2);
-    expect(plan.landing?.fadeIn).toEqual({
-      to: 0.6,
-      ms: MS / 2,
-      isBorrowed: true,
-    });
-  });
-
-  it('a stylesheet that hides the element lends nothing: the move lands at once, with no dip', () => {
-    const plan = planReducedMotion(
-      view({ownOpacity: () => 0}),
-      0,
-      {x: 100},
-      ['x'],
-      true,
-    );
-    expect(plan.atOnce).toEqual(['x']);
-    expect(plan.opacityFade).toBeNull();
-    expect(plan.landing).toBeNull();
-  });
-
-  it('an opacity the animator writes is owned: a dip returns to it, borrowing nothing', () => {
-    const plan = planReducedMotion(
-      view({ownOpacity: () => 0, writesOwnOpacity: () => true}),
-      0,
-      {x: 100},
-      ['x'],
-      true,
-    );
-    expect(plan.borrowed).toBeNull();
-    expect(plan.landing?.fadeIn).toEqual({
-      to: 1,
-      ms: MS / 2,
-      isBorrowed: false,
-    });
-  });
-
-  it('an exit by role on a surface no call owns opacity on restores the stylesheet opacity', () => {
-    const plan = planReducedMotion(
-      view({ownOpacity: () => 0.6}),
-      0,
-      {y: 40},
-      ['y'],
-      true,
-      'exit',
-    );
-    expect(plan.opacityFade).toEqual([
-      {at: 0, value: 0.6},
-      {at: MS, value: 0},
-    ]);
-    expect(plan.landing?.restore).toBe(0.6);
-    expect(plan.landing?.restoreIsBorrowed).toBe(true);
-  });
-});