gbs-add-block 2.1.0 → 2.3.0

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

@@ -1,64 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { adopt, idleToggle, request, settle } from "../core/toggle";
-
-describe("switch toggling", () => {
-  it("shows the new setting before it has been saved", () => {
-    const state = request(idleToggle(false), true);
-    expect(state).toEqual({ checked: true, pending: true, fallback: false });
-  });
-
-  it("keeps the new setting once the save succeeds", () => {
-    const state = settle(request(idleToggle(false), true), true, true);
-    expect(state).toEqual({ checked: true, pending: null, fallback: true });
-  });
-
-  it("goes back where it was when the save fails", () => {
-    const state = settle(request(idleToggle(false), true), true, false);
-    expect(state).toEqual({ checked: false, pending: null, fallback: false });
-  });
-
-  it("returns to where the run of changes started, not to the opposite", () => {
-    // On, then off again while the first save is still running: failing the
-    // second must land on the original off, which is also where it looks like
-    // it is — flipping the visible value would turn it back on.
-    const first = request(idleToggle(false), true);
-    const second = request(first, false);
-    expect(second.fallback).toBe(false);
-    expect(settle(second, false, false).checked).toBe(false);
-  });
-
-  it("ignores the outcome of a change that was overtaken", () => {
-    const first = request(idleToggle(false), true);
-    const second = request(first, false);
-    // The first request finally answers, long after the second replaced it.
-    expect(settle(second, true, true)).toBe(second);
-    expect(settle(second, true, false)).toBe(second);
-  });
-
-  it("ignores an outcome when nothing is in flight", () => {
-    const idle = idleToggle(true);
-    expect(settle(idle, true, false)).toBe(idle);
-  });
-
-  it("does nothing when asked for the value it already shows", () => {
-    const idle = idleToggle(true);
-    expect(request(idle, true)).toBe(idle);
-  });
-
-  it("re-requests a value that is showing but not yet saved", () => {
-    // Pressed on, pressed off, pressed on again: the last press still needs an
-    // outcome of its own, so it cannot be dropped as a no-op.
-    const pending = request(request(idleToggle(false), true), false);
-    const again = request(pending, true);
-    expect(again.pending).toBe(true);
-    expect(again.fallback).toBe(false);
-  });
-
-  it("lets a controlled value win over anything in flight", () => {
-    const pending = request(idleToggle(false), true);
-    expect(adopt(pending, false)).toEqual({ checked: false, pending: null, fallback: false });
-    // An unchanged, settled value is left as it is, so React skips the render.
-    const idle = idleToggle(true);
-    expect(adopt(idle, true)).toBe(idle);
-  });
-});

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

@@ -1,51 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { nextTab, tabDomId } from "../core/navigation";
-
-const tabs = [{}, { disabled: true }, {}, {}];
-
-describe("keyboard movement", () => {
-  it("moves with the arrows, skipping disabled tabs", () => {
-    expect(nextTab(tabs, 0, "ArrowRight")).toBe(2);
-    expect(nextTab(tabs, 2, "ArrowLeft")).toBe(0);
-  });
-
-  it("wraps around by default, or stops at the ends", () => {
-    expect(nextTab(tabs, 3, "ArrowRight")).toBe(0);
-    expect(nextTab(tabs, 0, "ArrowLeft")).toBe(3);
-    expect(nextTab(tabs, 3, "ArrowRight", { loop: false })).toBeNull();
-    expect(nextTab(tabs, 0, "ArrowLeft", { loop: false })).toBeNull();
-  });
-
-  it("jumps with Home and End", () => {
-    expect(nextTab(tabs, 2, "Home")).toBe(0);
-    expect(nextTab(tabs, 0, "End")).toBe(3);
-    expect(nextTab([{ disabled: true }, {}, { disabled: true }], 1, "End")).toBe(1);
-  });
-
-  it("uses up and down when vertical, and ignores the other axis", () => {
-    expect(nextTab(tabs, 0, "ArrowDown", { orientation: "vertical" })).toBe(2);
-    expect(nextTab(tabs, 2, "ArrowUp", { orientation: "vertical" })).toBe(0);
-    expect(nextTab(tabs, 0, "ArrowRight", { orientation: "vertical" })).toBeNull();
-    expect(nextTab(tabs, 0, "ArrowDown")).toBeNull();
-  });
-
-  it("swaps left and right in right-to-left layouts", () => {
-    expect(nextTab(tabs, 0, "ArrowLeft", { rtl: true })).toBe(2);
-    expect(nextTab(tabs, 2, "ArrowRight", { rtl: true })).toBe(0);
-  });
-
-  it("returns null when nothing can take focus", () => {
-    expect(nextTab([], 0, "ArrowRight")).toBeNull();
-    expect(nextTab([{ disabled: true }], 0, "ArrowRight")).toBeNull();
-    expect(nextTab(tabs, 0, "Enter")).toBeNull();
-  });
-});
-
-describe("ids", () => {
-  it("makes safe, distinct ids from any value", () => {
-    expect(tabDomId("t1", "tab", "overview")).toBe("t1-tab-overview");
-    expect(tabDomId("t1", "panel", "billing & plans")).toBe("t1-panel-billing_20_26_20plans");
-    expect(tabDomId("t1", "tab", "a b")).not.toBe(tabDomId("t1", "tab", "a_b"));
-    expect(tabDomId("t1", "tab", "v1.2")).toMatch(/^[\w-]+$/);
-  });
-});

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

@@ -1,38 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { countCharacters } from "../core/count";
-import { fitHeight, heightForRows } from "../core/size";
-
-const metrics = { lineHeight: 20, paddingBlock: 16, borderBlock: 2 };
-
-describe("character count", () => {
-  it("counts what a person sees", () => {
-    expect(countCharacters("")).toBe(0);
-    expect(countCharacters("line one\nline two")).toBe(17);
-    expect(countCharacters("👍🏽👍🏽")).toBe(2);
-  });
-});
-
-describe("auto resize", () => {
-  it("measures rows as border-box height", () => {
-    expect(heightForRows(1, metrics)).toBe(38);
-    expect(heightForRows(3, metrics)).toBe(78);
-  });
-
-  it("never shrinks below minRows", () => {
-    // One line of content: scrollHeight = 20 + 16 padding.
-    expect(fitHeight(36, metrics, 3)).toEqual({ height: 78, overflow: false });
-  });
-
-  it("grows with the content", () => {
-    expect(fitHeight(136, metrics, 3)).toEqual({ height: 138, overflow: false });
-  });
-
-  it("stops at maxRows and reports that it should scroll", () => {
-    expect(fitHeight(416, metrics, 3, 5)).toEqual({ height: 118, overflow: true });
-    expect(fitHeight(96, metrics, 3, 5)).toEqual({ height: 98, overflow: false });
-  });
-
-  it("keeps maxRows from undercutting minRows", () => {
-    expect(fitHeight(36, metrics, 4, 2).height).toBe(98);
-  });
-});

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

@@ -1,256 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { createToastApi } from "../core/api";
-import { createToastStore, visibleToasts, type ToastStore } from "../core/store";
-import { toast, toastStore } from "../core/toast";
-
-beforeEach(() => {
-  vi.useFakeTimers();
-});
-
-afterEach(() => {
-  vi.useRealTimers();
-});
-
-const states = (store: ToastStore) =>
-  store.getSnapshot().toasts.map((item) => `${item.id}:${item.state}`);
-
-const find = (store: ToastStore, id: string) =>
-  store.getSnapshot().toasts.find((item) => item.id === id);
-
-describe("showing", () => {
-  it("adds toasts newest first, with defaults", () => {
-    const store = createToastStore();
-    const first = store.show("Saved");
-    const second = store.show("Deleted", { type: "error", description: "3 rows" });
-
-    expect([first, second]).toEqual(["toast-1", "toast-2"]);
-    const [newest, oldest] = store.getSnapshot().toasts;
-    expect(newest).toMatchObject({ id: "toast-2", type: "error", description: "3 rows" });
-    expect(oldest).toMatchObject({
-      title: "Saved",
-      type: "default",
-      duration: 5000,
-      dismissible: true,
-      state: "open",
-      version: 1,
-    });
-  });
-
-  it("updates a toast shown again with the same id, keeping its place", () => {
-    const store = createToastStore();
-    store.show("Syncing", { id: "sync" });
-    store.show("Other");
-    store.show("Synced", { id: "sync", type: "success" });
-
-    expect(states(store)).toEqual(["toast-1:open", "sync:open"]);
-    expect(find(store, "sync")).toMatchObject({ title: "Synced", type: "success", version: 2 });
-  });
-
-  it("restarts the countdown when the same id is shown again", () => {
-    const store = createToastStore();
-    store.show("Draft saved", { id: "draft" });
-    vi.advanceTimersByTime(4000);
-    store.show("Draft saved again", { id: "draft" });
-    vi.advanceTimersByTime(4000);
-    expect(find(store, "draft")?.state).toBe("open");
-    vi.advanceTimersByTime(1000);
-    expect(find(store, "draft")?.state).toBe("closing");
-  });
-
-  it("brings back a toast that is fading out instead of stacking a copy", () => {
-    const store = createToastStore();
-    store.show("Offline", { id: "net" });
-    store.dismiss("net");
-    store.show("Still offline", { id: "net" });
-    vi.advanceTimersByTime(300);
-    expect(states(store)).toEqual(["net:open"]);
-  });
-});
-
-describe("timing", () => {
-  it("closes after its duration, then leaves after the exit animation", () => {
-    const store = createToastStore();
-    const onAutoClose = vi.fn();
-    const onDismiss = vi.fn();
-    store.show("Saved", { duration: 2000, onAutoClose, onDismiss });
-
-    vi.advanceTimersByTime(1999);
-    expect(states(store)).toEqual(["toast-1:open"]);
-    vi.advanceTimersByTime(1);
-    expect(states(store)).toEqual(["toast-1:closing"]);
-    expect(onAutoClose).toHaveBeenCalledOnce();
-    expect(onDismiss).not.toHaveBeenCalled();
-    vi.advanceTimersByTime(200);
-    expect(states(store)).toEqual([]);
-  });
-
-  it("keeps sticky and loading toasts until dismissed", () => {
-    const store = createToastStore();
-    store.show("Zero", { duration: 0 });
-    store.show("Infinite", { duration: Infinity });
-    store.show("Working", { type: "loading" });
-
-    vi.advanceTimersByTime(60_000);
-    expect(states(store)).toEqual(["toast-3:open", "toast-2:open", "toast-1:open"]);
-    expect(find(store, "toast-1")?.duration).toBe(Infinity);
-  });
-
-  it("dismisses one toast or all of them", () => {
-    const store = createToastStore();
-    const onDismiss = vi.fn();
-    store.show("A", { onDismiss });
-    store.show("B");
-    store.show("C");
-
-    store.dismiss("toast-1");
-    expect(onDismiss).toHaveBeenCalledWith(expect.objectContaining({ id: "toast-1" }));
-    expect(states(store)).toEqual(["toast-3:open", "toast-2:open", "toast-1:closing"]);
-
-    store.dismiss();
-    vi.advanceTimersByTime(200);
-    expect(states(store)).toEqual([]);
-  });
-
-  it("holds the remaining time while paused", () => {
-    const store = createToastStore();
-    store.show("Saved");
-
-    vi.advanceTimersByTime(3000);
-    store.pause();
-    vi.advanceTimersByTime(10_000);
-    expect(states(store)).toEqual(["toast-1:open"]);
-
-    store.resume();
-    vi.advanceTimersByTime(1999);
-    expect(states(store)).toEqual(["toast-1:open"]);
-    vi.advanceTimersByTime(1);
-    expect(states(store)).toEqual(["toast-1:closing"]);
-  });
-
-  it("queues toasts beyond the limit with their full time", () => {
-    const store = createToastStore({ limit: 3 });
-    for (const title of ["A", "B", "C", "D"]) store.show(title);
-
-    expect(visibleToasts(store.getSnapshot()).map((item) => item.title)).toEqual(["D", "C", "B"]);
-
-    // B, C and D run out; A only starts counting once it gets a slot.
-    vi.advanceTimersByTime(5000);
-    expect(find(store, "toast-1")?.state).toBe("open");
-    expect(visibleToasts(store.getSnapshot()).map((item) => item.title)).toEqual([
-      "D",
-      "C",
-      "B",
-      "A",
-    ]);
-    vi.advanceTimersByTime(4999);
-    expect(find(store, "toast-1")?.state).toBe("open");
-    vi.advanceTimersByTime(1);
-    expect(find(store, "toast-1")?.state).toBe("closing");
-  });
-});
-
-describe("updates", () => {
-  it("gives a loading toast a normal duration once its type changes", () => {
-    const store = createToastStore();
-    const id = store.show("Uploading", { type: "loading" });
-
-    store.update(id, { description: "40%" });
-    expect(find(store, id)).toMatchObject({ duration: Infinity, description: "40%", version: 2 });
-
-    store.update(id, { type: "success", title: "Uploaded" });
-    expect(find(store, id)).toMatchObject({ type: "success", title: "Uploaded", duration: 5000 });
-    vi.advanceTimersByTime(5000);
-    expect(find(store, id)?.state).toBe("closing");
-  });
-
-  it("ignores ids that are not open", () => {
-    const store = createToastStore();
-    store.update("missing", { title: "Nope" });
-    expect(states(store)).toEqual([]);
-  });
-
-  it("applies a new limit and notifies subscribers", () => {
-    const store = createToastStore();
-    const listener = vi.fn();
-    store.subscribe(listener);
-
-    store.configure({ limit: 1, duration: undefined });
-    expect(store.getSnapshot().limit).toBe(1);
-    expect(listener).toHaveBeenCalledOnce();
-
-    store.pause();
-    store.pause();
-    expect(listener).toHaveBeenCalledTimes(2);
-  });
-
-  it("keeps the same snapshot object until something changes", () => {
-    const store = createToastStore();
-    const before = store.getSnapshot();
-    expect(store.getSnapshot()).toBe(before);
-    store.show("Hi");
-    expect(store.getSnapshot()).not.toBe(before);
-  });
-});
-
-describe("toast api", () => {
-  it("sets the type from the shortcut used", () => {
-    const store = createToastStore();
-    const api = createToastApi(store);
-    api.success("Saved");
-    api.warning("Low disk");
-    api.custom(({ id }) => id);
-
-    const [custom, warning, success] = store.getSnapshot().toasts;
-    expect(success.type).toBe("success");
-    expect(warning.type).toBe("warning");
-    expect(typeof custom.render).toBe("function");
-  });
-
-  it("turns a promise into a success toast", async () => {
-    const store = createToastStore();
-    const api = createToastApi(store);
-    const result = api.promise(Promise.resolve(42), {
-      loading: "Saving",
-      success: (value) => `Saved ${value}`,
-      error: "Failed",
-    });
-
-    expect(store.getSnapshot().toasts[0]).toMatchObject({ type: "loading", title: "Saving" });
-    await expect(result).resolves.toBe(42);
-    expect(store.getSnapshot().toasts[0]).toMatchObject({ type: "success", title: "Saved 42" });
-  });
-
-  it("turns a rejected promise into an error toast and still rejects", async () => {
-    const store = createToastStore();
-    const api = createToastApi(store);
-    const result = api.promise(() => Promise.reject(new Error("Network down")), {
-      loading: "Saving",
-      error: (error) => (error as Error).message,
-    });
-
-    await expect(result).rejects.toThrow("Network down");
-    expect(store.getSnapshot().toasts[0]).toMatchObject({ type: "error", title: "Network down" });
-  });
-
-  it("closes quietly when a promise message is left out", async () => {
-    const store = createToastStore();
-    const api = createToastApi(store);
-    await api.promise(Promise.resolve("ok"), { loading: "Checking" });
-    expect(states(store)).toEqual(["toast-1:closing"]);
-  });
-
-  it("does nothing where a toast cannot be shown", async () => {
-    const store = createToastStore();
-    const api = createToastApi(store, () => false);
-    expect(api("Hidden")).toBe("");
-    expect(api.success("Hidden", { id: "kept" })).toBe("kept");
-    await expect(api.promise(Promise.resolve(1), { loading: "…" })).resolves.toBe(1);
-    expect(states(store)).toEqual([]);
-  });
-
-  it("ignores the default toast() on a server, where there is no document", () => {
-    expect(typeof document).toBe("undefined");
-    expect(toast("Rendered on the server")).toBe("");
-    expect(toastStore.getSnapshot().toasts).toHaveLength(0);
-  });
-});

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

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isHoverPointer, nextVisibility } from "../core/visibility";
-
-const delays = { open: 400, close: 120 };
-
-describe("nextVisibility", () => {
-  it("waits before showing on hover, so a swept toolbar stays quiet", () => {
-    expect(nextVisibility({ hovered: true, focused: false }, delays)).toEqual({
-      open: true,
-      delay: 400,
-    });
-  });
-
-  it("shows immediately on keyboard focus", () => {
-    expect(nextVisibility({ hovered: false, focused: true }, delays)).toEqual({
-      open: true,
-      delay: 0,
-    });
-  });
-
-  it("stays open while focused, even after the pointer leaves", () => {
-    expect(nextVisibility({ hovered: false, focused: true }, delays).open).toBe(true);
-  });
-
-  it("waits a moment before hiding, so crossing a gap does not flicker", () => {
-    expect(nextVisibility({ hovered: false, focused: false }, delays)).toEqual({
-      open: false,
-      delay: 120,
-    });
-  });
-});
-
-describe("isHoverPointer", () => {
-  it("counts a mouse", () => {
-    expect(isHoverPointer("mouse")).toBe(true);
-  });
-
-  it("ignores touch and pen, where a tooltip would cover what was tapped", () => {
-    expect(isHoverPointer("touch")).toBe(false);
-    expect(isHoverPointer("pen")).toBe(false);
-  });
-});