@remit/web-client 0.0.76 → 0.0.78

package/src/components/settings/LabelsList.tsx

@@ -0,0 +1,112 @@
+import type { RemitImapLabelResponse } from "@remit/api-http-client/types.gen.ts";
+import { Button, Input, LabelChip, labelColorOptions, Select } from "@remit/ui";
+import { Trash2 } from "lucide-react";
+import { useState } from "react";
+
+interface LabelsListProps {
+	labels: RemitImapLabelResponse[];
+	onRename: (labelId: string, name: string) => void;
+	onRecolor: (labelId: string, color: string) => void;
+	onDelete: (label: RemitImapLabelResponse) => void;
+	deletingLabelId?: string;
+}
+
+/**
+ * The account's labels, each renamable and recolorable inline and deletable
+ * with the cascade-confirming dialog the caller opens (issue #26). Mirrors
+ * `FiltersList`'s row shape: a name, a color chip, and a destructive action.
+ */
+export function LabelsList({
+	labels,
+	onRename,
+	onRecolor,
+	onDelete,
+	deletingLabelId,
+}: LabelsListProps) {
+	const [editingId, setEditingId] = useState<string>();
+	const [draftName, setDraftName] = useState("");
+
+	if (labels.length === 0) {
+		return (
+			<p className="py-6 text-sm text-fg-muted">
+				No labels yet. Create one below, then use it in a filter or apply it to
+				mail directly.
+			</p>
+		);
+	}
+
+	const commitRename = (labelId: string) => {
+		const trimmed = draftName.trim();
+		if (trimmed !== "") onRename(labelId, trimmed);
+		setEditingId(undefined);
+	};
+
+	return (
+		<ul className="divide-y divide-line rounded-md border border-line">
+			{labels.map((label) => (
+				<li key={label.labelId} className="flex items-center gap-3 px-3 py-2.5">
+					<div className="min-w-0 flex-1">
+						{editingId === label.labelId ? (
+							<Input
+								autoFocus
+								value={draftName}
+								onChange={(event) => setDraftName(event.target.value)}
+								onBlur={() => commitRename(label.labelId)}
+								onKeyDown={(event) => {
+									if (event.key === "Enter") {
+										event.preventDefault();
+										commitRename(label.labelId);
+									}
+									if (event.key === "Escape") {
+										event.preventDefault();
+										setEditingId(undefined);
+									}
+								}}
+								aria-label={`Rename label ${label.name}`}
+							/>
+						) : (
+							<button
+								type="button"
+								onClick={() => {
+									setEditingId(label.labelId);
+									setDraftName(label.name);
+								}}
+								aria-label={`Rename label ${label.name}`}
+								className="flex items-center gap-2 rounded-sm text-left hover:opacity-80"
+							>
+								<LabelChip label={label} />
+							</button>
+						)}
+						<p className="mt-0.5 text-xs text-fg-subtle">
+							{label.filterCount === 0
+								? "Not used in any filter"
+								: `Used in ${label.filterCount} ${
+										label.filterCount === 1 ? "filter" : "filters"
+									}`}
+						</p>
+					</div>
+					<Select
+						aria-label={`Color for ${label.name}`}
+						value={label.color}
+						onChange={(event) => onRecolor(label.labelId, event.target.value)}
+						className="w-28 shrink-0"
+					>
+						{labelColorOptions.map((color) => (
+							<option key={color} value={color}>
+								{color}
+							</option>
+						))}
+					</Select>
+					<Button
+						variant="ghost"
+						size="sm"
+						icon={<Trash2 className="size-4 text-danger" />}
+						onClick={() => onDelete(label)}
+						disabled={deletingLabelId === label.labelId}
+						aria-label={`Delete label ${label.name}`}
+					/>
+				</li>
+			))}
+		</ul>
+	);
+}

package/src/components/settings/settings-filter.stories.tsx

@@ -1,5 +1,5 @@
 import type { RemitImapFilterResponse } from "@remit/api-http-client/types.gen.ts";
-import { BottomSheet, type FolderOption } from "@remit/ui";
+import { BottomSheet, type FolderOption, type LabelOption } from "@remit/ui";
 import type { Meta, StoryObj } from "@storybook/react-vite";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import type { ReactNode } from "react";
@@ -24,6 +24,11 @@ const FOLDERS: FolderOption[] = [
 	{ id: "mbx-travel", label: "Travel" },
 ];
 
+const LABELS: LabelOption[] = [
+	{ id: "lbl-receipts", name: "Receipts", color: "Blue" },
+	{ id: "lbl-travel", name: "Travel", color: "Green" },
+];
+
 const makeFilter = (
 	overrides: Partial<RemitImapFilterResponse> = {},
 ): RemitImapFilterResponse => ({
@@ -104,6 +109,7 @@ export const EditStandingRule: Story = {
 				accountId={ACCOUNT_ID}
 				filter={makeFilter()}
 				folders={FOLDERS}
+				labels={LABELS}
 				onClose={() => undefined}
 			/>
 		</SheetStage>
@@ -119,6 +125,7 @@ export const EditAnchoredRule: Story = {
 				accountId={ACCOUNT_ID}
 				filter={makeFilter({ hasAnchor: true, name: "GitHub" })}
 				folders={FOLDERS}
+				labels={LABELS}
 				onClose={() => undefined}
 			/>
 		</SheetStage>
@@ -138,6 +145,7 @@ export const EditUntilADate: Story = {
 					expiresAt: "2027-09-01T23:59:59+00:00",
 				})}
 				folders={FOLDERS}
+				labels={LABELS}
 				onClose={() => undefined}
 			/>
 		</SheetStage>
@@ -157,6 +165,7 @@ export const DegradedAnchor: Story = {
 				accountId={ACCOUNT_ID}
 				filter={makeFilter({ hasAnchor: true, name: "Newsletters" })}
 				folders={FOLDERS}
+				labels={LABELS}
 				semanticUnavailable
 				onClose={() => undefined}
 			/>

package/src/hooks/useApplyLabel.ts

@@ -0,0 +1,68 @@
+import { messageBulkOperationsUpdateMessageLabelsMutation } from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import type {
+	RemitImapLabelAction,
+	RemitImapThreadMessageResponse,
+} from "@remit/api-http-client/types.gen.ts";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+import { useErrorBanners } from "@/components/ui/ErrorBannerProvider";
+import { formatErrorDetail } from "@/components/ui/error-banners";
+import { resolveMailboxesForMessages } from "@/hooks/useMarkAsRead";
+import {
+	invalidateThreadListQueries,
+	threadListCacheKeys,
+} from "@/lib/thread-list-cache";
+
+/**
+ * Apply or remove a label on a "just these" selection (issue #26, RFC 034
+ * recap). No optimistic patch: a label is metadata on the row, not something
+ * that removes it from the current view, so settling on the server response
+ * and invalidating is enough — unlike a move or delete, which the row leaves
+ * immediately.
+ */
+export const useApplyLabel = (options: {
+	mailboxId: string;
+	accountId?: string;
+	/** The threads the selection may span, for resolving which mailbox lists to invalidate. */
+	messages?: RemitImapThreadMessageResponse[];
+}) => {
+	const { mailboxId, messages } = options;
+	const queryClient = useQueryClient();
+	const { pushError } = useErrorBanners();
+
+	const { mutate, isPending } = useMutation({
+		...messageBulkOperationsUpdateMessageLabelsMutation(),
+		onError: (error, variables) => {
+			pushError({
+				title:
+					variables.body.action === "Remove"
+						? "Couldn't remove label"
+						: "Couldn't apply label",
+				detail: formatErrorDetail(error),
+				error,
+			});
+		},
+		onSettled: (_data, _error, variables) => {
+			invalidateThreadListQueries(
+				queryClient,
+				threadListCacheKeys(
+					resolveMailboxesForMessages(
+						variables.body.messageIds ?? [],
+						messages ?? [],
+						mailboxId,
+					),
+				),
+			);
+		},
+	});
+
+	const applyLabel = useCallback(
+		(messageIds: string[], labelId: string, action: RemitImapLabelAction) => {
+			if (messageIds.length === 0) return;
+			mutate({ body: { messageIds, labelId, action } });
+		},
+		[mutate],
+	);
+
+	return { applyLabel, isPending };
+};

package/src/hooks/useLabels.ts

@@ -0,0 +1,124 @@
+import {
+	labelDetailOperationsDeleteLabelMutation,
+	labelDetailOperationsUpdateLabelMutation,
+	labelOperationsCreateLabelMutation,
+	labelOperationsListLabelsOptions,
+	labelOperationsListLabelsQueryKey,
+} from "@remit/api-http-client/@tanstack/react-query.gen.ts";
+import type {
+	RemitImapLabelColor,
+	RemitImapUpdateLabelInput,
+} from "@remit/api-http-client/types.gen.ts";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useCallback } from "react";
+
+/**
+ * The query key the label list reads and every mutation invalidates on
+ * success — the same contract `buildFilterListKey` pins for filters, so the
+ * settings list and the rule editor's label picker never go stale after a
+ * label is created, renamed, recolored, or deleted (issue #26).
+ */
+export const buildLabelListKey = (accountId: string) =>
+	labelOperationsListLabelsQueryKey({ path: { accountId } });
+
+/** List the account's labels. */
+export const useLabelList = (accountId: string | undefined) => {
+	const query = useQuery({
+		...labelOperationsListLabelsOptions({
+			path: { accountId: accountId ?? "" },
+		}),
+		enabled: !!accountId,
+	});
+
+	return {
+		labels: query.data?.items ?? [],
+		isPending: query.isPending,
+		isError: query.isError,
+		error: query.error,
+		refetch: query.refetch,
+	};
+};
+
+export const useCreateLabel = (accountId: string | undefined) => {
+	const queryClient = useQueryClient();
+	const mutation = useMutation({
+		...labelOperationsCreateLabelMutation(),
+		onSuccess: () => {
+			if (!accountId) return;
+			queryClient.invalidateQueries({ queryKey: buildLabelListKey(accountId) });
+		},
+	});
+	const { mutateAsync } = mutation;
+
+	const createLabel = useCallback(
+		(name: string, color: RemitImapLabelColor = "Default") => {
+			if (!accountId) return Promise.reject(new Error("No account"));
+			return mutateAsync({ path: { accountId }, body: { name, color } });
+		},
+		[accountId, mutateAsync],
+	);
+
+	return {
+		createLabel,
+		isPending: mutation.isPending,
+		isError: mutation.isError,
+		error: mutation.error,
+		reset: mutation.reset,
+	};
+};
+
+export const useUpdateLabel = (accountId: string | undefined) => {
+	const queryClient = useQueryClient();
+	const mutation = useMutation({
+		...labelDetailOperationsUpdateLabelMutation(),
+		onSuccess: () => {
+			if (!accountId) return;
+			queryClient.invalidateQueries({ queryKey: buildLabelListKey(accountId) });
+		},
+	});
+	const { mutate } = mutation;
+
+	const updateLabel = useCallback(
+		(labelId: string, input: RemitImapUpdateLabelInput) => {
+			if (!accountId) return;
+			mutate({ path: { accountId, labelId }, body: input });
+		},
+		[accountId, mutate],
+	);
+
+	return {
+		updateLabel,
+		isPending: mutation.isPending,
+		updatingLabelId: mutation.isPending
+			? mutation.variables?.path.labelId
+			: undefined,
+	};
+};
+
+export const useDeleteLabel = (accountId: string | undefined) => {
+	const queryClient = useQueryClient();
+	const mutation = useMutation({
+		...labelDetailOperationsDeleteLabelMutation(),
+		onSuccess: () => {
+			if (!accountId) return;
+			queryClient.invalidateQueries({ queryKey: buildLabelListKey(accountId) });
+		},
+	});
+	const { mutate } = mutation;
+
+	const deleteLabel = useCallback(
+		(labelId: string) => {
+			if (!accountId) return;
+			mutate({ path: { accountId, labelId } });
+		},
+		[accountId, mutate],
+	);
+
+	return {
+		deleteLabel,
+		isPending: mutation.isPending,
+		deletingLabelId: mutation.isPending
+			? mutation.variables?.path.labelId
+			: undefined,
+	};
+};

package/src/hooks/useRuleEditorState.ts

@@ -28,6 +28,7 @@ export interface RuleEditorState {
 		onRemoveWiden: () => void;
 		onChangeMatchOperator: (matchOperator: MatchOperator) => void;
 		onChangeMove: (mailboxId: string) => void;
+		onChangeLabel: (labelId: string) => void;
 		onChangeScope: (scope: RuleScope) => void;
 		onChangeName: (name: string) => void;
 		onChangeUntil: (until: string) => void;
@@ -141,6 +142,12 @@ export const useRuleEditorState = ({
 			moveMailboxId: mailboxId || undefined,
 		}));
 
+	const changeLabel = (labelId: string) =>
+		setRuleState((current) => ({
+			...current,
+			labelId: labelId || undefined,
+		}));
+
 	const changeScope = (scope: RuleScope) =>
 		setRuleState((current) => ({ ...current, scope }));
 
@@ -166,6 +173,7 @@ export const useRuleEditorState = ({
 			onRemoveWiden: removeWiden,
 			onChangeMatchOperator: changeMatchOperator,
 			onChangeMove: changeMove,
+			onChangeLabel: changeLabel,
 			onChangeScope: changeScope,
 			onChangeName: changeName,
 			onChangeUntil: changeUntil,

package/src/lib/inbox-filters.test.ts

@@ -0,0 +1,106 @@
+import assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import { applyInboxFilters } from "./inbox-filters.js";
+
+// Only the fields the filter reads, following the fixture idiom in
+// starred-rows.test.ts.
+const thread = (
+	fields: Partial<RemitImapThreadMessageResponse> & { messageId: string },
+): RemitImapThreadMessageResponse =>
+	({ isRead: false, ...fields }) as unknown as RemitImapThreadMessageResponse;
+
+const personal = thread({ messageId: "m1", category: "personal" });
+const unclassified = thread({ messageId: "m2", category: "uncategorized" });
+const preClassification = thread({ messageId: "m3" });
+
+const ids = (threads: RemitImapThreadMessageResponse[]): string[] =>
+	threads.map((t) => t.messageId);
+
+describe("applyInboxFilters", () => {
+	test("returns the loaded list when nothing narrows it", () => {
+		const threads = [personal, unclassified, preClassification];
+		assert.deepEqual(applyInboxFilters(threads, "all", new Set()), threads);
+	});
+
+	test("matches a thread whose category is set", () => {
+		assert.deepEqual(
+			ids(applyInboxFilters([personal, unclassified], "personal", new Set())),
+			["m1"],
+		);
+	});
+
+	test("counts a thread with no category as unclassified (#45)", () => {
+		// A pre-classification thread already renders an `uncategorized` badge,
+		// so the Unclassified chip has to find the row the user can see. Reading
+		// the response field raw made that row vanish under its own chip.
+		assert.deepEqual(
+			ids(
+				applyInboxFilters(
+					[personal, unclassified, preClassification],
+					"uncategorized",
+					new Set(),
+				),
+			),
+			["m2", "m3"],
+		);
+	});
+
+	test("never lets unclassified mail answer to personal (#45)", () => {
+		assert.deepEqual(
+			applyInboxFilters(
+				[unclassified, preClassification],
+				"personal",
+				new Set(),
+			),
+			[],
+		);
+	});
+
+	test("applies attribute predicates alongside a category", () => {
+		const read = thread({
+			messageId: "m4",
+			category: "personal",
+			isRead: true,
+		});
+		assert.deepEqual(
+			ids(applyInboxFilters([personal, read], "personal", new Set(["unread"]))),
+			["m1"],
+		);
+	});
+
+	test("applies attribute predicates without a category", () => {
+		const read = thread({
+			messageId: "m4",
+			category: "newsletter",
+			isRead: true,
+		});
+		assert.deepEqual(
+			ids(applyInboxFilters([personal, read], "all", new Set(["unread"]))),
+			["m1"],
+		);
+	});
+
+	test("matches starred and attachment threads", () => {
+		const starred = thread({ messageId: "m5", hasStars: true });
+		const withAttachment = thread({ messageId: "m6", hasAttachment: true });
+		const plain = thread({ messageId: "m7" });
+		const threads = [starred, withAttachment, plain];
+		assert.deepEqual(
+			ids(applyInboxFilters(threads, "all", new Set(["flagged"]))),
+			["m5"],
+		);
+		assert.deepEqual(
+			ids(applyInboxFilters(threads, "all", new Set(["attachment"]))),
+			["m6"],
+		);
+	});
+
+	test("ignores an attribute id with no predicate behind it", () => {
+		const threads = [personal, unclassified];
+		assert.deepEqual(
+			applyInboxFilters(threads, "all", new Set(["nonsense"])),
+			threads,
+		);
+	});
+});

package/src/lib/inbox-filters.ts

@@ -0,0 +1,44 @@
+import type { RemitImapThreadMessageResponse } from "@remit/api-http-client/types.gen.ts";
+import { toDisplayCategory } from "./display-category.js";
+
+/**
+ * Inbox filter predicates — the inbox preset offers Unread / Starred / Has
+ * attachment (never accounts; an inbox is one account already). The `flagged`
+ * id is the wire name for IMAP \Flagged; the label is "Starred".
+ */
+const INBOX_FILTER_PREDICATES: Record<
+	string,
+	(t: RemitImapThreadMessageResponse) => boolean
+> = {
+	unread: (t) => !t.isRead,
+	flagged: (t) => t.hasStars === true,
+	attachment: (t) => Boolean(t.hasAttachment),
+};
+
+/**
+ * Narrow the loaded threads to one category and a set of attributes. Applied
+ * over the loaded pages until #306 moves the predicate into the query.
+ *
+ * The category comparison goes through `toDisplayCategory` so the inbox agrees
+ * with Starred and the brief, which filter mapped rows. `category` is optional
+ * on the response and absent reads as `uncategorized` everywhere else — a
+ * pre-classification thread renders an `uncategorized` badge, so a raw
+ * comparison made the row you can see vanish under its own chip (#45).
+ */
+export function applyInboxFilters(
+	threads: RemitImapThreadMessageResponse[],
+	category: string,
+	attributes: ReadonlySet<string>,
+): RemitImapThreadMessageResponse[] {
+	const predicates = Array.from(attributes)
+		.map((id) => INBOX_FILTER_PREDICATES[id])
+		.filter(
+			(p): p is (t: RemitImapThreadMessageResponse) => boolean => p != null,
+		);
+	if (category === "all" && predicates.length === 0) return threads;
+	return threads.filter(
+		(t) =>
+			(category === "all" || toDisplayCategory(t.category) === category) &&
+			predicates.every((p) => p(t)),
+	);
+}

package/src/lib/organize/filter-edit-model.test.ts

@@ -58,6 +58,16 @@ describe("filterToRule", () => {
 		assert.equal(rule.moveMailboxId, undefined);
 	});
 
+	it("loads a label action (issue #26)", () => {
+		const rule = filterToRule(filter({ actionLabelId: "lbl-1" }));
+		assert.equal(rule.labelId, "lbl-1");
+	});
+
+	it("maps the None label sentinel to no action", () => {
+		const rule = filterToRule(filter({ actionLabelId: "None" }));
+		assert.equal(rule.labelId, undefined);
+	});
+
 	it("loads a Temporary filter as an until-a-date rule", () => {
 		const rule = filterToRule(
 			filter({ scope: "Temporary", expiresAt: "2027-03-04T23:59:59+00:00" }),
@@ -131,6 +141,13 @@ describe("ruleChangesPredicateOrAction", () => {
 			true,
 		);
 	});
+
+	it("is true when the label target changes (issue #26)", () => {
+		assert.equal(
+			ruleChangesPredicateOrAction({ ...base, labelId: "lbl-new" }, base),
+			true,
+		);
+	});
 });
 
 describe("ruleChangesScopeOrExpiry (reader #266)", () => {
@@ -212,6 +229,27 @@ describe("buildUpdateFilterInput", () => {
 		assert.equal(body.actionMailboxId, "None");
 	});
 
+	it("sends a chosen label target (issue #26)", () => {
+		const changed: FilterRule = {
+			...original,
+			labelId: "lbl-receipts",
+			matchOperator: "any",
+		};
+		const body = buildUpdateFilterInput(changed, original);
+		assert.equal(body.actionLabelId, "lbl-receipts");
+	});
+
+	it("drops a cleared label target to the None sentinel", () => {
+		const withLabel = { ...original, labelId: "lbl-receipts" };
+		const changed = {
+			...withLabel,
+			labelId: undefined,
+			matchOperator: "any" as const,
+		};
+		const body = buildUpdateFilterInput(changed, withLabel);
+		assert.equal(body.actionLabelId, "None");
+	});
+
 	it("is empty when nothing changed", () => {
 		assert.deepEqual(buildUpdateFilterInput(original, original), {});
 	});

package/src/lib/organize/filter-edit-model.ts

@@ -14,8 +14,9 @@ import { NO_ACTION } from "./organize-model";
  * cannot evaluate it (D4) — the rule then matches by its literal clauses only.
  *
  * The scope maps `Standing` → "standing" and `Temporary` → "until"; a persisted
- * filter is never the one-time "once" scope. `moveMailboxId` drops the `"None"`
- * sentinel to `undefined` so an empty folder select reads as "no move action".
+ * filter is never the one-time "once" scope. `moveMailboxId` and `labelId` both
+ * drop the `"None"` sentinel to `undefined` so an empty select reads as "no
+ * action" (issue #26).
  */
 export const filterToRule = (
 	filter: RemitImapFilterResponse,
@@ -34,6 +35,8 @@ export const filterToRule = (
 			: undefined,
 		moveMailboxId:
 			filter.actionMailboxId !== NO_ACTION ? filter.actionMailboxId : undefined,
+		labelId:
+			filter.actionLabelId !== NO_ACTION ? filter.actionLabelId : undefined,
 		scope: filter.scope === "Temporary" ? "until" : "standing",
 		until:
 			filter.scope === "Temporary"
@@ -65,15 +68,16 @@ const predicateActionKey = (rule: FilterRule): string =>
 		clauses: rule.clauses.map((clause) => [clause.field, clause.value]),
 		operator: rule.matchOperator,
 		move: rule.moveMailboxId ?? null,
+		label: rule.labelId ?? null,
 		widen: rule.widen ? (rule.widen.inactive ? "inactive" : "active") : "none",
 	});
 
 /**
  * Whether the edited rule changes the predicate or the action versus the one it
- * was loaded from — the clauses, the match operator, the move target, or the
- * widen's presence. A change here is what bumps `ruleChangedAt` and offers the
- * re-back-apply (RFC 034 Decision 3.2); the name is deliberately excluded, so a
- * cosmetic rename is not a rule change.
+ * was loaded from — the clauses, the match operator, the move target, the
+ * label target, or the widen's presence. A change here is what bumps
+ * `ruleChangedAt` and offers the re-back-apply (RFC 034 Decision 3.2); the name
+ * is deliberately excluded, so a cosmetic rename is not a rule change.
  */
 export const ruleChangesPredicateOrAction = (
 	rule: FilterRule,
@@ -104,10 +108,10 @@ export const ruleChangesScopeOrExpiry = (
  * The PATCH body for an edited filter. A cosmetic rename sends `{ name }` only,
  * so the server's `changesRuleAssertion` guard leaves `ruleChangedAt`
  * untouched (RFC 034 Decision 3.2). A predicate or action change sends the
- * operator, clauses, and move target; a scope or expiry change sends `scope`
- * and, for the `until` scope, `expiresAt` (reader #266) — either bumps
- * `ruleChangedAt`. The label action and the anchor are never in the editor's
- * gift, so they never enter the patch; the partial update preserves them.
+ * operator, clauses, move target, and label target; a scope or expiry change
+ * sends `scope` and, for the `until` scope, `expiresAt` (reader #266) —
+ * either bumps `ruleChangedAt`. The anchor is never in the editor's gift, so
+ * it never enters the patch; the partial update preserves it.
  */
 export const buildUpdateFilterInput = (
 	rule: FilterRule,
@@ -123,6 +127,7 @@ export const buildUpdateFilterInput = (
 			value: clause.value,
 		}));
 		body.actionMailboxId = rule.moveMailboxId ?? NO_ACTION;
+		body.actionLabelId = rule.labelId ?? NO_ACTION;
 	}
 	if (ruleChangesScopeOrExpiry(rule, original)) {
 		body.scope = rule.scope === "until" ? "Temporary" : "Standing";

package/src/lib/organize/label-delete-copy.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { deleteLabelConfirmCopy } from "./label-delete-copy";
+
+describe("deleteLabelConfirmCopy", () => {
+	it("names the label with no blast-radius note when no filter uses it", () => {
+		const copy = deleteLabelConfirmCopy("Receipts", 0);
+		assert.equal(copy.title, 'Delete the "Receipts" label?');
+		assert.equal(copy.description, undefined);
+	});
+
+	it("names exactly one filter in the singular", () => {
+		const copy = deleteLabelConfirmCopy("Receipts", 1);
+		assert.match(copy.description ?? "", /1 filter that applies it/);
+	});
+
+	it("names several filters in the plural", () => {
+		const copy = deleteLabelConfirmCopy("Receipts", 3);
+		assert.match(copy.description ?? "", /3 filters that apply it/);
+	});
+});