@remit/web-client 0.0.86 → 0.0.88

package/src/lib/search-token-index.test.ts

@@ -6,7 +6,9 @@ import type {
 } from "@remit/api-http-client/types.gen.ts";
 import {
 	buildAccountNameIndex,
+	buildAccountSuggestionValues,
 	buildMailboxNameIndex,
+	buildMailboxSuggestionValues,
 } from "./search-token-index.js";
 
 const account = (
@@ -110,3 +112,100 @@ describe("buildMailboxNameIndex", () => {
 		assert.deepEqual(buildMailboxNameIndex([]), new Map());
 	});
 });
+
+describe("buildMailboxSuggestionValues", () => {
+	it("offers the leaf when no other folder shares it", () => {
+		const [offer] = buildMailboxSuggestionValues([
+			[mailbox({ mailboxId: "mb-1", fullPath: "INBOX/Archive" })],
+		]);
+		assert.equal(offer?.value, "Archive");
+		assert.equal(offer?.label, "Archive");
+	});
+
+	it("offers the full path where the leaf would be ambiguous", () => {
+		const offers = buildMailboxSuggestionValues([
+			[mailbox({ mailboxId: "mb-1", fullPath: "INBOX/Archive" })],
+			[mailbox({ mailboxId: "mb-2", fullPath: "Work/archive" })],
+		]);
+		assert.deepEqual(
+			offers.map((offer) => offer.value),
+			["INBOX/Archive", "Work/archive"],
+		);
+	});
+
+	it("every offer resolves back through the index it was built beside", () => {
+		const lists = [
+			[
+				mailbox({ mailboxId: "mb-1", fullPath: "INBOX" }),
+				mailbox({ mailboxId: "mb-2", fullPath: "INBOX/Archive" }),
+			],
+			[mailbox({ mailboxId: "mb-3", fullPath: "Team/Archive" })],
+		];
+		const index = buildMailboxNameIndex(lists);
+		for (const offer of buildMailboxSuggestionValues(lists)) {
+			assert.ok(index.has(offer.value.toLowerCase()), offer.value);
+		}
+	});
+
+	it("reads the folder's own name, a rename winning over the path", () => {
+		const [offer] = buildMailboxSuggestionValues([
+			[
+				mailbox({
+					mailboxId: "mb-1",
+					fullPath: "INBOX/Archief",
+					displayNameOverride: " Archive ",
+				}),
+			],
+		]);
+		assert.equal(offer?.value, "Archief");
+		assert.equal(offer?.label, "Archive");
+	});
+
+	it("names the account only where more than one is loaded", () => {
+		const lists = [[mailbox({ mailboxId: "mb-1", fullPath: "Archive" })]];
+		const accounts = [
+			account({ accountId: "account-1", email: "me@example.com" }),
+		];
+		assert.equal(
+			buildMailboxSuggestionValues(lists, accounts)[0]?.hint,
+			undefined,
+		);
+		assert.equal(
+			buildMailboxSuggestionValues(lists, [
+				...accounts,
+				account({ accountId: "account-2", email: "work@example.com" }),
+			])[0]?.hint,
+			"me@example.com",
+		);
+	});
+});
+
+describe("buildAccountSuggestionValues", () => {
+	it("offers the local part, read as the account's own name", () => {
+		const [offer] = buildAccountSuggestionValues([
+			account({
+				accountId: "acct-1",
+				email: "work@company.com",
+				displayName: "Work",
+			}),
+		]);
+		assert.equal(offer?.value, "work");
+		assert.equal(offer?.label, "Work");
+		assert.equal(offer?.hint, "work@company.com");
+	});
+
+	it("offers the whole address where the local part is ambiguous", () => {
+		const offers = buildAccountSuggestionValues([
+			account({ accountId: "acct-1", email: "work@company.com" }),
+			account({ accountId: "acct-2", email: "work@other.com" }),
+		]);
+		assert.deepEqual(
+			offers.map((offer) => offer.value),
+			["work@company.com", "work@other.com"],
+		);
+		assert.deepEqual(
+			offers.map((offer) => offer.label),
+			["work@company.com", "work@other.com"],
+		);
+	});
+});

package/src/lib/search-token-index.ts

@@ -1,13 +1,20 @@
 /**
  * Builds the name -> id indexes `parseSearchTokens` uses to resolve `in:` and
- * `account:` tokens (#428 follow-up, see doc/design/flows/06-search.md). Pure
+ * `account:` tokens (#428 follow-up, see doc/design/flows/06-search.md), and the
+ * same names as the values the search box offers for those tokens. Pure
  * functions over already-loaded data; the caller owns fetching accounts and
  * mailboxes (`useMailboxNameIndex` fans out the mailbox-list queries).
+ *
+ * The offers are built from the same lists as the indexes so that every value on
+ * the list resolves back to the folder or account it was built from: what the
+ * box suggests and what the parser accepts cannot drift apart.
  */
 import type {
 	RemitImapAccountResponse,
 	RemitImapMailboxResponse,
 } from "@remit/api-http-client/types.gen.ts";
+import { getMailboxDisplayName } from "./folder-roles.js";
+import type { SearchSuggestionValue } from "./search-suggestions.js";
 
 /**
  * Account email (and its local-part before `@`) -> accountId, lower-cased.
@@ -54,3 +61,62 @@ export function buildMailboxNameIndex(
 	}
 	return index;
 }
+
+/**
+ * The folders `in:` can name, in the shortest spelling that still resolves to
+ * the folder it names: the leaf where no other folder shares it, the full path
+ * where one does — the same rule the index resolves by, from the other side.
+ *
+ * The row reads the folder's own name (a user's rename wins) and carries the
+ * account it belongs to whenever more than one is loaded, because two accounts
+ * with an Archive each are otherwise two identical rows.
+ */
+export function buildMailboxSuggestionValues(
+	mailboxesByAccount: readonly RemitImapMailboxResponse[][],
+	accounts: readonly RemitImapAccountResponse[] = [],
+): SearchSuggestionValue[] {
+	const all = mailboxesByAccount.flat().filter((mailbox) => mailbox.fullPath);
+	const leafCounts = new Map<string, number>();
+	for (const mailbox of all) {
+		const leaf = getMailboxDisplayName(mailbox.fullPath).toLowerCase();
+		leafCounts.set(leaf, (leafCounts.get(leaf) ?? 0) + 1);
+	}
+	const emailByAccountId = new Map(
+		accounts.map((account) => [account.accountId, account.email]),
+	);
+	return all.map((mailbox) => {
+		const leaf = getMailboxDisplayName(mailbox.fullPath);
+		const unique = leafCounts.get(leaf.toLowerCase()) === 1;
+		const hint =
+			accounts.length > 1 ? emailByAccountId.get(mailbox.accountId) : undefined;
+		return {
+			value: unique ? leaf : mailbox.fullPath,
+			label: mailbox.displayNameOverride?.trim() || leaf,
+			...(hint ? { hint } : {}),
+		};
+	});
+}
+
+/**
+ * The accounts `account:` can name — the local part where it is unambiguous,
+ * the whole address where it is not — read as the account's own name.
+ */
+export function buildAccountSuggestionValues(
+	accounts: readonly RemitImapAccountResponse[],
+): SearchSuggestionValue[] {
+	const localPartCounts = new Map<string, number>();
+	for (const account of accounts) {
+		const localPart = account.email.toLowerCase().split("@")[0] ?? "";
+		localPartCounts.set(localPart, (localPartCounts.get(localPart) ?? 0) + 1);
+	}
+	return accounts.map((account) => {
+		const localPart = account.email.split("@")[0] ?? account.email;
+		const unique = localPartCounts.get(localPart.toLowerCase()) === 1;
+		const displayName = account.displayName?.trim();
+		return {
+			value: unique ? localPart : account.email,
+			label: displayName || account.email,
+			...(displayName ? { hint: account.email } : {}),
+		};
+	});
+}

package/src/lib/search-tokens.test.ts

@@ -2,8 +2,14 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import {
 	parseSearchTokens,
+	quoteSearchTokenValue,
 	removeSearchToken,
+	SEARCH_TOKEN_SPECS,
+	type SearchToken,
 	searchTokenLabel,
+	searchTokenSpec,
+	splitSearchTerm,
+	splitSearchWords,
 } from "./search-tokens.js";
 
 describe("parseSearchTokens", () => {
@@ -25,6 +31,14 @@ describe("parseSearchTokens", () => {
 		]);
 	});
 
+	it("parses subject:", () => {
+		const result = parseSearchTokens("subject:invoice tax");
+		assert.equal(result.freeText, "tax");
+		assert.deepEqual(result.tokens, [
+			{ type: "subject", raw: "subject:invoice", value: "invoice" },
+		]);
+	});
+
 	it("parses has:attachment", () => {
 		const result = parseSearchTokens("receipts has:attachment");
 		assert.equal(result.freeText, "receipts");
@@ -33,12 +47,70 @@ describe("parseSearchTokens", () => {
 		]);
 	});
 
+	it("leaves an unknown has: value as free text", () => {
+		const result = parseSearchTokens("has:pictures receipts");
+		assert.equal(result.freeText, "has:pictures receipts");
+		assert.deepEqual(result.tokens, []);
+	});
+
 	it("parses is:unread case-insensitively", () => {
 		const result = parseSearchTokens("IS:UNREAD receipts");
 		assert.equal(result.freeText, "receipts");
 		assert.deepEqual(result.tokens, [{ type: "isUnread", raw: "IS:UNREAD" }]);
 	});
 
+	it("parses is:read as its own state, not the absence of unread", () => {
+		const result = parseSearchTokens("is:read receipts");
+		assert.equal(result.freeText, "receipts");
+		assert.deepEqual(result.tokens, [{ type: "isRead", raw: "is:read" }]);
+	});
+
+	it("parses is:starred and its is:flagged wire spelling alike", () => {
+		assert.deepEqual(parseSearchTokens("is:starred").tokens, [
+			{ type: "isStarred", raw: "is:starred" },
+		]);
+		assert.deepEqual(parseSearchTokens("is:flagged").tokens, [
+			{ type: "isStarred", raw: "is:flagged" },
+		]);
+	});
+
+	it("leaves an unknown is: value as free text", () => {
+		const result = parseSearchTokens("is:important receipts");
+		assert.equal(result.freeText, "is:important receipts");
+		assert.deepEqual(result.tokens, []);
+	});
+
+	it("parses category: against the message-category vocabulary", () => {
+		const result = parseSearchTokens("category:Personal invoice");
+		assert.equal(result.freeText, "invoice");
+		assert.deepEqual(result.tokens, [
+			{
+				type: "category",
+				raw: "category:Personal",
+				value: "Personal",
+				category: "personal",
+			},
+		]);
+	});
+
+	it("accepts the label the chips show for the pending category", () => {
+		const result = parseSearchTokens("category:unclassified");
+		assert.deepEqual(result.tokens, [
+			{
+				type: "category",
+				raw: "category:unclassified",
+				value: "unclassified",
+				category: "uncategorized",
+			},
+		]);
+	});
+
+	it("leaves an unknown category as free text", () => {
+		const result = parseSearchTokens("category:urgent invoice");
+		assert.equal(result.freeText, "category:urgent invoice");
+		assert.deepEqual(result.tokens, []);
+	});
+
 	it("parses before: and after: as epoch seconds", () => {
 		const result = parseSearchTokens("after:2024-01-01 before:2024-02-01 tax");
 		assert.equal(result.freeText, "tax");
@@ -143,6 +215,137 @@ describe("parseSearchTokens", () => {
 		assert.equal(result.freeText, "from:");
 		assert.deepEqual(result.tokens, []);
 	});
+
+	it("leaves an unknown token as free text rather than erroring", () => {
+		const result = parseSearchTokens("label:urgent to:bob invoice");
+		assert.equal(result.freeText, "label:urgent to:bob invoice");
+		assert.deepEqual(result.tokens, []);
+	});
+
+	it("takes a quoted value as one term", () => {
+		const result = parseSearchTokens('in:"Sent Items" invoice', {
+			mailboxesByName: new Map([["sent items", "mailbox-2"]]),
+		});
+		assert.equal(result.freeText, "invoice");
+		assert.deepEqual(result.tokens, [
+			{
+				type: "in",
+				raw: 'in:"Sent Items"',
+				value: "Sent Items",
+				mailboxId: "mailbox-2",
+			},
+		]);
+	});
+
+	it("reads an unterminated quote to the end, so a half-typed value still parses", () => {
+		const result = parseSearchTokens('subject:"quarterly report');
+		assert.deepEqual(result.tokens, [
+			{
+				type: "subject",
+				raw: 'subject:"quarterly report',
+				value: "quarterly report",
+			},
+		]);
+	});
+
+	it("keeps quoted free text as it was typed", () => {
+		const result = parseSearchTokens('"exact phrase" is:unread');
+		assert.equal(result.freeText, '"exact phrase"');
+		assert.equal(result.tokens.length, 1);
+	});
+});
+
+describe("splitSearchWords", () => {
+	it("reports where each term sits in the query", () => {
+		assert.deepEqual(splitSearchWords("a  bc"), [
+			{ raw: "a", start: 0, end: 1 },
+			{ raw: "bc", start: 3, end: 5 },
+		]);
+	});
+
+	it("keeps a quoted run together", () => {
+		assert.deepEqual(splitSearchWords('in:"Sent Items" x'), [
+			{ raw: 'in:"Sent Items"', start: 0, end: 15 },
+			{ raw: "x", start: 16, end: 17 },
+		]);
+	});
+
+	it("has no terms in an empty query", () => {
+		assert.deepEqual(splitSearchWords("   "), []);
+	});
+});
+
+describe("splitSearchTerm", () => {
+	it("splits at the first colon and lower-cases the name", () => {
+		assert.deepEqual(splitSearchTerm("From:a:b"), {
+			name: "from",
+			value: "a:b",
+			rawValue: "a:b",
+		});
+	});
+
+	it("unquotes the value", () => {
+		assert.deepEqual(splitSearchTerm('in:"Sent Items"'), {
+			name: "in",
+			value: "Sent Items",
+			rawValue: '"Sent Items"',
+		});
+	});
+
+	it("is not a token attempt without a name before the colon", () => {
+		assert.equal(splitSearchTerm("invoice"), undefined);
+		assert.equal(splitSearchTerm(":30"), undefined);
+	});
+});
+
+describe("quoteSearchTokenValue", () => {
+	it("quotes a value with whitespace and leaves a bare one alone", () => {
+		assert.equal(quoteSearchTokenValue("Sent Items"), '"Sent Items"');
+		assert.equal(quoteSearchTokenValue("Archive"), "Archive");
+	});
+
+	it("round-trips through the parser", () => {
+		const query = `in:${quoteSearchTokenValue("Sent Items")}`;
+		const result = parseSearchTokens(query, {
+			mailboxesByName: new Map([["sent items", "mailbox-2"]]),
+		});
+		assert.equal(result.tokens.length, 1);
+		assert.equal(result.freeText, "");
+	});
+});
+
+describe("SEARCH_TOKEN_SPECS", () => {
+	it("carries a spec for every name the parser accepts", () => {
+		for (const spec of SEARCH_TOKEN_SPECS) {
+			assert.equal(searchTokenSpec(spec.name)?.name, spec.name);
+		}
+	});
+
+	it("offers only values that parse to a token", () => {
+		for (const spec of SEARCH_TOKEN_SPECS) {
+			for (const option of spec.options ?? []) {
+				const { tokens } = parseSearchTokens(`${spec.name}:${option.value}`);
+				assert.equal(
+					tokens.length,
+					1,
+					`${spec.name}:${option.value} did not parse`,
+				);
+			}
+		}
+	});
+
+	it("names every category the API carries", () => {
+		const category = SEARCH_TOKEN_SPECS.find((s) => s.name === "category");
+		assert.deepEqual(category?.options?.map((o) => o.value).sort(), [
+			"automated",
+			"marketing",
+			"newsletter",
+			"personal",
+			"social",
+			"transactional",
+			"uncategorized",
+		]);
+	});
 });
 
 describe("removeSearchToken", () => {
@@ -155,6 +358,17 @@ describe("removeSearchToken", () => {
 		assert.equal(next, "parcel delivery");
 	});
 
+	it("removes a quoted token whole", () => {
+		const query = 'invoice in:"Sent Items" tax';
+		const token: SearchToken = {
+			type: "in",
+			raw: 'in:"Sent Items"',
+			value: "Sent Items",
+			mailboxId: "mailbox-2",
+		};
+		assert.equal(removeSearchToken(query, token), "invoice tax");
+	});
+
 	it("is a no-op when the token isn't present", () => {
 		const next = removeSearchToken("parcel delivery", {
 			type: "hasAttachment",
@@ -170,6 +384,23 @@ describe("searchTokenLabel", () => {
 			searchTokenLabel({ type: "from", raw: "from:alice", value: "alice" }),
 			"From: alice",
 		);
+		assert.equal(
+			searchTokenLabel({
+				type: "subject",
+				raw: "subject:invoice",
+				value: "invoice",
+			}),
+			"Subject: invoice",
+		);
+		assert.equal(
+			searchTokenLabel({
+				type: "category",
+				raw: "category:uncategorized",
+				value: "uncategorized",
+				category: "uncategorized",
+			}),
+			"Category: Unclassified",
+		);
 		assert.equal(
 			searchTokenLabel({ type: "hasAttachment", raw: "has:attachment" }),
 			"Has attachment",
@@ -178,6 +409,11 @@ describe("searchTokenLabel", () => {
 			searchTokenLabel({ type: "isUnread", raw: "is:unread" }),
 			"Unread",
 		);
+		assert.equal(searchTokenLabel({ type: "isRead", raw: "is:read" }), "Read");
+		assert.equal(
+			searchTokenLabel({ type: "isStarred", raw: "is:starred" }),
+			"Starred",
+		);
 		assert.equal(
 			searchTokenLabel({
 				type: "before",