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

package/src/utils/pressGesture.test.ts

@@ -1,323 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file pressGesture.test.ts
- * @input pressGesture.ts
- * @output Unit tests for the press state machine, one case per requirement
- *   of the touch press model, in the model's order
- * @position Testing; validates pressGesture.ts without a browser
- *
- * Every number these assert against was measured on an iPhone simulator
- * driving the real Settings and Contacts apps with real HID touches at
- * 60 fps. The test names say the behaviour, not the mechanism, so a rewrite
- * of the machine still has to keep them.
- */
-
-import {describe, expect, it} from 'vitest';
-import type {PressEvent, PressGesture, PressPaint} from './pressGesture';
-import {
-  idlePressGesture,
-  PRESS_FADE_MS,
-  PRESS_FLASH_MS,
-  PRESS_ONSET_MS,
-  PRESS_SLOP_PX,
-  pressGestureStep,
-} from './pressGesture';
-
-/** Drive a gesture and collect what was painted after each event. */
-function run(events: PressEvent[]): {
-  paints: PressPaint[];
-  gesture: PressGesture;
-} {
-  let gesture = idlePressGesture();
-  const paints: PressPaint[] = [];
-  for (const event of events) {
-    const step = pressGestureStep(gesture, event);
-    gesture = step.gesture;
-    paints.push(step.paint);
-  }
-  return {gesture, paints};
-}
-
-const down = (x = 100, y = 100): PressEvent => ({kind: 'down', x, y});
-const move = (x: number, y: number): PressEvent => ({kind: 'move', x, y});
-
-describe('the clocks are the native ones', () => {
-  it("waits the scroll view's content-touch delay before believing a press", () => {
-    // `UIScrollView.delaysContentTouches` holds a content touch 0.15 s.
-    // Measured: a 1.5 s hold painted the native highlight for 1.34 s.
-    expect(PRESS_ONSET_MS).toBe(150);
-  });
-
-  it("uses the scroller's own slop, the release's own fade, and a flash for a quick tap", () => {
-    expect(PRESS_SLOP_PX).toBe(10);
-    expect(PRESS_FADE_MS).toBe(200);
-    expect(PRESS_FLASH_MS).toBe(100);
-  });
-});
-
-describe('nothing paints until the press is believed', () => {
-  it('paints nothing on the touch itself', () => {
-    const {paints, gesture} = run([down()]);
-    expect(paints).toEqual(['none']);
-    expect(gesture.phase).toBe('armed');
-  });
-
-  it('asks for the onset timer, and only then', () => {
-    expect(pressGestureStep(idlePressGesture(), down()).timer).toBe('onset');
-  });
-
-  it('never paints for a fling: the scroller claims it inside the delay', () => {
-    // Measured: `pointercancel` at +31 ms on a fling, 119 ms before the onset
-    // timer would have fired.
-    const {paints} = run([down(), move(100, 90), {kind: 'cancel'}]);
-    expect(paints).toEqual(['none', 'none', 'none']);
-  });
-});
-
-describe('a held press paints instantly and completely', () => {
-  it('paints on the onset, with no transition state in between', () => {
-    const {paints, gesture} = run([down(), {kind: 'onset'}]);
-    expect(paints).toEqual(['none', 'on']);
-    expect(gesture.phase).toBe('pressed');
-  });
-});
-
-describe('travel cancels, and a shaky hand does not', () => {
-  it('keeps the press while the finger stays inside the slop', () => {
-    // Measured: a 4 pt drag over 2 s kept the native highlight for the whole
-    // gesture.
-    const inside = PRESS_SLOP_PX - 1;
-    const {paints, gesture} = run([
-      down(),
-      {kind: 'onset'},
-      move(100, 100 + inside),
-    ]);
-    expect(paints).toEqual(['none', 'on', 'on']);
-    expect(gesture.phase).toBe('pressed');
-  });
-
-  it('cancels the moment the finger passes the slop, painted or not', () => {
-    const beyond = PRESS_SLOP_PX + 1;
-    const painted = run([down(), {kind: 'onset'}, move(100, 100 + beyond)]);
-    expect(painted.paints.at(-1)).toBe('none');
-    expect(painted.gesture.phase).toBe('dead');
-
-    const unpainted = run([down(), move(100, 100 + beyond)]);
-    expect(unpainted.paints).toEqual(['none', 'none']);
-    expect(unpainted.gesture.phase).toBe('dead');
-  });
-
-  it('measures travel from where the finger landed, not from the last move', () => {
-    // Otherwise a slow drag never trips the slop: each step is small, and the
-    // press would ride a scroll all the way down the list.
-    const creep: PressEvent[] = [];
-    for (let y = 101; y <= 100 + PRESS_SLOP_PX + 2; y += 1) {
-      creep.push(move(100, y));
-    }
-    const {gesture} = run([down(), {kind: 'onset'}, ...creep]);
-    expect(gesture.phase).toBe('dead');
-  });
-});
-
-describe("the scroller's claim cancels", () => {
-  it('drops the paint with no fade', () => {
-    // Measured: the native highlight goes from full to bare in ONE frame, and
-    // 45 ms BEFORE the list's content first moves.
-    const {paints, gesture} = run([down(), {kind: 'onset'}, {kind: 'cancel'}]);
-    expect(paints).toEqual(['none', 'on', 'none']);
-    expect(gesture.phase).toBe('dead');
-  });
-
-  it('asks for no timer on the way out, so nothing can fire later', () => {
-    const armed = pressGestureStep(idlePressGesture(), down()).gesture;
-    const pressed = pressGestureStep(armed, {kind: 'onset'}).gesture;
-    expect(pressGestureStep(pressed, {kind: 'cancel'}).timer).toBeNull();
-  });
-});
-
-describe('a cancelled gesture is dead', () => {
-  it('does not come back when the finger stops moving', () => {
-    const {paints, gesture} = run([
-      down(),
-      {kind: 'onset'},
-      move(100, 200),
-      move(100, 200),
-      move(100, 201),
-    ]);
-    expect(paints.slice(2)).toEqual(['none', 'none', 'none']);
-    expect(gesture.phase).toBe('dead');
-  });
-
-  it('does not come back when the finger returns to where it started', () => {
-    const {paints} = run([
-      down(),
-      {kind: 'onset'},
-      move(100, 200),
-      move(100, 100),
-    ]);
-    expect(paints.at(-1)).toBe('none');
-  });
-
-  it('does not paint on the release either', () => {
-    const {paints} = run([
-      down(),
-      {kind: 'onset'},
-      {kind: 'cancel'},
-      {kind: 'up'},
-    ]);
-    expect(paints.at(-1)).toBe('none');
-  });
-
-  it('does not paint if the onset timer fires late, after the scroll took the gesture', () => {
-    // iOS throttles frame callbacks during a scroll and a queued timer can
-    // land after the cancel; the phase, not the timer, decides.
-    const {paints} = run([down(), {kind: 'cancel'}, {kind: 'onset'}]);
-    expect(paints).toEqual(['none', 'none', 'none']);
-  });
-
-  it('only a new touch revives it', () => {
-    const {paints, gesture} = run([
-      down(),
-      {kind: 'cancel'},
-      down(120, 300),
-      {kind: 'onset'},
-    ]);
-    expect(paints.at(-1)).toBe('on');
-    expect(gesture.phase).toBe('pressed');
-  });
-
-  it('ends when the finger lifts, so the NEXT press is heard', () => {
-    // The gesture holds the controller's one tracking slot until it resolves.
-    // A `dead` gesture that never resolved is how every press after the first
-    // scroll would answer with nothing.
-    const {gesture} = run([
-      down(),
-      {kind: 'onset'},
-      move(100, 300),
-      {kind: 'up'},
-    ]);
-    expect(gesture.phase).toBe('idle');
-  });
-});
-
-describe('a press after a scroll', () => {
-  it('paints, the way the first one did', () => {
-    const {paints, gesture} = run([
-      down(),
-      {kind: 'onset'},
-      move(100, 400),
-      {kind: 'up'},
-      down(100, 420),
-      {kind: 'onset'},
-    ]);
-    expect(paints.at(-1)).toBe('on');
-    expect(gesture.phase).toBe('pressed');
-  });
-});
-
-describe('the paint does not survive its gesture', () => {
-  it('leaves nothing painted once a cancelled gesture is over', () => {
-    const {paints, gesture} = run([
-      down(),
-      {kind: 'onset'},
-      {kind: 'cancel'},
-      {kind: 'up'},
-    ]);
-    expect(paints.at(-1)).toBe('none');
-    expect(gesture.phase).toBe('idle');
-  });
-});
-
-describe('a tap too quick for the delay still answers', () => {
-  it('paints at the release and holds it at full strength', () => {
-    const {paints, gesture} = run([down(), {kind: 'up'}]);
-    expect(paints).toEqual(['none', 'on']);
-    expect(gesture.phase).toBe('flash');
-  });
-
-  it('arms the flash hold, then hands over to the same fade a long press gets', () => {
-    const armed = pressGestureStep(idlePressGesture(), down()).gesture;
-    const flash = pressGestureStep(armed, {kind: 'up'});
-    expect(flash.timer).toBe('flash');
-    const fading = pressGestureStep(flash.gesture, {kind: 'flashEnd'});
-    expect(fading.paint).toBe('fading');
-    expect(fading.timer).toBe('fade');
-  });
-
-  it('is not clipped by the cancel iOS sends after the tap', () => {
-    // iOS Safari delivers `touchcancel` at `scrollend`, up to seconds after a
-    // tap. It must not cut the answer the tap earned.
-    const {paints} = run([down(), {kind: 'up'}, {kind: 'cancel'}]);
-    expect(paints.at(-1)).toBe('on');
-  });
-});
-
-describe('the release fades', () => {
-  it('fades from a held press and ends idle', () => {
-    const {paints, gesture} = run([
-      down(),
-      {kind: 'onset'},
-      {kind: 'up'},
-      {kind: 'fadeEnd'},
-    ]);
-    expect(paints).toEqual(['none', 'on', 'fading', 'none']);
-    expect(gesture.phase).toBe('idle');
-  });
-
-  it('asks for the fade timer so the state cannot be left behind', () => {
-    const armed = pressGestureStep(idlePressGesture(), down()).gesture;
-    const pressed = pressGestureStep(armed, {kind: 'onset'}).gesture;
-    expect(pressGestureStep(pressed, {kind: 'up'}).timer).toBe('fade');
-  });
-});
-
-describe('on a touch-first device, a mouse button or the Space key presses at once', () => {
-  // The stylesheet drops `:active` by the PRIMARY pointer, so on a phone or
-  // a tablet a trackpad click or a Space press has nothing else to paint it.
-  // Nothing can turn either into a scroll, so nothing waits.
-  const buttonDown: PressEvent = {kind: 'buttonDown'};
-
-  it('paints on the press itself and arms no timer', () => {
-    const step = pressGestureStep(idlePressGesture(), buttonDown);
-    expect(step.paint).toBe('on');
-    expect(step.timer).toBeNull();
-    expect(step.gesture.phase).toBe('buttonHeld');
-  });
-
-  it('keeps the paint through any travel, as a held mouse keeps `:active`', () => {
-    const {paints, gesture} = run([
-      buttonDown,
-      move(100 + PRESS_SLOP_PX * 10, 100),
-      move(-500, -500),
-      {kind: 'onset'},
-    ]);
-    expect(paints).toEqual(['on', 'on', 'on', 'on']);
-    expect(gesture.phase).toBe('buttonHeld');
-  });
-
-  it("fades at the release with a finger's fade, and ends idle", () => {
-    const held = pressGestureStep(idlePressGesture(), buttonDown).gesture;
-    const release = pressGestureStep(held, {kind: 'up'});
-    expect(release.paint).toBe('fading');
-    expect(release.timer).toBe('fade');
-    const {paints, gesture} = run([
-      buttonDown,
-      {kind: 'up'},
-      {kind: 'fadeEnd'},
-    ]);
-    expect(paints).toEqual(['on', 'fading', 'none']);
-    expect(gesture.phase).toBe('idle');
-  });
-
-  it('drops the paint at once when the platform takes the press away', () => {
-    const {paints, gesture} = run([buttonDown, {kind: 'cancel'}]);
-    expect(paints).toEqual(['on', 'none']);
-    expect(gesture.phase).toBe('dead');
-  });
-
-  it('takes over a surface whose last press is still fading', () => {
-    const {paints} = run([buttonDown, {kind: 'up'}, buttonDown]);
-    expect(paints).toEqual(['on', 'fading', 'on']);
-  });
-});

package/src/utils/pressPaintSource.test.ts

@@ -1,65 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file pressPaintSource.test.ts
- * @input The core source tree
- * @output Fails when the touch press's paint formula is written anywhere but
- *   interactionOverlay.stylex.ts
- * @position Guards the one-source rule for the press paint: a copied
- *   `color-mix` across files is where a component quietly stops responding to
- *   the theme while the rest keep working. Components paint
- *   `var(--_press-paint)` / `var(--_press-paint-image)` instead.
- */
-
-import {readdirSync, readFileSync, statSync} from 'node:fs';
-import {join, relative} from 'node:path';
-import {describe, expect, it} from 'vitest';
-
-const SRC = join(__dirname, '..');
-const ONE_SOURCE = 'utils/interactionOverlay.stylex.ts';
-/**
- * The formula's shape: the pressed token mixed at a computed strength, as
- * StyleX source (`${colorVars['--color-overlay-pressed']}`) or as plain CSS.
- */
-const FORMULA =
-  /color-mix\(in srgb,\s*(?:\$\{colorVars\['--color-overlay-pressed'\]\}|var\(--color-overlay-pressed\))\s*calc\(/;
-
-function* sourceFiles(dir: string): Generator<string> {
-  for (const entry of readdirSync(dir)) {
-    const path = join(dir, entry);
-    if (statSync(path).isDirectory()) {
-      if (entry === 'node_modules' || entry === 'dist') {
-        continue;
-      }
-      yield* sourceFiles(path);
-    } else if (
-      /\.(ts|tsx|mjs)$/.test(entry) &&
-      !/\.test\.(ts|tsx|mjs)$/.test(entry)
-    ) {
-      yield path;
-    }
-  }
-}
-
-describe('the touch press paint has one source', () => {
-  it('writes the pressed-token-at-strength formula in interactionOverlay.stylex.ts and nowhere else', () => {
-    const offenders: string[] = [];
-    let declaredInSource = 0;
-    for (const file of sourceFiles(SRC)) {
-      const text = readFileSync(file, 'utf8');
-      const rel = relative(SRC, file).split('\\').join('/');
-      // Doc comments describe the formula in words; only code counts.
-      const code = text
-        .replace(/\/\*[\s\S]*?\*\//g, '')
-        .replace(/^\s*\/\/.*$/gm, '');
-      const hits = code.match(new RegExp(FORMULA.source, 'g')) ?? [];
-      if (rel === ONE_SOURCE) {
-        declaredInSource = hits.length;
-      } else if (hits.length > 0) {
-        offenders.push(`${rel} (${hits.length})`);
-      }
-    }
-    expect(declaredInSource).toBe(1);
-    expect(offenders).toEqual([]);
-  });
-});

package/src/utils/pressableCoverage.test.ts

@@ -1,192 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file pressableCoverage.test.ts
- * @input Every non-test source file under packages/core/src
- * @output A guard that every file which paints a press is reachable by the
- *   touch press controller
- * @position Testing; the structural half of the touch press model's contract
- *
- * The touch press controller (utils/pressFeedback.ts) can only paint what
- * carries `data-astryx-pressable`, and under a coarse pointer the `:active`
- * arm is dropped, so a surface that paints a press without the marker would
- * press on a mouse and stay dead under a finger. This test enumerates the
- * pressable set from the source itself — never from a hand-kept list — and
- * holds it equal to the marked set:
- *
- *  - A file paints a press when its StyleX carries an `':active` key, a
- *    `[data-astryx-press` arm, or composes `interactionOverlayStyles`.
- *  - A file is marked when it calls `usePressFeedback(`.
- *  - A file whose press arms are read off an ancestor scope marker
- *    (`stylex.when.ancestor(':active', someScope)`, the way an indicator
- *    reads its owner row) is covered when every file that applies that scope
- *    marker is marked, since the controller writes `data-astryx-press` on the
- *    element carrying the scope.
- *  - A styles-only module (`*.stylex.ts`) is covered when every file that
- *    imports it is marked.
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import {describe, expect, it} from 'vitest';
-
-const SRC = path.resolve(__dirname, '..');
-
-/** The utility and the controller define the model; they are not surfaces. */
-const MODEL_FILES = new Set([
-  'utils/interactionOverlay.stylex.ts',
-  'utils/pressFeedback.ts',
-  'utils/pressGesture.ts',
-]);
-
-function walk(dir: string, out: string[] = []): string[] {
-  for (const entry of fs.readdirSync(dir, {withFileTypes: true})) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name === '__tests__') {
-        continue;
-      }
-      walk(full, out);
-    } else if (
-      /\.(ts|tsx)$/.test(entry.name) &&
-      !/\.(test|stories|spec)\./.test(entry.name) &&
-      !entry.name.endsWith('.d.ts')
-    ) {
-      out.push(full);
-    }
-  }
-  return out;
-}
-
-const files = walk(SRC);
-const source = new Map(
-  files.map(file => [path.relative(SRC, file), fs.readFileSync(file, 'utf8')]),
-);
-
-const PRESS_ARM = /':active|'\[data-astryx-press=|interactionOverlayStyles\./;
-const ANCESTOR_ARM =
-  /stylex\.when\.ancestor\(\s*'(?::active|\[data-astryx-press=[^)]*)',\s*(\w+)\s*\)/g;
-
-function isMarked(file: string): boolean {
-  return (source.get(file) ?? '').includes('usePressFeedback(');
-}
-
-/** Files (other than `except`) that apply the scope marker `name` to an element. */
-function referrers(name: string, except: string): string[] {
-  const pattern = new RegExp(`\\b${name}\\b`);
-  return [...source.entries()]
-    .filter(([file, text]) => {
-      if (file === except || file.endsWith('.markers.stylex.ts')) {
-        return false;
-      }
-      // Mentioning the marker is not applying it: a reader names it inside
-      // `stylex.when.*()`, an index re-exports it, a doc comment describes it.
-      const applied = text
-        .replace(/\/\*[\s\S]*?\*\//g, '')
-        .replace(/^\s*\/\/.*$/gm, '')
-        .replace(/import[\s\S]*?from\s+'[^']+';/g, '')
-        .replace(/export\s*(?:type\s*)?\{[\s\S]*?\}\s*from\s+'[^']+';/g, '')
-        .replace(/stylex\.when\.\w+\([^)]*\)/g, '');
-      return pattern.test(applied);
-    })
-    .map(([file]) => file);
-}
-
-/** Files that import the module at `file` (by its relative specifier). */
-function importers(file: string): string[] {
-  const stem = file.replace(/\.tsx?$/, '');
-  return [...source.entries()]
-    .filter(([other, text]) => {
-      if (other === file) {
-        return false;
-      }
-      const dir = path.dirname(other);
-      const specifiers = [...text.matchAll(/from\s+'([^']+)'/g)].map(m =>
-        path.normalize(path.join(dir, m[1])),
-      );
-      return specifiers.includes(stem);
-    })
-    .map(([other]) => other);
-}
-
-const pressArmFiles = [...source.entries()]
-  .filter(([file, text]) => !MODEL_FILES.has(file) && PRESS_ARM.test(text))
-  .map(([file]) => file)
-  .sort();
-
-describe('every surface that paints a press is reachable by the touch press controller', () => {
-  it('finds the pressable set from the source (a sanity floor, not a list)', () => {
-    // Button, Item, the eight components of the first press PR and the ~20
-    // composers of the overlay utility: well above this floor, and a regex
-    // that stopped matching would fall below it.
-    expect(pressArmFiles.length).toBeGreaterThan(25);
-  });
-
-  it.each(pressArmFiles)(
-    '%s carries the marker, or its scope owners do',
-    file => {
-      const text = source.get(file) ?? '';
-      if (isMarked(file)) {
-        return;
-      }
-
-      const problems: string[] = [];
-
-      if (file.endsWith('.stylex.ts')) {
-        // A styles-only module: its arms land on whichever component composes
-        // it, so each importer must be a marked surface.
-        const users = importers(file);
-        expect(users, `${file} is imported by nobody`).not.toHaveLength(0);
-        for (const user of users) {
-          if (!isMarked(user)) {
-            problems.push(`${user} composes ${file} unmarked`);
-          }
-        }
-      } else {
-        // A component whose arms read an ancestor scope marker: the owners that
-        // apply the marker are the pressables, and each must be marked.
-        const scopes = [...text.matchAll(ANCESTOR_ARM)].map(m => m[1]);
-        expect(
-          scopes,
-          `${file} paints a press without usePressFeedback() and without an ancestor scope`,
-        ).not.toHaveLength(0);
-        for (const scope of new Set(scopes)) {
-          const owners = referrers(scope, file);
-          expect(owners, `${scope} is applied by nobody`).not.toHaveLength(0);
-          for (const owner of owners) {
-            if (!isMarked(owner)) {
-              problems.push(`${owner} applies ${scope} unmarked`);
-            }
-          }
-        }
-      }
-
-      expect(problems).toEqual([]);
-    },
-  );
-
-  it('marks nothing that does not paint a press', () => {
-    // The converse: a marker with no arm would ask the controller to write an
-    // attribute nothing reads. Every marked file must paint a press itself or
-    // apply a scope an indicator reads.
-    const marked = [...source.entries()]
-      .filter(([, text]) => text.includes('usePressFeedback('))
-      .map(([file]) => file)
-      .filter(file => file !== 'hooks/usePressFeedback.ts');
-    const scopeNames = new Set(
-      [...source.values()].flatMap(text =>
-        [...text.matchAll(ANCESTOR_ARM)].map(m => m[1]),
-      ),
-    );
-    const unexplained = marked.filter(file => {
-      const text = source.get(file) ?? '';
-      if (PRESS_ARM.test(text)) {
-        return false;
-      }
-      return ![...scopeNames].some(scope =>
-        new RegExp(`\\b${scope}\\b`).test(text),
-      );
-    });
-    expect(unexplained).toEqual([]);
-  });
-});

package/src/utils/safeUrl.test.ts

@@ -1,101 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {describe, expect, it} from 'vitest';
-import {isSafeDestination, isSafeUrl, sanitizeUrl} from './safeUrl';
-
-// Expectations come from the navigation contract, not another policy helper.
-const accepted = [
-  'https://example.com/a?b=c#d',
-  'http://example.com',
-  '//example.com/protocol-relative',
-  '/relative/path',
-  'relative/path',
-  '#fragment',
-  'mailto:a@example.com',
-  'tel:+1234567890',
-  'custom:open/document',
-  'data:image/png;base64,iVBORw0KGgo=',
-  'data:text/plain,download',
-  'data: text/plain,download',
-  'mailto: a@example.com',
-];
-const rejected = [
-  'javascript:alert(1)',
-  'JaVaScRiPt:alert(1)',
-  '  javascript:alert(1)',
-  'vbscript:MsgBox(1)',
-  'data:text/html,<script>alert(1)</script>',
-  'DATA:TEXT/HTML;base64,PHNjcmlwdD4=',
-  'java\tscript:alert(1)',
-  'java\nscript:alert(1)',
-  '\x00javascript:alert(1)',
-  'java\x7fscript:alert(1)',
-  // A data URL's media type ignores the spaces before it.
-  'data: text/html,<script>alert(1)</script>',
-  'data:   text/html,<script>alert(1)</script>',
-  'DATA: TEXT/HTML;base64,PHNjcmlwdD4=',
-  '  data: text/html,x',
-  'data:\t text/html,x',
-  'data: \ttext/html,x',
-  'data:\x00 text/html,x',
-  'data: \x7ftext/html,x',
-  'javascript: alert(1)',
-  'vbscript: MsgBox(1)',
-];
-
-describe('navigation strings', () => {
-  it.each(accepted)('accepts %s', url => {
-    expect(isSafeUrl(url)).toBe(true);
-    expect(isSafeDestination(url)).toBe(true);
-    expect(sanitizeUrl(url)).toBe(url);
-  });
-  it.each(rejected)('rejects %s', url => {
-    expect(isSafeUrl(url)).toBe(false);
-    expect(isSafeDestination(url)).toBe(false);
-    expect(sanitizeUrl(url)).toBeNull();
-  });
-  it('normalizes accepted strings only when requested', () => {
-    expect(sanitizeUrl('  /docs\n')).toBe('/docs');
-    expect(sanitizeUrl('/do\x00cs')).toBe('/docs');
-  });
-});
-
-describe('structured destinations', () => {
-  it.each([
-    {pathname: '/docs', search: '?q=1', hash: '#a'},
-    {href: 'https://example.com'},
-    {protocol: 'https:', hostname: 'example.com', pathname: '/docs'},
-    {protocol: 'custom', pathname: 'document'},
-    {protocol: 'mailto:', pathname: 'a@example.com'},
-    {protocol: 'data:', pathname: 'image/png;base64,aA=='},
-    {search: '?page=2'},
-    {hash: '#section'},
-    {},
-    new URL('https://example.com/docs'),
-    undefined,
-    null,
-  ])('accepts supported destination %j', destination => {
-    expect(isSafeDestination(destination)).toBe(true);
-  });
-  it.each([
-    {pathname: 'javascript:alert(1)'},
-    {pathname: 'java\x00script:alert(1)'},
-    {href: 'vbscript:MsgBox(1)'},
-    {pathname: '/ok', href: 'javascript:1'},
-    {protocol: 'javascript:', pathname: 'alert(1)'},
-    {protocol: 'javascript', pathname: 'alert(1)'},
-    {protocol: ' JaVa\tsCrIpT ', pathname: 'alert(1)'},
-    {protocol: 'vbscript', pathname: 'MsgBox(1)'},
-    {protocol: 'data:', pathname: 'text/html,<b>x</b>'},
-    {protocol: 'data', pathname: 'TEXT/HTML;base64,PGI+eDwvYj4='},
-    {protocol: 'data:', host: 'text/', pathname: 'html,<b>x</b>'},
-    {protocol: 'data:', hostname: 'text/html,<b>x</b>'},
-    {href: '/safe', protocol: 'javascript:'},
-    new URL('javascript:alert(1)'),
-    {pathname: 42},
-    {protocol: {toString: (): string => 'javascript:'}},
-    3,
-  ])('rejects blocked or unsupported destination %j', destination => {
-    expect(isSafeDestination(destination)).toBe(false);
-  });
-});