@heyramzi/ui 2.1.0 → 2.2.0

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));
 }

package/src/onboarding/stores.test.ts

@@ -3,101 +3,101 @@ import { localStorageStore, memoryStore } from "./stores.js";
 import type { SeenStore } from "./types.js";
 
 function fakeStorage(): Storage {
-	const data = new Map<string, string>();
-	return {
-		get length() {
-			return data.size;
-		},
-		clear: () => data.clear(),
-		getItem: (key) => data.get(key) ?? null,
-		key: (i) => [...data.keys()][i] ?? null,
-		removeItem: (key) => void data.delete(key),
-		setItem: (key, value) => void data.set(key, String(value)),
-	};
+  const data = new Map<string, string>();
+  return {
+    get length() {
+      return data.size;
+    },
+    clear: () => data.clear(),
+    getItem: (key) => data.get(key) ?? null,
+    key: (i) => [...data.keys()][i] ?? null,
+    removeItem: (key) => void data.delete(key),
+    setItem: (key, value) => void data.set(key, String(value)),
+  };
 }
 
 function behavesLikeAStore(make: () => SeenStore) {
-	it("starts empty", async () => {
-		expect(await make().load()).toEqual({});
-	});
+  it("starts empty", async () => {
+    expect(await make().load()).toEqual({});
+  });
 
-	it("remembers the version it saw", async () => {
-		const store = make();
-		await store.markSeen("home", 1, "completed");
-		await store.markSeen("board", 2, "dismissed");
-		expect(await store.load()).toEqual({ home: 1, board: 2 });
-	});
+  it("remembers the version it saw", async () => {
+    const store = make();
+    await store.markSeen("home", 1, "completed");
+    await store.markSeen("board", 2, "dismissed");
+    expect(await store.load()).toEqual({ home: 1, board: 2 });
+  });
 
-	it("never goes back to an older version", async () => {
-		const store = make();
-		await store.markSeen("home", 3, "completed");
-		await store.markSeen("home", 2, "completed");
-		expect((await store.load()).home).toBe(3);
-	});
+  it("never goes back to an older version", async () => {
+    const store = make();
+    await store.markSeen("home", 3, "completed");
+    await store.markSeen("home", 2, "completed");
+    expect((await store.load()).home).toBe(3);
+  });
 
-	it("resets one tour or all of them", async () => {
-		const store = make();
-		await store.markSeen("home", 1, "completed");
-		await store.markSeen("board", 1, "completed");
-		await store.reset("home");
-		expect(await store.load()).toEqual({ board: 1 });
-		await store.reset();
-		expect(await store.load()).toEqual({});
-	});
+  it("resets one tour or all of them", async () => {
+    const store = make();
+    await store.markSeen("home", 1, "completed");
+    await store.markSeen("board", 1, "completed");
+    await store.reset("home");
+    expect(await store.load()).toEqual({ board: 1 });
+    await store.reset();
+    expect(await store.load()).toEqual({});
+  });
 }
 
 describe("memoryStore", () => {
-	behavesLikeAStore(() => memoryStore());
+  behavesLikeAStore(() => memoryStore());
 
-	it("takes a starting state and keeps its own copy", async () => {
-		const initial = { home: 1 };
-		const store = memoryStore(initial);
-		await store.markSeen("board", 1, "completed");
-		expect(initial).toEqual({ home: 1 });
-		expect(await store.load()).toEqual({ home: 1, board: 1 });
-	});
+  it("takes a starting state and keeps its own copy", async () => {
+    const initial = { home: 1 };
+    const store = memoryStore(initial);
+    await store.markSeen("board", 1, "completed");
+    expect(initial).toEqual({ home: 1 });
+    expect(await store.load()).toEqual({ home: 1, board: 1 });
+  });
 });
 
 describe("localStorageStore", () => {
-	beforeEach(() => {
-		vi.stubGlobal("localStorage", fakeStorage());
-	});
-	afterEach(() => {
-		vi.unstubAllGlobals();
-	});
+  beforeEach(() => {
+    vi.stubGlobal("localStorage", fakeStorage());
+  });
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
 
-	behavesLikeAStore(() => localStorageStore());
+  behavesLikeAStore(() => localStorageStore());
 
-	it("shares state between two stores on one key and keeps keys apart", async () => {
-		await localStorageStore("a").markSeen("home", 1, "completed");
-		expect(await localStorageStore("a").load()).toEqual({ home: 1 });
-		expect(await localStorageStore("b").load()).toEqual({});
-	});
+  it("shares state between two stores on one key and keeps keys apart", async () => {
+    await localStorageStore("a").markSeen("home", 1, "completed");
+    expect(await localStorageStore("a").load()).toEqual({ home: 1 });
+    expect(await localStorageStore("b").load()).toEqual({});
+  });
 
-	it("reads corrupt or foreign data as empty", async () => {
-		localStorage.setItem("heyramzi:onboarding", "{nope");
-		expect(await localStorageStore().load()).toEqual({});
-		localStorage.setItem("heyramzi:onboarding", JSON.stringify(["x"]));
-		expect(await localStorageStore().load()).toEqual({});
-		localStorage.setItem("heyramzi:onboarding", JSON.stringify({ home: 1, bad: "yes" }));
-		expect(await localStorageStore().load()).toEqual({ home: 1 });
-	});
+  it("reads corrupt or foreign data as empty", async () => {
+    localStorage.setItem("heyramzi:onboarding", "{nope");
+    expect(await localStorageStore().load()).toEqual({});
+    localStorage.setItem("heyramzi:onboarding", JSON.stringify(["x"]));
+    expect(await localStorageStore().load()).toEqual({});
+    localStorage.setItem("heyramzi:onboarding", JSON.stringify({ home: 1, bad: "yes" }));
+    expect(await localStorageStore().load()).toEqual({ home: 1 });
+  });
 
-	it("doesn't throw when storage is blocked", async () => {
-		vi.stubGlobal("localStorage", {
-			getItem: () => {
-				throw new Error("blocked");
-			},
-			setItem: () => {
-				throw new Error("blocked");
-			},
-			removeItem: () => {
-				throw new Error("blocked");
-			},
-		});
-		const store = localStorageStore();
-		expect(await store.load()).toEqual({});
-		await expect(store.markSeen("home", 1, "completed")).resolves.toBeUndefined();
-		await expect(store.reset()).resolves.toBeUndefined();
-	});
+  it("doesn't throw when storage is blocked", async () => {
+    vi.stubGlobal("localStorage", {
+      getItem: () => {
+        throw new Error("blocked");
+      },
+      setItem: () => {
+        throw new Error("blocked");
+      },
+      removeItem: () => {
+        throw new Error("blocked");
+      },
+    });
+    const store = localStorageStore();
+    expect(await store.load()).toEqual({});
+    await expect(store.markSeen("home", 1, "completed")).resolves.toBeUndefined();
+    await expect(store.reset()).resolves.toBeUndefined();
+  });
 });

package/src/onboarding/stores.ts

@@ -5,54 +5,56 @@ type Seen = Record<string, number>;
 
 /** Holds seen-state in memory. Tests and previews. */
 export function memoryStore(initial: Seen = {}): SeenStore {
-	let seen: Seen = { ...initial };
-	return {
-		async load() {
-			return { ...seen };
-		},
-		async markSeen(tourId, version, _outcome: Outcome) {
-			seen[tourId] = Math.max(seen[tourId] ?? 0, version);
-		},
-		async reset(tourId) {
-			if (tourId === undefined) seen = {};
-			else delete seen[tourId];
-		},
-	};
+  let seen: Seen = { ...initial };
+  return {
+    async load() {
+      return { ...seen };
+    },
+    async markSeen(tourId, version, _outcome: Outcome) {
+      seen[tourId] = Math.max(seen[tourId] ?? 0, version);
+    },
+    async reset(tourId) {
+      if (tourId === undefined) seen = {};
+      else delete seen[tourId];
+    },
+  };
 }
 
 function readSeen(key: string): Seen {
-	const read = tryCatch(() => JSON.parse(localStorage.getItem(key) ?? "{}") as unknown);
-	const parsed = read.ok ? read.value : null;
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
-	return Object.fromEntries(
-		Object.entries(parsed).filter((entry): entry is [string, number] => typeof entry[1] === "number"),
-	);
+  const read = tryCatch(() => JSON.parse(localStorage.getItem(key) ?? "{}") as unknown);
+  const parsed = read.ok ? read.value : null;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  return Object.fromEntries(
+    Object.entries(parsed).filter(
+      (entry): entry is [string, number] => typeof entry[1] === "number",
+    ),
+  );
 }
 
 // Blocked storage (private mode, a full disk) means the tour shows again next visit, which beats an error.
 function writeSeen(key: string, seen: Seen): void {
-	tryCatch(() => localStorage.setItem(key, JSON.stringify(seen)));
+  tryCatch(() => localStorage.setItem(key, JSON.stringify(seen)));
 }
 
 /** Keeps seen-state in this browser. Demos and signed-out pages. */
 export function localStorageStore(key = "heyramzi:onboarding"): SeenStore {
-	return {
-		async load() {
-			return readSeen(key);
-		},
-		async markSeen(tourId, version, _outcome: Outcome) {
-			const seen = readSeen(key);
-			seen[tourId] = Math.max(seen[tourId] ?? 0, version);
-			writeSeen(key, seen);
-		},
-		async reset(tourId) {
-			if (tourId === undefined) {
-				tryCatch(() => localStorage.removeItem(key));
-				return;
-			}
-			const seen = readSeen(key);
-			delete seen[tourId];
-			writeSeen(key, seen);
-		},
-	};
+  return {
+    async load() {
+      return readSeen(key);
+    },
+    async markSeen(tourId, version, _outcome: Outcome) {
+      const seen = readSeen(key);
+      seen[tourId] = Math.max(seen[tourId] ?? 0, version);
+      writeSeen(key, seen);
+    },
+    async reset(tourId) {
+      if (tourId === undefined) {
+        tryCatch(() => localStorage.removeItem(key));
+        return;
+      }
+      const seen = readSeen(key);
+      delete seen[tourId];
+      writeSeen(key, seen);
+    },
+  };
 }