@remit/web-client 0.0.325 → 0.0.327

package/src/lib/dedupe-thread-messages.test.ts

@@ -1,79 +0,0 @@
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
-import { dedupeThreadMessages } from "./dedupe-thread-messages.js";
-
-function threadMessage(
-	overrides: Partial<RemitImapThreadMessageResponse> = {},
-): RemitImapThreadMessageResponse {
-	return {
-		threadId: "t1",
-		threadMessageId: "tm1",
-		messageId: "m1",
-		accountConfigId: "cfg_1",
-		mailboxId: "mb1",
-		fromName: "Sender",
-		fromEmail: "sender@example.com",
-		subject: "Subject",
-		snippet: "Snippet",
-		category: "uncategorized",
-		sentDate: 1767225600,
-		isRead: false,
-		isDeleted: false,
-		hasAttachment: false,
-		hasStars: false,
-		star: "none",
-		senderTrust: "unknown",
-		status: "active",
-		syncStatus: "pending",
-		abandonedMutation: "none",
-		muted: false,
-		createdAt: 0,
-		updatedAt: 0,
-		...overrides,
-	};
-}
-
-describe("dedupeThreadMessages (#166)", () => {
-	test("collapses an overlapping page to one row per threadMessageId", () => {
-		const pageOne = [
-			threadMessage({ threadMessageId: "tm1", messageId: "m1" }),
-			threadMessage({ threadMessageId: "tm2", messageId: "m2" }),
-		];
-		const pageTwo = [
-			threadMessage({ threadMessageId: "tm2", messageId: "m2" }),
-			threadMessage({ threadMessageId: "tm3", messageId: "m3" }),
-		];
-
-		const got = dedupeThreadMessages([...pageOne, ...pageTwo]);
-
-		assert.deepStrictEqual(
-			got.map((item) => item.threadMessageId),
-			["tm1", "tm2", "tm3"],
-		);
-	});
-
-	test("keeps the first occurrence's data when duplicates disagree", () => {
-		const items = [
-			threadMessage({ threadMessageId: "tm1", isRead: false }),
-			threadMessage({ threadMessageId: "tm1", isRead: true }),
-		];
-
-		const got = dedupeThreadMessages(items);
-
-		assert.equal(got.length, 1);
-		assert.equal(got[0].isRead, false);
-	});
-
-	test("leaves non-overlapping pages unaffected", () => {
-		const items = [
-			threadMessage({ threadMessageId: "tm1", messageId: "m1" }),
-			threadMessage({ threadMessageId: "tm2", messageId: "m2" }),
-			threadMessage({ threadMessageId: "tm3", messageId: "m3" }),
-		];
-
-		const got = dedupeThreadMessages(items);
-
-		assert.deepStrictEqual(got, items);
-	});
-});

package/src/lib/dedupe-thread-messages.ts

@@ -1,26 +0,0 @@
-import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
-
-/**
- * Pure helper: collapse a flattened list of thread messages to one row per
- * `threadMessageId`, keeping the first occurrence.
- *
- * Belt-and-braces guard for issue #166. The web client appends every fetched
- * page as-is and relies on the keyset cursor never handing back an overlapping
- * page. `threadMessageId` is unique per message, so two rows sharing one are
- * the same message — dropping the later row removes a duplicate, never a
- * distinct result. Applied where pages are flattened into the list, so every
- * consumer of the list sees a clean array and no render site has to remember
- * to dedupe.
- */
-export const dedupeThreadMessages = (
-	items: RemitImapThreadMessageResponse[],
-): RemitImapThreadMessageResponse[] => {
-	const seen = new Set<string>();
-	const deduped: RemitImapThreadMessageResponse[] = [];
-	for (const item of items) {
-		if (seen.has(item.threadMessageId)) continue;
-		seen.add(item.threadMessageId);
-		deduped.push(item);
-	}
-	return deduped;
-};

package/src/lib/delete-folder.test.ts

@@ -1,304 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import {
-	advanceMove,
-	beginMove,
-	elapsedLabel,
-	excludeFolder,
-	type FolderNode,
-	failMove,
-	guardFolderDeletion,
-	hasChildFolders,
-	initialStage,
-	moveProgressLabel,
-	vouchedRole,
-} from "./delete-folder.js";
-
-const folder = (
-	over: Partial<FolderNode> & { mailboxId: string },
-): FolderNode => ({
-	fullPath: over.mailboxId,
-	hierarchyDelimiter: "/",
-	messageCount: 0,
-	...over,
-});
-
-describe("guardFolderDeletion", () => {
-	it("blocks the inbox by its reserved path, case-insensitively", () => {
-		const target = folder({ mailboxId: "a", fullPath: "InBoX" });
-		const guard = guardFolderDeletion(target, [target], []);
-		assert.equal(guard.deletable, false);
-		assert.equal(guard.reason, "inbox");
-		assert.match(guard.message ?? "", /inbox can't be deleted/i);
-	});
-
-	it("blocks a folder appointed to a canonical role and names the role", () => {
-		const target = folder({ mailboxId: "arch", fullPath: "Archive" });
-		const guard = guardFolderDeletion(
-			target,
-			[target],
-			[{ role: "Archive", source: "Appointed", mailboxId: "arch" }],
-		);
-		assert.equal(guard.deletable, false);
-		assert.equal(guard.reason, "role");
-		assert.match(guard.message ?? "", /Archive/);
-	});
-
-	it("blocks a folder the mail server flagged for the role", () => {
-		const target = folder({ mailboxId: "sent", fullPath: "Sent" });
-		const guard = guardFolderDeletion(
-			target,
-			[target],
-			[{ role: "Sent", source: "Flagged", mailboxId: "sent" }],
-		);
-		assert.equal(guard.deletable, false);
-		assert.equal(guard.reason, "role");
-	});
-
-	it("deletes a folder whose only role claim is a name proposal", () => {
-		const target = folder({ mailboxId: "arch", fullPath: "Archive" });
-		const guard = guardFolderDeletion(
-			target,
-			[target],
-			[{ role: "Archive", source: "Proposed", mailboxId: "arch" }],
-		);
-		assert.deepEqual(guard, { deletable: true });
-	});
-
-	it("deletes the name-proposed fallback a stale appointment resolves to", () => {
-		const target = folder({ mailboxId: "deleted-items", fullPath: "Deleted" });
-		const guard = guardFolderDeletion(
-			target,
-			[target],
-			[{ role: "Trash", source: "Stale", mailboxId: "deleted-items" }],
-		);
-		assert.deepEqual(guard, { deletable: true });
-	});
-
-	it("blocks the flagged folder a stale appointment falls back to", () => {
-		const target = folder({
-			mailboxId: "server-trash",
-			fullPath: "Trash",
-			specialUse: ["Trash"],
-		});
-		const guard = guardFolderDeletion(
-			target,
-			[target],
-			[{ role: "Trash", source: "Stale", mailboxId: "server-trash" }],
-		);
-		assert.equal(guard.deletable, false);
-		assert.equal(guard.reason, "role");
-		assert.match(guard.message ?? "", /Trash/);
-	});
-
-	it("reads the flag for the role the entry names, not any flag the folder has", () => {
-		const target = folder({
-			mailboxId: "archive",
-			fullPath: "Archive",
-			specialUse: ["Archive"],
-		});
-		const guard = guardFolderDeletion(
-			target,
-			[target],
-			[{ role: "Trash", source: "Stale", mailboxId: "archive" }],
-		);
-		assert.deepEqual(guard, { deletable: true });
-	});
-
-	it("blocks a folder that has subfolders", () => {
-		const target = folder({ mailboxId: "work", fullPath: "Work" });
-		const child = folder({ mailboxId: "sub", fullPath: "Work/Shop" });
-		const guard = guardFolderDeletion(target, [target, child], []);
-		assert.equal(guard.deletable, false);
-		assert.equal(guard.reason, "children");
-		assert.match(guard.message ?? "", /subfolders/i);
-	});
-
-	it("allows a plain leaf folder with no role and no children", () => {
-		const target = folder({
-			mailboxId: "r",
-			fullPath: "Receipts",
-			messageCount: 4,
-		});
-		const other = folder({ mailboxId: "n", fullPath: "News" });
-		const guard = guardFolderDeletion(
-			target,
-			[target, other],
-			[{ role: "Archive", source: "Appointed", mailboxId: "other-box" }],
-		);
-		assert.deepEqual(guard, { deletable: true });
-	});
-
-	it("ignores an unfilled role appointment with no mailbox", () => {
-		const target = folder({ mailboxId: "r", fullPath: "Receipts" });
-		const guard = guardFolderDeletion(
-			target,
-			[target],
-			[{ role: "Junk", source: "None" }],
-		);
-		assert.equal(guard.deletable, true);
-	});
-});
-
-describe("hasChildFolders", () => {
-	it("treats a delimiter-separated nested path as a child", () => {
-		const parent = {
-			mailboxId: "p",
-			fullPath: "Work",
-			hierarchyDelimiter: "/",
-		};
-		const kids = [{ mailboxId: "c", fullPath: "Work/Q3" }];
-		assert.equal(hasChildFolders(parent, [...kids, parent]), true);
-	});
-
-	it("does not treat a shared string prefix without a delimiter as a child", () => {
-		const parent = {
-			mailboxId: "p",
-			fullPath: "Work",
-			hierarchyDelimiter: "/",
-		};
-		const lookalike = [{ mailboxId: "w", fullPath: "Workshop" }];
-		assert.equal(hasChildFolders(parent, [...lookalike, parent]), false);
-	});
-
-	it("honours a non-slash delimiter", () => {
-		const parent = {
-			mailboxId: "p",
-			fullPath: "INBOX",
-			hierarchyDelimiter: ".",
-		};
-		const kids = [{ mailboxId: "c", fullPath: "INBOX.Sub" }];
-		assert.equal(hasChildFolders(parent, [...kids, parent]), true);
-	});
-});
-
-describe("vouchedRole", () => {
-	it("returns the role a mailbox fills", () => {
-		assert.equal(
-			vouchedRole({ mailboxId: "a" }, [
-				{ role: "Trash", source: "Appointed", mailboxId: "a" },
-			]),
-			"Trash",
-		);
-	});
-
-	it("returns undefined when the mailbox fills no role", () => {
-		assert.equal(
-			vouchedRole({ mailboxId: "a" }, [
-				{ role: "Trash", source: "Appointed", mailboxId: "b" },
-			]),
-			undefined,
-		);
-	});
-
-	it("returns undefined for a role nobody vouched for", () => {
-		assert.equal(
-			vouchedRole({ mailboxId: "a" }, [
-				{ role: "Trash", source: "Proposed", mailboxId: "a" },
-			]),
-			undefined,
-		);
-	});
-
-	it("returns the role a stale entry falls back to when the server flags it", () => {
-		assert.equal(
-			vouchedRole({ mailboxId: "a", specialUse: ["Trash"] }, [
-				{ role: "Trash", source: "Stale", mailboxId: "a" },
-			]),
-			"Trash",
-		);
-	});
-});
-
-describe("excludeFolder", () => {
-	it("drops the folder being deleted from the destination list", () => {
-		const targets = [
-			{ mailboxId: "a" },
-			{ mailboxId: "b" },
-			{ mailboxId: "c" },
-		];
-		assert.deepEqual(excludeFolder(targets, "b"), [
-			{ mailboxId: "a" },
-			{ mailboxId: "c" },
-		]);
-	});
-});
-
-describe("move progress", () => {
-	it("begins at zero and moving for a non-empty set", () => {
-		assert.deepEqual(beginMove(120), { total: 120, moved: 0, phase: "moving" });
-	});
-
-	it("begins already moved for an empty set", () => {
-		assert.deepEqual(beginMove(0), { total: 0, moved: 0, phase: "moved" });
-	});
-
-	it("advances by the batch size and finishes at the total", () => {
-		let progress = beginMove(150);
-		progress = advanceMove(progress, 100);
-		assert.deepEqual(progress, { total: 150, moved: 100, phase: "moving" });
-		progress = advanceMove(progress, 50);
-		assert.deepEqual(progress, { total: 150, moved: 150, phase: "moved" });
-	});
-
-	it("clamps moved to the total if the folder shrank underneath the count", () => {
-		const progress = advanceMove(beginMove(80), 100);
-		assert.equal(progress.moved, 80);
-		assert.equal(progress.phase, "moved");
-	});
-
-	it("stops progress on failure and does not advance afterwards", () => {
-		const failed = failMove(beginMove(150), "boom");
-		assert.equal(failed.phase, "failed");
-		assert.equal(failed.moved, 0);
-		const after = advanceMove(failed, 100);
-		assert.deepEqual(after, failed);
-	});
-
-	it("labels progress as moved-of-total", () => {
-		assert.equal(
-			moveProgressLabel({ total: 150, moved: 100, phase: "moving" }),
-			"Moved 100 of 150",
-		);
-	});
-});
-
-describe("elapsedLabel", () => {
-	it("counts a wait in minutes and padded seconds", () => {
-		assert.equal(elapsedLabel(0), "0:00");
-		assert.equal(elapsedLabel(9_400), "0:09");
-		assert.equal(elapsedLabel(65_000), "1:05");
-		assert.equal(elapsedLabel(600_000), "10:00");
-	});
-
-	it("reads a backwards clock as no time at all", () => {
-		assert.equal(elapsedLabel(-5_000), "0:00");
-	});
-});
-
-describe("initialStage", () => {
-	it("opens on the empty confirm for a folder with no mail", () => {
-		assert.equal(initialStage(0), "confirm-empty");
-	});
-
-	it("opens on the fate choice for a folder holding mail", () => {
-		assert.equal(initialStage(3), "choose-fate");
-	});
-});
-
-describe("hasChildFolders in a flat namespace", () => {
-	it("does not read a shared prefix as a child", () => {
-		const target = folder({
-			mailboxId: "work",
-			fullPath: "Work",
-			hierarchyDelimiter: "",
-		});
-		assert.equal(
-			hasChildFolders(target, [
-				target,
-				{ mailboxId: "shop", fullPath: "Workshop" },
-			]),
-			false,
-		);
-	});
-});

package/src/lib/delete-folder.ts

@@ -1,188 +0,0 @@
-import type { RemitImapFolderAppointment } from "@remit/api-http-client/types.gen.ts";
-
-export const MOVE_BATCH_SIZE = 100;
-
-export interface FolderNode {
-	mailboxId: string;
-	fullPath: string;
-	hierarchyDelimiter: string;
-	messageCount: number;
-	/** RFC 6154 SPECIAL-USE flags, bare (`Trash`, not `\Trash`). */
-	specialUse?: readonly string[];
-}
-
-/** Where a role's answer came from. */
-export type RoleAppointmentSource = RemitImapFolderAppointment["source"];
-
-export interface RoleAppointment {
-	role: string;
-	source: RoleAppointmentSource;
-	mailboxId?: string | null;
-}
-
-export type DeleteBlockReason = "inbox" | "role" | "children";
-
-export interface DeleteGuard {
-	deletable: boolean;
-	reason?: DeleteBlockReason;
-	message?: string;
-}
-
-const isInboxPath = (fullPath: string): boolean =>
-	fullPath.trim().toLowerCase() === "inbox";
-
-/**
- * A folder has children when another mailbox's path is nested under it — the
- * folder's own path followed by the hierarchy delimiter. The delimiter matters:
- * `Work` is not a parent of `Workshop`, only of `Work/Shop`. A server that
- * reports no delimiter has a flat namespace, where nothing nests at all.
- */
-export const hasChildFolders = (
-	folder: Pick<FolderNode, "mailboxId" | "fullPath" | "hierarchyDelimiter">,
-	all: readonly Pick<FolderNode, "mailboxId" | "fullPath">[],
-): boolean => {
-	if (folder.hierarchyDelimiter.length === 0) return false;
-	const prefix = `${folder.fullPath}${folder.hierarchyDelimiter}`;
-	return all.some(
-		(other) =>
-			other.mailboxId !== folder.mailboxId && other.fullPath.startsWith(prefix),
-	);
-};
-
-/**
- * Sources that vouch for the mailbox they name: a person chose it, or the
- * server flagged it. `Proposed` is a guess at a folder's name and vouches for
- * nothing. `Reserved` is unreachable behind the inbox branch below and stays
- * anyway — this set is a statement about evidence, not about branch order.
- */
-const VOUCHED_SOURCES: readonly RoleAppointmentSource[] = [
-	"Appointed",
-	"Flagged",
-	"Reserved",
-];
-
-/**
- * A `Stale` entry resolves to whatever the account would have had with no
- * appointment at all, and that fallback can be the folder the server itself
- * flags for the role. The entry no longer carries which it was, so read the
- * flag off the folder: the mail server's designation is unchanged by the
- * user's own choice going missing, and nothing behind this guard re-checks it.
- * Flag values are the bare RFC 6154 names, identical to the canonical roles.
- */
-const vouchesFor = (
-	appointment: RoleAppointment,
-	folder: Pick<FolderNode, "mailboxId" | "specialUse">,
-): boolean => {
-	if (appointment.mailboxId !== folder.mailboxId) return false;
-	if (appointment.source === "Stale")
-		return folder.specialUse?.includes(appointment.role) ?? false;
-	return VOUCHED_SOURCES.includes(appointment.source);
-};
-
-/** The canonical role a folder is vouched for, or `undefined` when none is. */
-export const vouchedRole = (
-	folder: Pick<FolderNode, "mailboxId" | "specialUse">,
-	appointments: readonly RoleAppointment[],
-): string | undefined => appointments.find((a) => vouchesFor(a, folder))?.role;
-
-/**
- * Why a folder can't be deleted, or `{ deletable: true }` when it can. The
- * inbox is reserved, a folder somebody vouched for in a canonical role must be
- * released first, and a folder with subfolders must have them handled before it
- * goes. A role a folder only fills because its name reads that way is no reason
- * to keep the folder: the message would name a remedy that does not apply.
- */
-export function guardFolderDeletion(
-	folder: FolderNode,
-	all: readonly FolderNode[],
-	appointments: readonly RoleAppointment[],
-): DeleteGuard {
-	if (isInboxPath(folder.fullPath))
-		return {
-			deletable: false,
-			reason: "inbox",
-			message: "The inbox can't be deleted.",
-		};
-
-	const role = vouchedRole(folder, appointments);
-	if (role)
-		return {
-			deletable: false,
-			reason: "role",
-			message: `This folder is your ${role} folder. Reassign that role before deleting it.`,
-		};
-
-	if (hasChildFolders(folder, all))
-		return {
-			deletable: false,
-			reason: "children",
-			message: "This folder has subfolders. Delete them first.",
-		};
-
-	return { deletable: true };
-}
-
-/** Destinations with the folder being deleted removed. */
-export function excludeFolder<T extends { mailboxId: string }>(
-	targets: readonly T[],
-	excludeMailboxId: string,
-): T[] {
-	return targets.filter((target) => target.mailboxId !== excludeMailboxId);
-}
-
-export type MovePhase = "moving" | "moved" | "failed";
-
-export interface MoveProgress {
-	total: number;
-	moved: number;
-	phase: MovePhase;
-	error?: string;
-}
-
-/** Progress at the start of a move; an empty set is already `moved`. */
-export function beginMove(total: number): MoveProgress {
-	return { total, moved: 0, phase: total === 0 ? "moved" : "moving" };
-}
-
-/**
- * Count a successful batch. Clamps to `total` so a folder that grew mid-move
- * never shows more moved than started, and only a still-`moving` progress
- * advances — a failed or finished move stays put.
- */
-export function advanceMove(
-	progress: MoveProgress,
-	batchSize: number,
-): MoveProgress {
-	if (progress.phase !== "moving") return progress;
-	const moved = Math.min(
-		progress.total,
-		progress.moved + Math.max(0, batchSize),
-	);
-	return {
-		...progress,
-		moved,
-		phase: moved >= progress.total ? "moved" : "moving",
-	};
-}
-
-/** A failed batch stops progress and surfaces the error; nothing advances after. */
-export function failMove(progress: MoveProgress, error: string): MoveProgress {
-	return { ...progress, phase: "failed", error };
-}
-
-export function moveProgressLabel(progress: MoveProgress): string {
-	return `Moved ${progress.moved} of ${progress.total}`;
-}
-
-/** How long a wait has run, as `m:ss` — clamped at zero so a clock skew reads as 0:00. */
-export function elapsedLabel(ms: number): string {
-	const seconds = Math.max(0, Math.floor(ms / 1000));
-	return `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
-}
-
-/** Where the wizard opens: a straight confirm for an empty folder, otherwise the fate step. */
-export function initialStage(
-	messageCount: number,
-): "confirm-empty" | "choose-fate" {
-	return messageCount > 0 ? "choose-fate" : "confirm-empty";
-}

package/src/lib/desktop-breakpoint.test.ts

@@ -1,76 +0,0 @@
-import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { dirname, resolve } from "node:path";
-import { describe, it } from "node:test";
-import { fileURLToPath } from "node:url";
-import { DESKTOP_MEDIA_QUERY } from "@remit/ui";
-import { compile } from "tailwindcss";
-
-const here = dirname(fileURLToPath(import.meta.url));
-
-const entryStylesheets = {
-	app: resolve(here, "../index.css"),
-	workbench: resolve(here, "../../../workbench/.storybook/tailwind.css"),
-};
-
-const loadStylesheet = async (id: string, base: string) => {
-	const require = createRequire(resolve(base, "resolve-from-here.js"));
-	const path =
-		id.startsWith(".") || id.startsWith("/")
-			? resolve(base, id)
-			: resolveCssExport(require, id);
-	return { path, base: dirname(path), content: await readFile(path, "utf8") };
-};
-
-const resolveCssExport = (require: NodeRequire, id: string): string => {
-	const direct = tryResolve(require, id);
-	if (direct?.endsWith(".css")) return direct;
-	return require.resolve(`${id}/index.css`);
-};
-
-const tryResolve = (require: NodeRequire, id: string): string | undefined => {
-	try {
-		return require.resolve(id);
-	} catch {
-		return undefined;
-	}
-};
-
-/**
- * The media condition Tailwind wraps a utility in, read back off the compiled
- * stylesheet. Building one candidate at a time keeps a single rule inside the
- * block, so the prelude immediately precedes it.
- */
-const compiledMediaConditionFor = async (
-	stylesheet: string,
-	utility: string,
-): Promise<string> => {
-	const compiler = await compile(await readFile(stylesheet, "utf8"), {
-		base: dirname(stylesheet),
-		loadStylesheet,
-	});
-	const css = compiler.build([utility]);
-	const escaped = utility.replace(/:/g, "\\\\:");
-	const match = css.match(
-		new RegExp(`@media ([^\\n{]+?)\\s*\\{\\s*\\.${escaped}\\s*\\{`),
-	);
-	assert.ok(match, `${utility} emitted no media-wrapped rule in ${stylesheet}`);
-	return match[1];
-};
-
-describe("the lg variant and the desktop hooks gate on the same condition", () => {
-	// Regression: the desktop gate used to be a bare 1024px width, so a large
-	// tablet in portrait — exactly 1024px wide — got the four-pane desktop
-	// shell. Two systems encode the gate: DESKTOP_MEDIA_QUERY drives the JS
-	// hooks, and Tailwind's `lg` variant (redefined in @remit/ui's token sheet)
-	// drives the CSS chrome. If either moves alone the app splits in half.
-	for (const [name, stylesheet] of Object.entries(entryStylesheets)) {
-		it(`compiles lg:hidden in the ${name} stylesheet to DESKTOP_MEDIA_QUERY`, async () => {
-			assert.equal(
-				await compiledMediaConditionFor(stylesheet, "lg:hidden"),
-				DESKTOP_MEDIA_QUERY,
-			);
-		});
-	}
-});