gbs-add-block 2.0.4 → 2.3.0

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

@@ -1,88 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { colorIndex, initials, splitGroup } from "../core/identity";
-
-describe("initials", () => {
-  it("takes the first and last part of a name", () => {
-    expect(initials("Ada Lovelace")).toBe("AL");
-    expect(initials("Ada Byron King Lovelace")).toBe("AL");
-  });
-
-  it("takes one letter from a single name, not two", () => {
-    // "MA" out of "Madonna" reads as a mistake.
-    expect(initials("Madonna")).toBe("M");
-  });
-
-  it("splits on the punctuation that joins parts of a name", () => {
-    expect(initials("jean-luc picard")).toBe("JP");
-    expect(initials("ada.lovelace")).toBe("AL");
-    expect(initials("ada_lovelace")).toBe("AL");
-    expect(initials("Ada Lovelace")).toBe("AL");
-  });
-
-  it("reads an email as the part before the at sign", () => {
-    // Nothing in "example.com" is this person's name.
-    expect(initials("ada@example.com")).toBe("A");
-    expect(initials("ada.lovelace@example.com")).toBe("AL");
-  });
-
-  it("keeps a whole character, not half a surrogate pair", () => {
-    expect(initials("\u{1F680} Launch")).toBe("\u{1F680}L");
-    expect(Array.from(initials("\u{1F680}")).length).toBe(1);
-  });
-
-  it("leaves scripts without letter case alone", () => {
-    // Uppercasing means nothing here, and can change the character.
-    expect(initials("山田 太郎")).toBe("山太");
-  });
-
-  it("does not turn one letter into two", () => {
-    // Uppercase ß is SS, which would be two letters in a one-letter slot.
-    expect(initials("ßrian")).toBe("ß");
-  });
-
-  it("has nothing for nothing", () => {
-    expect(initials("")).toBe("");
-    expect(initials("   ")).toBe("");
-    expect(initials("@example.com")).toBe("");
-  });
-});
-
-describe("colorIndex", () => {
-  it("gives the same person the same colour every time", () => {
-    expect(colorIndex("Ada Lovelace", 8)).toBe(colorIndex("Ada Lovelace", 8));
-  });
-
-  it("stays inside the palette", () => {
-    for (const name of ["", "a", "Ada Lovelace", "\u{1F680}", "x".repeat(500)]) {
-      const index = colorIndex(name, 8);
-      expect(index).toBeGreaterThanOrEqual(0);
-      expect(index).toBeLessThan(8);
-    }
-    expect(colorIndex("Ada", 0)).toBe(0);
-  });
-
-  it("spreads names across the palette rather than piling them up", () => {
-    const names = ["Ada", "Grace", "Alan", "Katherine", "Edsger", "Barbara", "Tim", "Linus"];
-    const used = new Set(names.map((name) => colorIndex(name, 8)));
-    expect(used.size).toBeGreaterThanOrEqual(5);
-  });
-});
-
-describe("splitGroup", () => {
-  const people = ["a", "b", "c", "d", "e"];
-
-  it("shows everyone when they fit", () => {
-    expect(splitGroup(people, 5)).toEqual({ shown: people, overflow: 0 });
-    expect(splitGroup(people, 9).overflow).toBe(0);
-  });
-
-  it("counts the overflow bubble as one of the slots", () => {
-    // Four slots: three faces and a "+2", so the group stays four wide.
-    expect(splitGroup(people, 4)).toEqual({ shown: ["a", "b", "c"], overflow: 2 });
-  });
-
-  it("handles a group with no room for faces", () => {
-    expect(splitGroup(people, 1)).toEqual({ shown: [], overflow: 5 });
-    expect(splitGroup(people, 0)).toEqual({ shown: [], overflow: 5 });
-  });
-});

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

@@ -1,46 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatCount, showCount } from "../core/count";
-
-describe("formatCount", () => {
-  it("prints the number while it fits", () => {
-    expect(formatCount(0)).toEqual({ text: "0" });
-    expect(formatCount(99)).toEqual({ text: "99" });
-  });
-
-  it("caps it, and says aloud what the cap means", () => {
-    // "99+" read out as "ninety-nine plus" is a guess at a number.
-    expect(formatCount(100)).toEqual({ text: "99+", spoken: "more than 99" });
-    expect(formatCount(4821, 999)).toEqual({ text: "999+", spoken: "more than 999" });
-  });
-
-  it("takes a formatter, for grouped or localized numbers", () => {
-    const format = new Intl.NumberFormat("de-DE").format;
-    expect(formatCount(1234, 9999, format).text).toBe("1.234");
-    expect(formatCount(20000, 9999, format)).toEqual({
-      text: "9.999+",
-      spoken: "more than 9.999",
-    });
-  });
-
-  it("drops the fraction of a number that should not have one", () => {
-    expect(formatCount(3.7).text).toBe("3");
-  });
-
-  it("has nothing to print for a number that is not one", () => {
-    expect(formatCount(Number.NaN).text).toBe("");
-    expect(formatCount(Number.POSITIVE_INFINITY).text).toBe("");
-  });
-});
-
-describe("showCount", () => {
-  it("leaves a zero off the page unless it is asked for", () => {
-    expect(showCount(0)).toBe(false);
-    expect(showCount(0, true)).toBe(true);
-    expect(showCount(1)).toBe(true);
-  });
-
-  it("never shows a negative or a non-number", () => {
-    expect(showCount(-1)).toBe(false);
-    expect(showCount(Number.NaN, true)).toBe(false);
-  });
-});

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

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { collapseItems, toBreadcrumbJsonLd } from "../core/trail";
-
-const shape = (slots: ReturnType<typeof collapseItems>) =>
-  slots.map((slot) => (slot.kind === "item" ? slot.index : `…${slot.hidden.join(",")}`));
-
-describe("collapsing", () => {
-  it("leaves a short trail alone", () => {
-    expect(shape(collapseItems(3))).toEqual([0, 1, 2]);
-    expect(shape(collapseItems(4, 4))).toEqual([0, 1, 2, 3]);
-  });
-
-  it("keeps the first and last crumbs around an ellipsis", () => {
-    expect(shape(collapseItems(6, 4))).toEqual([0, "…1,2,3,4", 5]);
-  });
-
-  it("keeps more on either side when asked", () => {
-    expect(shape(collapseItems(7, 4, 1, 2))).toEqual([0, "…1,2,3,4", 5, 6]);
-    expect(shape(collapseItems(7, 4, 2, 2))).toEqual([0, 1, "…2,3,4", 5, 6]);
-    expect(shape(collapseItems(7, 4, 0, 1))).toEqual(["…0,1,2,3,4,5", 6]);
-  });
-
-  it("doesn't collapse when the kept crumbs already cover the trail", () => {
-    expect(shape(collapseItems(4, 2, 2, 2))).toEqual([0, 1, 2, 3]);
-  });
-
-  it("always keeps the current page", () => {
-    expect(shape(collapseItems(5, 2, 1, 0))).toEqual([0, "…1,2,3", 4]);
-  });
-});
-
-describe("structured data", () => {
-  it("builds a schema.org BreadcrumbList with absolute links", () => {
-    const data = toBreadcrumbJsonLd(
-      [
-        { name: "Home", href: "/" },
-        { name: "Invoices", href: "/invoices" },
-        { name: "INV-042" },
-      ],
-      "https://app.example.com/billing/",
-    );
-    expect(data).toEqual({
-      "@context": "https://schema.org",
-      "@type": "BreadcrumbList",
-      itemListElement: [
-        { "@type": "ListItem", position: 1, name: "Home", item: "https://app.example.com/" },
-        { "@type": "ListItem", position: 2, name: "Invoices", item: "https://app.example.com/invoices" },
-        { "@type": "ListItem", position: 3, name: "INV-042" },
-      ],
-    });
-  });
-
-  it("keeps links as given without a base URL", () => {
-    expect(toBreadcrumbJsonLd([{ name: "Docs", href: "https://example.com/docs" }]).itemListElement[0].item).toBe(
-      "https://example.com/docs",
-    );
-  });
-});

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

@@ -1,31 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buttonState, isPromiseLike } from "../core/state";
-
-describe("button state", () => {
-  it("is active by default", () => {
-    expect(buttonState({})).toEqual({ busy: false, inactive: false, nativeDisabled: false });
-  });
-
-  it("stays focusable while busy", () => {
-    expect(buttonState({ loading: true })).toEqual({ busy: true, inactive: true, nativeDisabled: false });
-    expect(buttonState({ pending: true })).toEqual({ busy: true, inactive: true, nativeDisabled: false });
-  });
-
-  it("uses native disabled, and shows no spinner, when disabled", () => {
-    expect(buttonState({ disabled: true, loading: true })).toEqual({
-      busy: false,
-      inactive: true,
-      nativeDisabled: true,
-    });
-  });
-});
-
-describe("promise detection", () => {
-  it("recognizes promises and thenables only", () => {
-    expect(isPromiseLike(Promise.resolve())).toBe(true);
-    expect(isPromiseLike({ then: () => {} })).toBe(true);
-    expect(isPromiseLike(undefined)).toBe(false);
-    expect(isPromiseLike({ then: 1 })).toBe(false);
-    expect(isPromiseLike(() => {})).toBe(false);
-  });
-});

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

@@ -1,57 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isPositive, percentChange, trendDirection } from "../core/trend";
-
-describe("trendDirection", () => {
-  it("reads the sign of the change", () => {
-    expect(trendDirection(4.2)).toBe("up");
-    expect(trendDirection(-0.3)).toBe("down");
-    expect(trendDirection(0)).toBe("flat");
-  });
-
-  it("treats movement under the threshold as flat", () => {
-    expect(trendDirection(0.4, 0.5)).toBe("flat");
-    expect(trendDirection(-0.4, 0.5)).toBe("flat");
-    expect(trendDirection(0.6, 0.5)).toBe("up");
-  });
-
-  it("is flat for a value that is not a number", () => {
-    expect(trendDirection(Number.NaN)).toBe("flat");
-    expect(trendDirection(Number.POSITIVE_INFINITY)).toBe("flat");
-  });
-});
-
-describe("isPositive", () => {
-  it("treats up as good by default", () => {
-    expect(isPositive("up")).toBe(true);
-    expect(isPositive("down")).toBe(false);
-  });
-
-  it("flips for figures where down is the good outcome, such as churn", () => {
-    expect(isPositive("up", true)).toBe(false);
-    expect(isPositive("down", true)).toBe(true);
-  });
-
-  it("is null when nothing moved, so no colour is applied", () => {
-    expect(isPositive("flat")).toBeNull();
-    expect(isPositive("flat", true)).toBeNull();
-  });
-});
-
-describe("percentChange", () => {
-  it("is the change as a share of where it started", () => {
-    expect(percentChange(200, 250)).toBe(25);
-    expect(percentChange(200, 150)).toBe(-25);
-  });
-
-  it("measures against the size of a negative start", () => {
-    expect(percentChange(-200, -150)).toBe(25);
-  });
-
-  it("is null from zero, which has no percentage", () => {
-    expect(percentChange(0, 10)).toBeNull();
-  });
-
-  it("is null for values that are not numbers", () => {
-    expect(percentChange(Number.NaN, 10)).toBeNull();
-  });
-});

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

@@ -1,40 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { groupState, toggleAll, toggleValue } from "../core/group";
-
-const options = [
-  { value: "email" },
-  { value: "sms" },
-  { value: "push", disabled: true },
-];
-
-describe("toggling one value", () => {
-  it("adds and removes without duplicates", () => {
-    expect(toggleValue(["email"], "sms", true)).toEqual(["email", "sms"]);
-    expect(toggleValue(["email"], "email", true)).toEqual(["email"]);
-    expect(toggleValue(["email", "sms"], "email", false)).toEqual(["sms"]);
-    expect(toggleValue([], "email", false)).toEqual([]);
-  });
-});
-
-describe("select all", () => {
-  it("reports none, some or all", () => {
-    expect(groupState([], options)).toBe(false);
-    expect(groupState(["sms"], options)).toBe("indeterminate");
-    expect(groupState(["email", "sms", "push"], options)).toBe(true);
-    expect(groupState(["email"], [])).toBe(false);
-  });
-
-  it("selects every enabled option, leaving disabled ones alone", () => {
-    expect(toggleAll(["sms"], options)).toEqual(["sms", "email"]);
-    expect(toggleAll([], options)).toEqual(["email", "sms"]);
-  });
-
-  it("clears enabled options once they are all selected", () => {
-    expect(toggleAll(["email", "sms"], options)).toEqual([]);
-    expect(toggleAll(["push", "email", "sms"], options)).toEqual(["push"]);
-  });
-
-  it("keeps values that aren't options", () => {
-    expect(toggleAll(["legacy"], options)).toEqual(["legacy", "email", "sms"]);
-  });
-});

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

@@ -1,134 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  buildListItems,
-  filterOptions,
-  findByPrefix,
-  firstEnabledIndex,
-  lastEnabledIndex,
-  matchRanges,
-  nextEnabledIndex,
-  toggleValue,
-} from "../core/filter";
-import type { ComboboxOption } from "../core/types";
-import { getVisibleRange, measureItems, scrollToItem } from "../core/virtual";
-
-const options: ComboboxOption[] = [
-  { value: "in", label: "India", group: "Asia", keywords: ["bharat"] },
-  { value: "jp", label: "Japan", group: "Asia" },
-  { value: "kr", label: "South Korea", group: "Asia", disabled: true },
-  { value: "de", label: "Germany", group: "Europe", description: "Berlin" },
-  { value: "fr", label: "France", group: "Europe" },
-];
-
-const labels = (list: { option: ComboboxOption }[]) => list.map((entry) => entry.option.label);
-
-describe("matching", () => {
-  it("returns merged, case-insensitive ranges for every term", () => {
-    expect(matchRanges("South Korea", ["korea"])).toEqual([[6, 11]]);
-    expect(matchRanges("Germany", ["ger", "man"])).toEqual([[0, 6]]);
-    expect(matchRanges("Germany", ["ger", "xyz"])).toBeNull();
-    expect(matchRanges("Germany", [])).toEqual([]);
-  });
-
-  it("filters on label, description and keywords", () => {
-    expect(labels(filterOptions(options, ""))).toHaveLength(5);
-    expect(labels(filterOptions(options, "an"))).toEqual(["Japan", "Germany", "France"]);
-    expect(labels(filterOptions(options, "berlin"))).toEqual(["Germany"]);
-    expect(labels(filterOptions(options, "bharat"))).toEqual(["India"]);
-    expect(labels(filterOptions(options, "nothing"))).toEqual([]);
-  });
-
-  it("highlights the label only", () => {
-    const [india] = filterOptions(options, "ind");
-    expect(india.matches).toEqual([[0, 3]]);
-    const [germany] = filterOptions(options, "berlin");
-    expect(germany.matches).toEqual([]);
-  });
-
-  it("uses a custom filter when given", () => {
-    const entries = filterOptions(options, "x", (option) => option.value === "jp");
-    expect(labels(entries)).toEqual(["Japan"]);
-  });
-});
-
-describe("list building", () => {
-  it("adds group headings and numbers options across groups", () => {
-    const items = buildListItems(filterOptions(options, ""));
-    expect(items.map((item) => (item.kind === "group" ? `# ${item.label}` : item.entry.option.label))).toEqual([
-      "# Asia",
-      "India",
-      "Japan",
-      "South Korea",
-      "# Europe",
-      "Germany",
-      "France",
-    ]);
-    const optionItems = items.filter((item) => item.kind === "option");
-    expect(optionItems.map((item) => (item.kind === "option" ? item.index : -1))).toEqual([0, 1, 2, 3, 4]);
-  });
-
-  it("skips headings when no option has a group", () => {
-    const flat = buildListItems(filterOptions([{ value: "a", label: "A" }], ""));
-    expect(flat).toHaveLength(1);
-    expect(flat[0].kind).toBe("option");
-  });
-});
-
-describe("keyboard helpers", () => {
-  const entries = filterOptions(options, "");
-
-  it("moves over enabled options and wraps", () => {
-    expect(nextEnabledIndex(entries, 0, 1)).toBe(1);
-    expect(nextEnabledIndex(entries, 1, 1)).toBe(3); // skips the disabled option
-    expect(nextEnabledIndex(entries, 4, 1)).toBe(0);
-    expect(nextEnabledIndex(entries, 0, -1)).toBe(4);
-    expect(nextEnabledIndex([], 0, 1)).toBe(-1);
-  });
-
-  it("finds the first and last enabled option", () => {
-    expect(firstEnabledIndex(entries)).toBe(0);
-    expect(firstEnabledIndex(entries, 2)).toBe(3);
-    expect(lastEnabledIndex(entries)).toBe(4);
-    expect(lastEnabledIndex([{ option: options[2], matches: [] }])).toBe(-1);
-  });
-
-  it("jumps to a typed prefix", () => {
-    expect(findByPrefix(entries, "ja", -1)).toBe(1);
-    expect(findByPrefix(entries, "s", -1)).toBe(-1); // South Korea is disabled
-    expect(findByPrefix(entries, "zz", -1)).toBe(-1);
-  });
-});
-
-describe("selection", () => {
-  it("adds, removes and respects max", () => {
-    expect(toggleValue(["a"], "b")).toEqual(["a", "b"]);
-    expect(toggleValue(["a", "b"], "a")).toEqual(["b"]);
-    expect(toggleValue(["a", "b"], "c", 2)).toEqual(["a", "b"]);
-    expect(toggleValue(["a", "b"], "b", 2)).toEqual(["a"]);
-  });
-});
-
-describe("virtualization", () => {
-  const items = buildListItems(filterOptions(options, ""));
-  const metrics = measureItems(items, { option: 34, group: 26 });
-
-  it("measures group and option rows", () => {
-    expect(metrics.total).toBe(2 * 26 + 5 * 34);
-    expect(metrics.offsets[0]).toBe(0);
-    expect(metrics.offsets[1]).toBe(26);
-  });
-
-  it("returns the visible window with overscan", () => {
-    expect(getVisibleRange(metrics, 0, 60, 0)).toEqual({ start: 0, end: 3 });
-    expect(getVisibleRange(metrics, 0, 0, 0)).toEqual({ start: 0, end: 7 });
-    const range = getVisibleRange(metrics, 100, 60, 1);
-    expect(range.start).toBeLessThanOrEqual(3);
-    expect(range.end).toBeGreaterThanOrEqual(5);
-  });
-
-  it("scrolls an item into view only when needed", () => {
-    expect(scrollToItem(metrics, 0, 0, 100)).toBeNull();
-    expect(scrollToItem(metrics, 6, 0, 100)).toBe(metrics.offsets[7] - 100);
-    expect(scrollToItem(metrics, 1, 40, 100)).toBe(26);
-  });
-});