gbs-add-block 2.1.0 → 2.3.0

package/source/beta-components/number-input/__tests__/core.test.ts

@@ -1,151 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatNumber } from "../core/format";
-import { localeParts, parseNumber, toEditText } from "../core/parse";
-import { clamp, decimalsOf, round, snapToStep, stepBy } from "../core/step";
-
-describe("localeParts", () => {
-  it("reads each locale's notation out of Intl", () => {
-    expect(localeParts("en-US")).toMatchObject({ group: ",", decimal: "." });
-    expect(localeParts("de-DE")).toMatchObject({ group: ".", decimal: "," });
-    expect(localeParts("fr-FR")).toMatchObject({ decimal: "," });
-    expect(localeParts("ar-EG").digits[0]).toBe("٠");
-  });
-});
-
-describe("parseNumber", () => {
-  it("reads the locale's own notation", () => {
-    expect(parseNumber("1,234.56", "en-US")).toBe(1234.56);
-    expect(parseNumber("1.234,56", "de-DE")).toBe(1234.56);
-    // The separator here is a narrow no-break space, not one anybody types.
-    expect(parseNumber("1 234,56", "fr-FR")).toBe(1234.56);
-  });
-
-  it("reads the locale's digits", () => {
-    expect(parseNumber("١٢٣", "ar-EG")).toBe(123);
-  });
-
-  it("ignores currency symbols, percent signs and spare spaces", () => {
-    expect(parseNumber("$1,234.56", "en-US")).toBe(1234.56);
-    expect(parseNumber("45 %", "en-US")).toBe(45);
-    expect(parseNumber("  12  ", "en-US")).toBe(12);
-  });
-
-  it("reads negatives, including the typographic minus", () => {
-    expect(parseNumber("-42", "en-US")).toBe(-42);
-    expect(parseNumber("−42", "en-US")).toBe(-42);
-    expect(parseNumber("-1.234,5", "de-DE")).toBe(-1234.5);
-  });
-
-  it("refuses what is not a number, and keeps that apart from empty", () => {
-    expect(parseNumber("", "en-US")).toBeNull();
-    expect(parseNumber("abc", "en-US")).toBeNull();
-    expect(parseNumber("1.2.3", "en-US")).toBeNull();
-    expect(parseNumber(".", "en-US")).toBeNull();
-    expect(parseNumber("-", "en-US")).toBeNull();
-  });
-
-  it("does not mistake one locale's group separator for another's decimal", () => {
-    // The whole point: the same five characters, two different numbers.
-    expect(parseNumber("1.234", "en-US")).toBe(1.234);
-    expect(parseNumber("1.234", "de-DE")).toBe(1234);
-  });
-});
-
-describe("toEditText", () => {
-  it("gives the plain form, in the locale's decimal separator", () => {
-    expect(toEditText(1234.5, "en-US")).toBe("1234.5");
-    expect(toEditText(1234.5, "de-DE")).toBe("1234,5");
-    expect(toEditText(null, "en-US")).toBe("");
-  });
-
-  it("round-trips through parseNumber", () => {
-    for (const locale of ["en-US", "de-DE", "fr-FR"]) {
-      expect(parseNumber(toEditText(-1234.56, locale), locale)).toBe(-1234.56);
-    }
-  });
-});
-
-describe("formatNumber", () => {
-  it("groups, and respects a fixed number of decimals", () => {
-    expect(formatNumber(1234.5, { locale: "en-US", decimals: 2 })).toBe("1,234.50");
-    expect(formatNumber(1234.5, { locale: "en-US", useGrouping: false })).toBe("1234.5");
-  });
-
-  it("formats money and percentages", () => {
-    expect(formatNumber(1234.5, { locale: "en-US", style: "currency", currency: "USD" })).toBe("$1,234.50");
-    expect(formatNumber(0.45, { locale: "en-US", style: "percent" })).toBe("45%");
-  });
-
-  it("falls back to a plain number when a currency is asked for without a code", () => {
-    // Intl throws on style:"currency" with no currency; a field mid-configuration
-    // should not take the page down with it.
-    expect(formatNumber(12, { locale: "en-US", style: "currency" })).toBe("12");
-  });
-
-  it("has nothing to show for no value", () => {
-    expect(formatNumber(null, { locale: "en-US" })).toBe("");
-  });
-});
-
-describe("decimalsOf and round", () => {
-  it("counts fraction digits, including exponent notation", () => {
-    expect(decimalsOf(1)).toBe(0);
-    expect(decimalsOf(0.25)).toBe(2);
-    expect(decimalsOf(1e-7)).toBe(7);
-  });
-
-  it("rounds the way the number reads, not the way the float sits", () => {
-    expect(round(1.005, 2)).toBe(1.01);
-    expect(round(2.675, 2)).toBe(2.68);
-    expect(round(-1.005, 2)).toBe(-1.01);
-  });
-});
-
-describe("stepBy", () => {
-  it("adds a step without floating-point drift", () => {
-    expect(stepBy(0.1, 1, { step: 0.2 })).toBe(0.3);
-    expect(stepBy(0.3, -1, { step: 0.1 })).toBe(0.2);
-    expect(stepBy(1.1, 1, { step: 0.1 })).toBe(1.2);
-  });
-
-  it("starts an empty field at min, or one step from zero", () => {
-    expect(stepBy(null, 1, { step: 1 })).toBe(1);
-    expect(stepBy(null, -1, { step: 1 })).toBe(-1);
-    expect(stepBy(null, 1, { step: 1, min: 5 })).toBe(5);
-    expect(stepBy(null, -1, { step: 1, min: 5 })).toBe(5);
-  });
-
-  it("stops at the limits", () => {
-    expect(stepBy(9, 1, { step: 5, max: 10 })).toBe(10);
-    expect(stepBy(1, -1, { step: 5, min: 0 })).toBe(0);
-  });
-
-  it("treats a step of zero as one, rather than freezing", () => {
-    expect(stepBy(3, 1, { step: 0 })).toBe(4);
-  });
-});
-
-describe("snapToStep", () => {
-  it("counts the grid from min", () => {
-    expect(snapToStep(7, { step: 5, min: 0 })).toBe(5);
-    expect(snapToStep(8, { step: 5, min: 0 })).toBe(10);
-    expect(snapToStep(7, { step: 5, min: 1 })).toBe(6);
-  });
-
-  it("works in fractions", () => {
-    expect(snapToStep(0.27, { step: 0.05, min: 0 })).toBe(0.25);
-  });
-
-  it("stays inside the limits", () => {
-    expect(snapToStep(99, { step: 10, min: 0, max: 95 })).toBe(95);
-  });
-});
-
-describe("clamp", () => {
-  it("pulls a value inside whichever limits exist", () => {
-    expect(clamp(5, 0, 10)).toBe(5);
-    expect(clamp(-1, 0, 10)).toBe(0);
-    expect(clamp(11, 0, 10)).toBe(10);
-    expect(clamp(11, undefined, undefined)).toBe(11);
-  });
-});

package/source/beta-components/progress/__tests__/core.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { describeProgress, stepFraction } from "../core/progress";
-
-describe("describeProgress", () => {
-  it("measures a value against its max", () => {
-    expect(describeProgress(25)).toMatchObject({ fraction: 0.25, percent: 25, value: 25 });
-    expect(describeProgress(3, 8)).toMatchObject({ fraction: 0.375, percent: 38 });
-  });
-
-  it("treats no value as unknown, not as zero", () => {
-    // The difference decides whether a screen reader says "busy" or "0 percent".
-    for (const value of [null, undefined, Number.NaN]) {
-      expect(describeProgress(value)).toEqual({
-        indeterminate: true,
-        value: null,
-        fraction: 0,
-        percent: 0,
-      });
-    }
-  });
-
-  it("clamps into range rather than drawing past the end", () => {
-    expect(describeProgress(140).percent).toBe(100);
-    expect(describeProgress(-20).percent).toBe(0);
-  });
-
-  it("survives a task with nothing in it", () => {
-    // 0 of 0 files: without the guard this is NaN% and an empty bar drawn at
-    // Infinity.
-    const state = describeProgress(0, 0);
-    expect(state.fraction).toBe(0);
-    expect(Number.isNaN(state.percent)).toBe(false);
-  });
-
-  it("keeps the drawn fraction unrounded", () => {
-    // 99.6% must not snap the bar to full while bytes are still moving.
-    const state = describeProgress(99.6);
-    expect(state.percent).toBe(100);
-    expect(state.fraction).toBeCloseTo(0.996);
-  });
-});
-
-describe("stepFraction", () => {
-  it("counts a step as done, not as started", () => {
-    // "Step 2 of 5" is two fifths finished.
-    expect(stepFraction(2, 5)).toBe(0.4);
-    expect(stepFraction(0, 5)).toBe(0);
-    expect(stepFraction(5, 5)).toBe(1);
-  });
-
-  it("stays inside the wizard", () => {
-    expect(stepFraction(9, 5)).toBe(1);
-    expect(stepFraction(-1, 5)).toBe(0);
-    expect(stepFraction(1, 0)).toBe(0);
-  });
-});

package/source/beta-components/radio-group/__tests__/core.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { hasEnabledOption, normalizeOptions, resolveValue } from "../core/group";
-
-describe("normalizeOptions", () => {
-  it("turns plain strings into options labelled with themselves", () => {
-    expect(normalizeOptions(["daily", "weekly"])).toEqual([
-      { value: "daily", label: "daily" },
-      { value: "weekly", label: "weekly" },
-    ]);
-  });
-
-  it("leaves full options as they are, mixed in with strings", () => {
-    const options = normalizeOptions([
-      "daily",
-      { value: "weekly", label: "Every week", description: "On Mondays", disabled: true },
-    ]);
-    expect(options[1]).toEqual({
-      value: "weekly",
-      label: "Every week",
-      description: "On Mondays",
-      disabled: true,
-    });
-  });
-});
-
-describe("resolveValue", () => {
-  const options = normalizeOptions([
-    "email",
-    { value: "sms", label: "SMS", disabled: true },
-  ]);
-
-  it("selects the matching option", () => {
-    expect(resolveValue(options, "email")).toBe("email");
-  });
-
-  it("selects a disabled option, because a locked-in choice still has to show", () => {
-    expect(resolveValue(options, "sms")).toBe("sms");
-  });
-
-  it("selects nothing for a value the group does not offer", () => {
-    // A stale value from a record: picking some other option instead would
-    // claim a choice that was never made.
-    expect(resolveValue(options, "pigeon")).toBeNull();
-  });
-
-  it("selects nothing for no value at all", () => {
-    expect(resolveValue(options, null)).toBeNull();
-    expect(resolveValue(options, undefined)).toBeNull();
-  });
-});
-
-describe("hasEnabledOption", () => {
-  const options = normalizeOptions(["email", { value: "sms", label: "SMS", disabled: true }]);
-
-  it("is true while something can still be chosen", () => {
-    expect(hasEnabledOption(options, false)).toBe(true);
-  });
-
-  it("is false when the group is disabled or has nothing to offer", () => {
-    expect(hasEnabledOption(options, true)).toBe(false);
-    expect(hasEnabledOption(normalizeOptions([{ value: "sms", label: "SMS", disabled: true }]), false)).toBe(false);
-    expect(hasEnabledOption([], false)).toBe(false);
-  });
-});

package/source/beta-components/shared/__tests__/boundaries.test.ts

@@ -1,95 +0,0 @@
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { join, relative, resolve, sep } from "node:path";
-import { describe, expect, it } from "vitest";
-
-/*
- * The rules that keep the library installable.
- *
- * Components are copied into a project one folder at a time, so a component
- * that reaches into a sibling folder breaks as soon as someone installs it on
- * its own. `shared/` is the single exception: the installer copies it with
- * every install. These tests fail the moment a new import would break that.
- */
-
-const LIB = resolve(import.meta.dirname, "..", "..");
-const SHARED = "shared";
-
-/** Bare specifiers a component may import. The library ships no dependencies. */
-const ALLOWED_PACKAGES = new Set(["react", "react-dom", "react-dom/client", "vitest"]);
-
-function packages(): string[] {
-  return readdirSync(LIB)
-    .filter((name) => statSync(join(LIB, name)).isDirectory())
-    .sort();
-}
-
-function sourceFiles(dir: string): string[] {
-  return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
-    const path = join(dir, entry.name);
-    if (entry.isDirectory()) return sourceFiles(path);
-    return /\.tsx?$/.test(entry.name) ? [path] : [];
-  });
-}
-
-/** Every `from "…"` specifier in a file, with `import()` and `export … from` included. */
-function specifiers(file: string): string[] {
-  return [...readFileSync(file, "utf8").matchAll(/from\s+"([^"]+)"|import\("([^"]+)"\)/g)].map(
-    (match) => match[1] ?? match[2],
-  );
-}
-
-/** Which package a relative import lands in, or null when it leaves the library. */
-function targetPackage(file: string, specifier: string): string | null {
-  const target = resolve(file, "..", specifier);
-  const rel = relative(LIB, target);
-  if (rel.startsWith("..")) return null;
-  return rel.split(sep)[0];
-}
-
-describe.each(packages().filter((name) => name !== SHARED))("%s", (pkg) => {
-  const files = sourceFiles(join(LIB, pkg));
-
-  it("imports nothing from another component", () => {
-    const offenders = files.flatMap((file) =>
-      specifiers(file)
-        .filter((specifier) => specifier.startsWith("."))
-        .map((specifier) => ({ file: relative(LIB, file), specifier, to: targetPackage(file, specifier) }))
-        .filter((entry) => entry.to !== pkg && entry.to !== SHARED),
-    );
-    expect(offenders).toEqual([]);
-  });
-
-  it("imports no third-party package", () => {
-    const offenders = files.flatMap((file) =>
-      specifiers(file)
-        .filter((specifier) => !specifier.startsWith(".") && !ALLOWED_PACKAGES.has(specifier))
-        .map((specifier) => `${relative(LIB, file)} -> ${specifier}`),
-    );
-    expect(offenders).toEqual([]);
-  });
-});
-
-describe("shared", () => {
-  it("never imports a component, so it can be installed on its own", () => {
-    const offenders = sourceFiles(join(LIB, SHARED)).flatMap((file) =>
-      specifiers(file)
-        .filter((specifier) => specifier.startsWith("."))
-        .map((specifier) => ({ file: relative(LIB, file), to: targetPackage(file, specifier) }))
-        .filter((entry) => entry.to !== SHARED),
-    );
-    expect(offenders).toEqual([]);
-  });
-
-  it("is reached only as ../../shared, the path the installer guarantees", () => {
-    const offenders = packages()
-      .filter((name) => name !== SHARED)
-      .flatMap((pkg) => sourceFiles(join(LIB, pkg)))
-      .flatMap((file) =>
-        specifiers(file)
-          .filter((specifier) => specifier.includes(SHARED))
-          .filter((specifier) => !specifier.startsWith("../../shared/"))
-          .map((specifier) => `${relative(LIB, file)} -> ${specifier}`),
-      );
-    expect(offenders).toEqual([]);
-  });
-});

package/source/beta-components/shared/__tests__/core.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { cx } from "../core/cx";
-import { describeField } from "../core/field";
-import { countCharacters } from "../core/text";
-import { version } from "../version";
-import manifest from "../version.json";
-
-describe("cx", () => {
-  it("joins the truthy names", () => {
-    expect(cx("a", "b")).toBe("a b");
-  });
-
-  it("drops undefined, null and false, so an unset className adds nothing", () => {
-    expect(cx("a", undefined, null, false, "b")).toBe("a b");
-    expect(cx(undefined, false)).toBe("");
-  });
-});
-
-describe("countCharacters", () => {
-  it("counts what a person would call a character", () => {
-    expect(countCharacters("abc")).toBe(3);
-    // Four UTF-16 units, one character.
-    expect(countCharacters("👍🏽")).toBe(1);
-    // A base letter plus a combining accent.
-    expect(countCharacters("e\u0301")).toBe(1);
-  });
-
-  it("is 0 for an empty string", () => {
-    expect(countCharacters("")).toBe(0);
-  });
-});
-
-describe("describeField", () => {
-  it("is undefined when nothing describes the control", () => {
-    expect(describeField("f", {})).toBeUndefined();
-    expect(describeField("f", { description: "", error: null })).toBeUndefined();
-  });
-
-  it("reads the caller's own ids first and the error last", () => {
-    expect(
-      describeField("f", { extra: "outside", hint: "h", description: "d", error: "e" }),
-    ).toBe("outside f-hint f-description f-error");
-  });
-
-  it("includes only the parts that are rendered", () => {
-    expect(describeField("f", { error: "Required" })).toBe("f-error");
-    expect(describeField("f", { description: "Help" })).toBe("f-description");
-  });
-});
-
-describe("version", () => {
-  it("matches the manifest the installer reads", () => {
-    expect(manifest.version).toBe(version);
-  });
-});

package/source/beta-components/shared/__tests__/position.test.ts

@@ -1,143 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { placePopover, type AnchorRect, type PlacementOptions } from "../core/position";
-
-const VIEWPORT = { width: 1000, height: 800 };
-
-const anchorAt = (left: number, top: number, width = 120, height = 32): AnchorRect => ({
-  left,
-  top,
-  width,
-  height,
-  right: left + width,
-  bottom: top + height,
-});
-
-const options = (overrides: Partial<PlacementOptions> = {}): PlacementOptions => ({
-  side: "bottom",
-  align: "start",
-  gap: 4,
-  edge: 8,
-  rtl: false,
-  fitHeight: false,
-  minHeight: 140,
-  ...overrides,
-});
-
-describe("below the anchor", () => {
-  it("sits under the anchor, aligned to its left edge", () => {
-    const placement = placePopover(anchorAt(100, 100), { width: 200, height: 150 }, VIEWPORT, options());
-    expect(placement).toMatchObject({ side: "bottom", left: 100, top: 136 });
-  });
-
-  it("aligns to the right edge when asked", () => {
-    const placement = placePopover(
-      anchorAt(100, 100),
-      { width: 200, height: 150 },
-      VIEWPORT,
-      options({ align: "end" }),
-    );
-    // The anchor's right edge is 220, so a 200-wide panel starts at 20.
-    expect(placement.left).toBe(20);
-  });
-
-  it("moves above when there is no room below and it fits above", () => {
-    const placement = placePopover(anchorAt(100, 700), { width: 200, height: 150 }, VIEWPORT, options());
-    expect(placement).toMatchObject({ side: "top", top: 546 });
-  });
-
-  it("stays below when it fits neither side, rather than running off the top", () => {
-    const placement = placePopover(anchorAt(100, 300), { width: 200, height: 780 }, VIEWPORT, options());
-    expect(placement.side).toBe("bottom");
-  });
-});
-
-describe("fitHeight", () => {
-  it("takes the roomier side and caps the height to it", () => {
-    // 700px from the top: 68px below, 688px above.
-    const placement = placePopover(
-      anchorAt(100, 700),
-      { width: 200, height: 600 },
-      VIEWPORT,
-      options({ fitHeight: true }),
-    );
-    expect(placement.side).toBe("top");
-    expect(placement.maxHeight).toBe(688);
-  });
-
-  it("never caps below minHeight, however cramped the viewport", () => {
-    const placement = placePopover(
-      anchorAt(100, 380),
-      { width: 200, height: 300 },
-      { width: 1000, height: 420 },
-      options({ fitHeight: true, minHeight: 140 }),
-    );
-    expect(placement.maxHeight).toBeGreaterThanOrEqual(140);
-  });
-});
-
-describe("staying on screen", () => {
-  it("pulls a panel back from the right edge", () => {
-    const placement = placePopover(anchorAt(950, 100), { width: 300, height: 100 }, VIEWPORT, options());
-    expect(placement.left).toBe(1000 - 300 - 8);
-  });
-
-  it("keeps the left gutter when the panel is wider than the viewport", () => {
-    const placement = placePopover(anchorAt(10, 100), { width: 1200, height: 100 }, VIEWPORT, options());
-    expect(placement.left).toBe(8);
-  });
-});
-
-describe("sideways", () => {
-  it("opens to the right of the anchor, top edges level", () => {
-    const placement = placePopover(
-      anchorAt(100, 100),
-      { width: 200, height: 150 },
-      VIEWPORT,
-      options({ side: "right" }),
-    );
-    expect(placement).toMatchObject({ side: "right", left: 224, top: 100 });
-  });
-
-  it("flips to the left when the right has no room", () => {
-    const placement = placePopover(
-      anchorAt(850, 100),
-      { width: 200, height: 150 },
-      VIEWPORT,
-      options({ side: "right" }),
-    );
-    expect(placement).toMatchObject({ side: "left", left: 646 });
-  });
-
-  it("keeps a tall panel inside the viewport", () => {
-    const placement = placePopover(
-      anchorAt(100, 760),
-      { width: 200, height: 400 },
-      VIEWPORT,
-      options({ side: "right" }),
-    );
-    expect(placement.top).toBe(800 - 400 - 8);
-  });
-});
-
-describe("right to left", () => {
-  it("mirrors which edge `start` means", () => {
-    const placement = placePopover(
-      anchorAt(100, 100),
-      { width: 200, height: 150 },
-      VIEWPORT,
-      options({ rtl: true }),
-    );
-    // Reading starts on the right, so the panel's right edge meets the anchor's.
-    expect(placement.left).toBe(20);
-  });
-
-  it("mirrors left and right", () => {
-    const placement = placePopover(
-      anchorAt(500, 100),
-      { width: 200, height: 150 },
-      VIEWPORT,
-      options({ side: "right", rtl: true }),
-    );
-    expect(placement).toMatchObject({ side: "left", left: 296 });
-  });
-});

package/source/beta-components/skeleton/__tests__/core.test.ts

@@ -1,41 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { lineWidths, toLength } from "../core/lines";
-
-describe("lineWidths", () => {
-  it("draws the last line short, the way a paragraph ends", () => {
-    expect(lineWidths(3)).toEqual(["100%", "100%", "60%"]);
-  });
-
-  it("leaves a single line full width, so it does not read as a label", () => {
-    expect(lineWidths(1)).toEqual(["100%"]);
-  });
-
-  it("takes the width of the last line", () => {
-    expect(lineWidths(2, 40)).toEqual(["100%", "40%"]);
-  });
-
-  it("keeps the last line visible however small it is asked to be", () => {
-    expect(lineWidths(2, 0)).toEqual(["100%", "10%"]);
-    expect(lineWidths(2, 400)).toEqual(["100%", "100%"]);
-  });
-
-  it("is empty for nothing to draw", () => {
-    expect(lineWidths(0)).toEqual([]);
-    expect(lineWidths(-3)).toEqual([]);
-  });
-});
-
-describe("toLength", () => {
-  it("turns a number into pixels", () => {
-    expect(toLength(24)).toBe("24px");
-  });
-
-  it("passes a string through, so any CSS length works", () => {
-    expect(toLength("50%")).toBe("50%");
-    expect(toLength("3rem")).toBe("3rem");
-  });
-
-  it("is undefined when unset, leaving the stylesheet's default", () => {
-    expect(toLength(undefined)).toBeUndefined();
-  });
-});

package/source/beta-components/spinner/__tests__/core.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { spinnerPixels, stepVisibility } from "../core/visibility";
-
-const hidden = { visible: false, loadingSince: null, visibleSince: null };
-
-describe("visibility", () => {
-  it("shows at once without a delay", () => {
-    expect(stepVisibility(true, { ...hidden, loadingSince: 1000 }, 1000)).toEqual({ visible: true, recheckIn: null });
-  });
-
-  it("waits out the delay, then shows", () => {
-    const marks = { ...hidden, loadingSince: 1000 };
-    expect(stepVisibility(true, marks, 1100, { delay: 300 })).toEqual({ visible: false, recheckIn: 200 });
-    expect(stepVisibility(true, marks, 1300, { delay: 300 })).toEqual({ visible: true, recheckIn: null });
-  });
-
-  it("never shows for work that ends within the delay", () => {
-    expect(stepVisibility(false, hidden, 1200, { delay: 300 })).toEqual({ visible: false, recheckIn: null });
-  });
-
-  it("stays for the minimum duration once shown", () => {
-    const shown = { visible: true, loadingSince: null, visibleSince: 2000 };
-    expect(stepVisibility(false, shown, 2100, { minDuration: 500 })).toEqual({ visible: true, recheckIn: 400 });
-    expect(stepVisibility(false, shown, 2500, { minDuration: 500 })).toEqual({ visible: false, recheckIn: null });
-  });
-
-  it("keeps showing while loading continues", () => {
-    const shown = { visible: true, loadingSince: 1000, visibleSince: 1300 };
-    expect(stepVisibility(true, shown, 9000, { delay: 300, minDuration: 500 })).toEqual({
-      visible: true,
-      recheckIn: null,
-    });
-  });
-
-  it("treats negative options as zero", () => {
-    expect(stepVisibility(true, { ...hidden, loadingSince: 0 }, 0, { delay: -50 }).visible).toBe(true);
-  });
-});
-
-describe("size", () => {
-  it("maps names to pixels and passes numbers through", () => {
-    expect(spinnerPixels()).toBe(24);
-    expect(spinnerPixels("xs")).toBe(12);
-    expect(spinnerPixels("xl")).toBe(48);
-    expect(spinnerPixels(20)).toBe(20);
-    expect(spinnerPixels(0)).toBe(1);
-  });
-});