@heyramzi/ui 2.0.1 → 2.2.0

package/src/modules.test.ts

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it, vi } from "vite-plus/test";
+import * as status from "./status/index.js";
+import * as panel from "./panel/index.js";
+import * as record from "./record/index.js";
+import * as inbox from "./inbox/index.js";
+import * as thread from "./thread/index.js";
+import type {
+  PanelStat as FromTasksPanelStat,
+  SidePanelWidth as FromTasksWidth,
+  StatusDef as FromTasksStatusDef,
+  StatusDotVariant as FromTasksVariant,
+  StatusId as FromTasksId,
+  StatusMap as FromTasksMap,
+  Statuses as FromTasksStatuses,
+} from "./tasks/index.js";
+import type { PanelStat, SidePanelWidth } from "./panel/index.js";
+import type {
+  StatusDef,
+  StatusDotVariant,
+  StatusId,
+  StatusMap,
+  Statuses,
+} from "./status/index.js";
+
+// Both spellings of every moved type have to be the same type.
+type Same<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+const sameTypes: [
+  Same<PanelStat, FromTasksPanelStat>,
+  Same<SidePanelWidth, FromTasksWidth>,
+  Same<StatusDef, FromTasksStatusDef>,
+  Same<StatusDotVariant, FromTasksVariant>,
+  Same<StatusId<{ a: StatusDef }>, FromTasksId<{ a: StatusDef }>>,
+  Same<StatusMap, FromTasksMap>,
+  Same<Statuses, FromTasksStatuses>,
+] = [true, true, true, true, true, true, true];
+
+const pkg = JSON.parse(
+  readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8"),
+) as {
+  exports: Record<string, string | Record<string, string>>;
+};
+
+describe("module split", () => {
+  it("keeps every moved name on tasks, the same object as on its new module", async () => {
+    // The kanban board reads matchMedia on import, and jsdom has none.
+    vi.stubGlobal("matchMedia", () => ({
+      matches: false,
+      addEventListener() {},
+      removeEventListener() {},
+    }));
+    const tasks = await import("./tasks/index.js");
+    expect(sameTypes).toHaveLength(7);
+    expect(tasks.StatusBadge).toBe(status.StatusBadge);
+    expect(tasks.StatusDot).toBe(status.StatusDot);
+    expect(tasks.StatusIcon).toBe(status.StatusIcon);
+    expect(tasks.defineStatuses).toBe(status.defineStatuses);
+    expect(tasks.StatusBadge).toBeDefined();
+    expect(tasks.SidePanel).toBe(panel.SidePanel);
+  });
+
+  it("holds the record page's names", () => {
+    expect(record.RecordShell).toBeDefined();
+    expect(record.DEFAULT_RECORD_LABELS).toBeDefined();
+  });
+
+  it("names what the new modules export", () => {
+    expect(thread.Thread).toBeDefined();
+    expect(inbox.ThreadInbox).toBeDefined();
+    expect(inbox.InboxCard).toBeDefined();
+    expect(inbox.threadsOf).toBeTypeOf("function");
+  });
+
+  it("resolves every export path to a file", () => {
+    const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+    const missing: string[] = [];
+    for (const [name, target] of Object.entries(pkg.exports)) {
+      const path = typeof target === "string" ? target : (target.default ?? target.svelte);
+      if (path.includes("*") || path.endsWith(".css")) continue;
+      if (!existsSync(join(root, path))) missing.push(`${name} -> ${path}`);
+    }
+    expect(missing).toEqual([]);
+  });
+
+  it("keeps the old subpaths and adds the new ones", () => {
+    for (const name of [
+      "./tasks",
+      "./tasks/status",
+      "./tasks/status-dot",
+      "./tasks/statuses",
+      "./tasks/side-panel",
+      "./tasks/record",
+      "./tasks/inbox",
+      "./status",
+      "./panel",
+      "./record",
+      "./thread",
+      "./inbox",
+    ]) {
+      expect(pkg.exports[name], name).toBeDefined();
+    }
+  });
+});

package/src/onboarding/define-tours.test.ts

@@ -2,49 +2,64 @@ import { describe, expect, it } from "vite-plus/test";
 import { defineTours } from "./define-tours.js";
 import type { Step, Tour } from "./types.js";
 
-const step = (n: number): Step => ({ target: `[data-tour="s${n}"]`, title: `Title ${n}`, body: `Body ${n}` });
+const step = (n: number): Step => ({
+  target: `[data-tour="s${n}"]`,
+  title: `Title ${n}`,
+  body: `Body ${n}`,
+});
 const steps = (count: number) => Array.from({ length: count }, (_, i) => step(i + 1));
 const board = (over: Partial<Extract<Tour, { kind: "steps" }>> = {}): Tour => ({
-	id: "board",
-	route: "/(app)/projects",
-	kind: "steps",
-	steps: steps(3),
-	...over,
+  id: "board",
+  route: "/(app)/projects",
+  kind: "steps",
+  steps: steps(3),
+  ...over,
 });
 
 describe("defineTours", () => {
-	it("returns the tours it was given", () => {
-		const list = [board(), { id: "home", route: "/(app)", kind: "intro", title: "Hi", body: "Welcome." } as const];
-		expect(defineTours(list)).toBe(list);
-	});
-
-	it("rejects a repeated id", () => {
-		expect(() => defineTours([board(), board({ route: "/(app)/other" })])).toThrow(/"board".*used twice/);
-	});
-
-	it("takes 1 to 6 steps", () => {
-		expect(() => defineTours([board({ steps: steps(1) })])).not.toThrow();
-		expect(() => defineTours([board({ steps: steps(6) })])).not.toThrow();
-		expect(() => defineTours([board({ steps: [] })])).toThrow(/0 steps/);
-		expect(() => defineTours([board({ steps: steps(7) })])).toThrow(/7 steps/);
-	});
-
-	it("rejects a route that isn't a route id", () => {
-		expect(() => defineTours([board({ route: "projects" })])).toThrow(/not a route id/);
-	});
-
-	it("rejects a bad version", () => {
-		expect(() => defineTours([board({ version: 0 })])).toThrow(/version/);
-		expect(() => defineTours([board({ version: 1.5 })])).toThrow(/version/);
-		expect(() => defineTours([board({ version: 2 })])).not.toThrow();
-	});
-
-	it("rejects a step with no target or no words", () => {
-		expect(() => defineTours([board({ steps: [{ ...step(1), target: " " }] })])).toThrow(/step 1 has no target/);
-		expect(() => defineTours([board({ steps: [{ ...step(1), body: "" }] })])).toThrow(/title and a body/);
-	});
-
-	it("rejects an intro with no title", () => {
-		expect(() => defineTours([{ id: "home", route: "/(app)", kind: "intro", title: "", body: "x" }])).toThrow(/intro/);
-	});
+  it("returns the tours it was given", () => {
+    const list = [
+      board(),
+      { id: "home", route: "/(app)", kind: "intro", title: "Hi", body: "Welcome." } as const,
+    ];
+    expect(defineTours(list)).toBe(list);
+  });
+
+  it("rejects a repeated id", () => {
+    expect(() => defineTours([board(), board({ route: "/(app)/other" })])).toThrow(
+      /"board".*used twice/,
+    );
+  });
+
+  it("takes 1 to 6 steps", () => {
+    expect(() => defineTours([board({ steps: steps(1) })])).not.toThrow();
+    expect(() => defineTours([board({ steps: steps(6) })])).not.toThrow();
+    expect(() => defineTours([board({ steps: [] })])).toThrow(/0 steps/);
+    expect(() => defineTours([board({ steps: steps(7) })])).toThrow(/7 steps/);
+  });
+
+  it("rejects a route that isn't a route id", () => {
+    expect(() => defineTours([board({ route: "projects" })])).toThrow(/not a route id/);
+  });
+
+  it("rejects a bad version", () => {
+    expect(() => defineTours([board({ version: 0 })])).toThrow(/version/);
+    expect(() => defineTours([board({ version: 1.5 })])).toThrow(/version/);
+    expect(() => defineTours([board({ version: 2 })])).not.toThrow();
+  });
+
+  it("rejects a step with no target or no words", () => {
+    expect(() => defineTours([board({ steps: [{ ...step(1), target: " " }] })])).toThrow(
+      /step 1 has no target/,
+    );
+    expect(() => defineTours([board({ steps: [{ ...step(1), body: "" }] })])).toThrow(
+      /title and a body/,
+    );
+  });
+
+  it("rejects an intro with no title", () => {
+    expect(() =>
+      defineTours([{ id: "home", route: "/(app)", kind: "intro", title: "", body: "x" }]),
+    ).toThrow(/intro/);
+  });
 });

package/src/onboarding/define-tours.ts

@@ -1,31 +1,31 @@
 import { MAX_STEPS, type Tour } from "./types.js";
 
 function fail(id: string, problem: string): never {
-	throw new Error(`tour "${id}": ${problem}`);
+  throw new Error(`tour "${id}": ${problem}`);
 }
 
 /** Returns the tours as written, after checking what a typo would hide until a user hits it. */
 export function defineTours<const T extends readonly Tour[]>(tours: T): T {
-	const ids = new Set<string>();
-	for (const tour of tours) {
-		const { id } = tour;
-		if (!id || !id.trim()) throw new Error("a tour needs an id");
-		if (ids.has(id)) fail(id, "its id is used twice");
-		ids.add(id);
-		if (!tour.route.startsWith("/")) fail(id, `route "${tour.route}" is not a route id`);
-		const version = tour.version ?? 1;
-		if (!Number.isInteger(version) || version < 1) fail(id, "version is a whole number from 1");
-		if (tour.kind === "intro") {
-			if (!tour.title || !tour.body) fail(id, "an intro needs a title and a body");
-			continue;
-		}
-		if (tour.steps.length < 1 || tour.steps.length > MAX_STEPS) {
-			fail(id, `has ${tour.steps.length} steps, and a tour takes 1 to ${MAX_STEPS}`);
-		}
-		tour.steps.forEach((step, i) => {
-			if (!step.target.trim()) fail(id, `step ${i + 1} has no target`);
-			if (!step.title || !step.body) fail(id, `step ${i + 1} needs a title and a body`);
-		});
-	}
-	return tours;
+  const ids = new Set<string>();
+  for (const tour of tours) {
+    const { id } = tour;
+    if (!id || !id.trim()) throw new Error("a tour needs an id");
+    if (ids.has(id)) fail(id, "its id is used twice");
+    ids.add(id);
+    if (!tour.route.startsWith("/")) fail(id, `route "${tour.route}" is not a route id`);
+    const version = tour.version ?? 1;
+    if (!Number.isInteger(version) || version < 1) fail(id, "version is a whole number from 1");
+    if (tour.kind === "intro") {
+      if (!tour.title || !tour.body) fail(id, "an intro needs a title and a body");
+      continue;
+    }
+    if (tour.steps.length < 1 || tour.steps.length > MAX_STEPS) {
+      fail(id, `has ${tour.steps.length} steps, and a tour takes 1 to ${MAX_STEPS}`);
+    }
+    tour.steps.forEach((step, i) => {
+      if (!step.target.trim()) fail(id, `step ${i + 1} has no target`);
+      if (!step.title || !step.body) fail(id, `step ${i + 1} needs a title and a body`);
+    });
+  }
+  return tours;
 }

package/src/onboarding/demo.svelte

@@ -20,9 +20,24 @@
 			route: "/demo/board",
 			kind: "steps",
 			steps: [
-				{ target: '[data-tour="demo-new"]', title: "Start here", body: "A new project takes a name and a client. That's all.", placement: "bottom-end" },
-				{ target: '[data-tour="demo-filter"]', title: "Narrow it down", body: "Late shows what slipped. Mine shows what's yours.", placement: "bottom-start" },
-				{ target: '[data-tour="demo-list"]', title: "Open a row", body: "Click a project to see its tasks, files and notes.", placement: "top" },
+				{
+					target: '[data-tour="demo-new"]',
+					title: "Start here",
+					body: "A new project takes a name and a client. That's all.",
+					placement: "bottom-end",
+				},
+				{
+					target: '[data-tour="demo-filter"]',
+					title: "Narrow it down",
+					body: "Late shows what slipped. Mine shows what's yours.",
+					placement: "bottom-start",
+				},
+				{
+					target: '[data-tour="demo-list"]',
+					title: "Open a row",
+					body: "Click a project to see its tasks, files and notes.",
+					placement: "top",
+				},
 			],
 		},
 	]);
@@ -55,8 +70,12 @@
 
 <div class="flex flex-col gap-4">
 	<div class="flex flex-wrap gap-2">
-		<Button variant="outline" size="sm" onclick={() => start("/demo/board")}>Show the page tour</Button>
-		<Button variant="outline" size="sm" onclick={() => start("/demo/intro")}>Show the intro card</Button>
+		<Button variant="outline" size="sm" onclick={() => start("/demo/board")}
+			>Show the page tour</Button
+		>
+		<Button variant="outline" size="sm" onclick={() => start("/demo/intro")}
+			>Show the intro card</Button
+		>
 	</div>
 
 	<div class="bg-card ring-foreground/10 flex flex-col gap-4 rounded-xl p-4 ring-1">

package/src/onboarding/index.ts

@@ -2,11 +2,4 @@ export { default as OnboardingProvider } from "./onboarding-provider.svelte";
 export { onboarding } from "./onboarding.svelte.js";
 export { defineTours } from "./define-tours.js";
 export { localStorageStore, memoryStore } from "./stores.js";
-export type {
-	Outcome,
-	Placement,
-	SeenStore,
-	Step,
-	Strings,
-	Tour,
-} from "./types.js";
+export type { Outcome, Placement, SeenStore, Step, Strings, Tour } from "./types.js";

package/src/onboarding/onboarding-provider.svelte

@@ -2,7 +2,13 @@
 	import { tryCatchAsync } from "../lib/result.js";
 	import { untrack } from "svelte";
 	import { onboarding } from "./onboarding.svelte.js";
-	import { keepFoundSteps, pickForReplay, pickTour, toursForRoute, type SeenMap } from "./pick.js";
+	import {
+		keepFoundSteps,
+		pickForReplay,
+		pickTour,
+		toursForRoute,
+		type SeenMap,
+	} from "./pick.js";
 	import TourRunner from "./tour-runner.svelte";
 	import type { Outcome, SeenStore, Step, Strings, Tour } from "./types.js";
 	import { waitForElement } from "./wait.js";
@@ -71,17 +77,23 @@
 		controller = mine;
 		void loadSeen().then((map) => {
 			if (!map || mine.signal.aborted) return;
-			const tour = pickTour(untrack(() => tours), id, map);
+			const tour = pickTour(
+				untrack(() => tours),
+				id,
+				map,
+			);
 			if (tour) void launch(tour, false, mine.signal);
 		});
 		return () => mine.abort();
 	});
 
-	$effect(() => onboarding.bind(async (tourId) => {
-		const tour = pickForReplay(tours, routeId, tourId);
-		if (!tour || !controller || controller.signal.aborted) return false;
-		return launch(tour, true, controller.signal);
-	}));
+	$effect(() =>
+		onboarding.bind(async (tourId) => {
+			const tour = pickForReplay(tours, routeId, tourId);
+			if (!tour || !controller || controller.signal.aborted) return false;
+			return launch(tour, true, controller.signal);
+		}),
+	);
 
 	$effect(() => {
 		onboarding.running = active !== null;

package/src/onboarding/onboarding.svelte.ts

@@ -1,24 +1,24 @@
 type Replay = (tourId?: string) => Promise<boolean>;
 
 class Onboarding {
-	/** True when the current page has a tour, so a menu item can hide itself. */
-	hasTour = $state(false);
-	/** True while a tour is on screen. */
-	running = $state(false);
-	#replay: Replay | null = null;
+  /** True when the current page has a tour, so a menu item can hide itself. */
+  hasTour = $state(false);
+  /** True while a tour is on screen. */
+  running = $state(false);
+  #replay: Replay | null = null;
 
-	/** The provider registers itself here. Returns the undo for cleanup. */
-	bind(replay: Replay): () => void {
-		this.#replay = replay;
-		return () => {
-			if (this.#replay === replay) this.#replay = null;
-		};
-	}
+  /** The provider registers itself here. Returns the undo for cleanup. */
+  bind(replay: Replay): () => void {
+    this.#replay = replay;
+    return () => {
+      if (this.#replay === replay) this.#replay = null;
+    };
+  }
 
-	/** Restarts this page's tour, or the one named. Writes no seen-state. False when nothing started. */
-	replay(tourId?: string): Promise<boolean> {
-		return this.#replay ? this.#replay(tourId) : Promise.resolve(false);
-	}
+  /** Restarts this page's tour, or the one named. Writes no seen-state. False when nothing started. */
+  replay(tourId?: string): Promise<boolean> {
+    return this.#replay ? this.#replay(tourId) : Promise.resolve(false);
+  }
 }
 
 export const onboarding = new Onboarding();

package/src/onboarding/pick.test.ts

@@ -1,79 +1,88 @@
 import { describe, expect, it } from "vite-plus/test";
-import { isSeen, keepFoundSteps, pickForReplay, pickTour, toursForRoute } from "./pick.js";
+import {
+  isSeen,
+  keepFoundSteps,
+  pickForReplay,
+  pickTour,
+  toursForRoute,
+} from "./pick.js";
 import type { Tour } from "./types.js";
 
 const step = { target: "#a", title: "A", body: "a" };
 const tours: Tour[] = [
-	{ id: "home", route: "/(app)", kind: "intro", title: "Hi", body: "Welcome." },
-	{ id: "board", route: "/(app)/projects", kind: "steps", steps: [step] },
-	{ id: "board-extra", route: "/(app)/projects", kind: "steps", steps: [step], version: 2 },
-	{ id: "record", route: "/(app)/projects/[id]", kind: "steps", steps: [step] },
+  { id: "home", route: "/(app)", kind: "intro", title: "Hi", body: "Welcome." },
+  { id: "board", route: "/(app)/projects", kind: "steps", steps: [step] },
+  { id: "board-extra", route: "/(app)/projects", kind: "steps", steps: [step], version: 2 },
+  { id: "record", route: "/(app)/projects/[id]", kind: "steps", steps: [step] },
 ];
 
 describe("isSeen", () => {
-	it("counts a tour as seen once the stored version reaches its own", () => {
-		expect(isSeen(tours[1], {})).toBe(false);
-		expect(isSeen(tours[1], { board: 1 })).toBe(true);
-		expect(isSeen(tours[2], { "board-extra": 1 })).toBe(false);
-		expect(isSeen(tours[2], { "board-extra": 2 })).toBe(true);
-	});
+  it("counts a tour as seen once the stored version reaches its own", () => {
+    expect(isSeen(tours[1], {})).toBe(false);
+    expect(isSeen(tours[1], { board: 1 })).toBe(true);
+    expect(isSeen(tours[2], { "board-extra": 1 })).toBe(false);
+    expect(isSeen(tours[2], { "board-extra": 2 })).toBe(true);
+  });
 
-	it("shows a tour again after its version is bumped", () => {
-		const v1: Tour = { id: "t", route: "/", kind: "steps", steps: [step] };
-		const v2: Tour = { ...v1, version: 2 };
-		expect(isSeen(v1, { t: 1 })).toBe(true);
-		expect(isSeen(v2, { t: 1 })).toBe(false);
-	});
+  it("shows a tour again after its version is bumped", () => {
+    const v1: Tour = { id: "t", route: "/", kind: "steps", steps: [step] };
+    const v2: Tour = { ...v1, version: 2 };
+    expect(isSeen(v1, { t: 1 })).toBe(true);
+    expect(isSeen(v2, { t: 1 })).toBe(false);
+  });
 });
 
 describe("pickTour", () => {
-	it("matches the route id exactly, so a params route never borrows its parent's tour", () => {
-		expect(pickTour(tours, "/(app)", {})?.id).toBe("home");
-		expect(pickTour(tours, "/(app)/projects/[id]", {})?.id).toBe("record");
-		expect(pickTour(tours, "/(app)/settings", {})).toBeUndefined();
-	});
+  it("matches the route id exactly, so a params route never borrows its parent's tour", () => {
+    expect(pickTour(tours, "/(app)", {})?.id).toBe("home");
+    expect(pickTour(tours, "/(app)/projects/[id]", {})?.id).toBe("record");
+    expect(pickTour(tours, "/(app)/settings", {})).toBeUndefined();
+  });
 
-	it("takes the first unseen tour on a route, one at a time", () => {
-		expect(pickTour(tours, "/(app)/projects", {})?.id).toBe("board");
-		expect(pickTour(tours, "/(app)/projects", { board: 1 })?.id).toBe("board-extra");
-		expect(pickTour(tours, "/(app)/projects", { board: 1, "board-extra": 2 })).toBeUndefined();
-	});
+  it("takes the first unseen tour on a route, one at a time", () => {
+    expect(pickTour(tours, "/(app)/projects", {})?.id).toBe("board");
+    expect(pickTour(tours, "/(app)/projects", { board: 1 })?.id).toBe("board-extra");
+    expect(pickTour(tours, "/(app)/projects", { board: 1, "board-extra": 2 })).toBeUndefined();
+  });
 
-	it("picks nothing without a route", () => {
-		expect(pickTour(tours, null, {})).toBeUndefined();
-		expect(pickTour(tours, undefined, {})).toBeUndefined();
-	});
+  it("picks nothing without a route", () => {
+    expect(pickTour(tours, null, {})).toBeUndefined();
+    expect(pickTour(tours, undefined, {})).toBeUndefined();
+  });
 });
 
 describe("toursForRoute", () => {
-	it("lists every tour on the route in definition order", () => {
-		expect(toursForRoute(tours, "/(app)/projects").map((t) => t.id)).toEqual(["board", "board-extra"]);
-	});
+  it("lists every tour on the route in definition order", () => {
+    expect(toursForRoute(tours, "/(app)/projects").map((t) => t.id)).toEqual([
+      "board",
+      "board-extra",
+    ]);
+  });
 });
 
 describe("pickForReplay", () => {
-	it("restarts the page's first tour even when it was seen", () => {
-		expect(pickForReplay(tours, "/(app)/projects")?.id).toBe("board");
-	});
+  it("restarts the page's first tour even when it was seen", () => {
+    expect(pickForReplay(tours, "/(app)/projects")?.id).toBe("board");
+  });
 
-	it("finds a tour by id on any route", () => {
-		expect(pickForReplay(tours, "/(app)", "record")?.id).toBe("record");
-		expect(pickForReplay(tours, "/(app)", "missing")).toBeUndefined();
-	});
+  it("finds a tour by id on any route", () => {
+    expect(pickForReplay(tours, "/(app)", "record")?.id).toBe("record");
+    expect(pickForReplay(tours, "/(app)", "missing")).toBeUndefined();
+  });
 });
 
 describe("keepFoundSteps", () => {
-	const steps = [
-		{ ...step, target: "#a" },
-		{ ...step, target: "#b" },
-		{ ...step, target: "#c" },
-	];
+  const steps = [
+    { ...step, target: "#a" },
+    { ...step, target: "#b" },
+    { ...step, target: "#c" },
+  ];
 
-	it("drops the steps whose target isn't on the page", () => {
-		expect(keepFoundSteps(steps, (s) => s !== "#b").map((s) => s.target)).toEqual(["#a", "#c"]);
-	});
+  it("drops the steps whose target isn't on the page", () => {
+    expect(keepFoundSteps(steps, (s) => s !== "#b").map((s) => s.target)).toEqual(["#a", "#c"]);
+  });
 
-	it("returns nothing when no target is found, so no empty spotlight starts", () => {
-		expect(keepFoundSteps(steps, () => false)).toEqual([]);
-	});
+  it("returns nothing when no target is found, so no empty spotlight starts", () => {
+    expect(keepFoundSteps(steps, () => false)).toEqual([]);
+  });
 });

package/src/onboarding/pick.ts

@@ -4,33 +4,36 @@ export type SeenMap = Record<string, number>;
 
 /** The seen version has to reach the tour's own, so bumping `version` shows it again. */
 export function isSeen(tour: Tour, seen: SeenMap): boolean {
-	return (seen[tour.id] ?? 0) >= (tour.version ?? 1);
+  return (seen[tour.id] ?? 0) >= (tour.version ?? 1);
 }
 
 export function toursForRoute(tours: readonly Tour[], routeId: string | null | undefined): Tour[] {
-	return routeId ? tours.filter((tour) => tour.route === routeId) : [];
+  return routeId ? tours.filter((tour) => tour.route === routeId) : [];
 }
 
 /** The first unseen tour on a route, in the order they were defined. One per page view. */
 export function pickTour(
-	tours: readonly Tour[],
-	routeId: string | null | undefined,
-	seen: SeenMap,
+  tours: readonly Tour[],
+  routeId: string | null | undefined,
+  seen: SeenMap,
 ): Tour | undefined {
-	return toursForRoute(tours, routeId).find((tour) => !isSeen(tour, seen));
+  return toursForRoute(tours, routeId).find((tour) => !isSeen(tour, seen));
 }
 
 /** What replay starts: a named tour, or the page's first one whether or not it was seen. */
 export function pickForReplay(
-	tours: readonly Tour[],
-	routeId: string | null | undefined,
-	tourId?: string,
+  tours: readonly Tour[],
+  routeId: string | null | undefined,
+  tourId?: string,
 ): Tour | undefined {
-	if (tourId) return tours.find((tour) => tour.id === tourId);
-	return toursForRoute(tours, routeId)[0];
+  if (tourId) return tours.find((tour) => tour.id === tourId);
+  return toursForRoute(tours, routeId)[0];
 }
 
 /** Keeps the steps whose target is on the page. A tour with none left starts nothing. */
-export function keepFoundSteps(steps: readonly Step[], exists: (selector: string) => boolean): Step[] {
-	return steps.filter((step) => exists(step.target));
+export function keepFoundSteps(
+  steps: readonly Step[],
+  exists: (selector: string) => boolean,
+): Step[] {
+  return steps.filter((step) => exists(step.target));
 }