@remit/ui 0.0.56 → 0.0.58

package/src/index.ts

@@ -71,6 +71,11 @@ export {
 	BottomSheet,
 	type BottomSheetProps,
 } from "./components/bottom-sheet.js";
+export {
+	BriefEmpty,
+	type BriefEmptyProps,
+	type BriefSyncProgress,
+} from "./components/brief-empty.js";
 export {
 	BriefSection,
 	type BriefSectionProps,
@@ -143,23 +148,31 @@ export {
 	clauseFieldOrder,
 	commitBlockedReason,
 	commitLabel,
+	demoClauseSuggestions,
 	demoFolders,
 	demoLabels,
 	demoRule,
 	demoSenderFallbackRule,
+	demoSubjectPrefillRule,
 	demoVocabularyRule,
 	type FilterRule,
 	type FolderOption,
+	hasActiveWiden,
 	type LabelOption,
 	type MatchOperator,
+	matchesBodyText,
 	matchJoinWord,
+	matchModeHint,
+	matchModeLabel,
 	matchOperatorLabel,
 	type PreviewCount,
 	previewCountSummary,
 	type RuleClause,
+	type RuleMatchMode,
 	type RuleScope,
 	type RuleWiden,
 	scopeLabel,
+	unreadableBodyClauses,
 	widenChipLabel,
 } from "./components/filter-rule.js";
 export {
@@ -302,6 +315,10 @@ export {
 	type OutboxStatusBadgeProps,
 	outboxStatusConfig,
 } from "./components/outbox-status-badge.js";
+export {
+	PasswordInput,
+	type PasswordInputProps,
+} from "./components/password-input.js";
 export {
 	PopoverMenu,
 	type PopoverMenuItem,
@@ -397,9 +414,11 @@ export {
 } from "./components/row-actions.js";
 export { SearchBar, type SearchBarProps } from "./components/search-bar.js";
 export {
+	type SearchCaretRequest,
 	type SearchChip,
 	SearchChipInput,
 	type SearchChipInputProps,
+	type SearchFieldSuggest,
 } from "./components/search-chip-input.js";
 export {
 	DROPPED_SEMANTIC_COPY,
@@ -419,6 +438,8 @@ export {
 	type SearchResultTone,
 } from "./components/search-result-row.js";
 export {
+	MakeFilterAction,
+	type MakeFilterActionProps,
 	partitionSpamResults,
 	type SearchResultSection,
 	SearchResults,
@@ -523,6 +544,11 @@ export {
 	SpamResultsOffer,
 	type SpamResultsOfferProps,
 } from "./components/spam-results-offer.js";
+export {
+	type Suggestion,
+	SuggestList,
+	type SuggestListProps,
+} from "./components/suggest-list.js";
 export {
 	commitPeek,
 	SwipeableRow,
@@ -572,6 +598,11 @@ export {
 	labelColorOptions,
 	labelDotClass,
 } from "./lib/label-color.js";
+export {
+	derivePropertyClauses,
+	normalizeSubject,
+	sharedSubjectFragment,
+} from "./lib/property-prefill.js";
 export {
 	LIST_ROW_ATTRIBUTE,
 	LIST_ROW_SELECTOR,
@@ -580,8 +611,32 @@ export {
 	type UseRovingFocusOptions,
 	useRovingFocus,
 } from "./lib/roving-focus.js";
+export {
+	buildSearchRule,
+	type DroppedFacet,
+	type DroppedFacetType,
+	isConvertible,
+	type SearchConversion,
+} from "./lib/search-rule.js";
+export {
+	collapsibleDomain,
+	deriveSenderClauses,
+	distinctSenders,
+	senderDomain,
+} from "./lib/sender-derivation.js";
+export {
+	type SuggestAction,
+	type SuggestKeyState,
+	suggestKeyAction,
+} from "./lib/suggest-keys.js";
 export {
 	type UseLongPressOptions,
 	type UseLongPressResult,
 	useLongPress,
 } from "./lib/use-long-press.js";
+export {
+	type ComboboxProps,
+	type SuggestListState,
+	type UseSuggestListInput,
+	useSuggestList,
+} from "./lib/use-suggest-list.js";

package/src/lib/property-prefill.test.ts

@@ -0,0 +1,173 @@
+/**
+ * The opening clauses a properties-only rule offers (RFC 038 D2/D4). The
+ * prefill is a starting point the user edits, so the contract worth holding is
+ * the order of evidence — sender before subject, and nothing at all rather than
+ * a guess that matches half a mailbox.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	derivePropertyClauses,
+	normalizeSubject,
+	sharedSubjectFragment,
+} from "./property-prefill.js";
+
+describe("normalizeSubject", () => {
+	it("strips stacked reply, forward, and list decorations", () => {
+		assert.equal(
+			normalizeSubject("Re: Fwd: [ops] Invoice 1841"),
+			"Invoice 1841",
+		);
+		assert.equal(normalizeSubject("RE[2]: Invoice 1841"), "Invoice 1841");
+		assert.equal(normalizeSubject("AW: SV: Invoice 1841"), "Invoice 1841");
+	});
+
+	it("collapses whitespace and trims", () => {
+		assert.equal(normalizeSubject("  Invoice   1841  "), "Invoice 1841");
+	});
+
+	it("leaves a subject that is only decoration empty", () => {
+		assert.equal(normalizeSubject("Re: "), "");
+	});
+});
+
+describe("sharedSubjectFragment", () => {
+	it("takes the longest run of whole words every subject carries", () => {
+		assert.equal(
+			sharedSubjectFragment([
+				"Invoice 1841",
+				"Invoice 1902",
+				"Re: Invoice 2003",
+			]),
+			"Invoice",
+		);
+	});
+
+	it("matches case-insensitively and answers in the first subject's casing", () => {
+		assert.equal(
+			sharedSubjectFragment(["Invoice 1841", "INVOICE 1902"]),
+			"Invoice",
+		);
+	});
+
+	it("compares whole words, never a partial one", () => {
+		// "Invoice 18" is a shared character run and not a shared word run.
+		assert.equal(
+			sharedSubjectFragment(["Invoice 1841", "Invoice 1892"]),
+			"Invoice",
+		);
+	});
+
+	it("keeps a single subject as its own fragment", () => {
+		assert.equal(sharedSubjectFragment(["Invoice 1841"]), "Invoice 1841");
+	});
+
+	it("rejects a single subject that is nothing but filler", () => {
+		assert.equal(sharedSubjectFragment(["for you"]), undefined);
+	});
+
+	it("rejects a shared run of filler words", () => {
+		assert.equal(
+			sharedSubjectFragment(["the report", "the summary"]),
+			undefined,
+		);
+	});
+
+	it("rejects a shared run too short to be worth matching", () => {
+		assert.equal(
+			sharedSubjectFragment(["Q3 numbers", "Q3 results"]),
+			undefined,
+		);
+	});
+
+	it("is undefined when the subjects share nothing", () => {
+		assert.equal(
+			sharedSubjectFragment(["Invoice 1841", "Standup notes"]),
+			undefined,
+		);
+	});
+
+	it("is undefined when no subject survives normalizing", () => {
+		assert.equal(sharedSubjectFragment(["Re:", "   "]), undefined);
+	});
+});
+
+describe("derivePropertyClauses", () => {
+	it("matches on the sender when the whole selection is from one address", () => {
+		assert.deepEqual(
+			derivePropertyClauses(
+				["npm@github.com", "npm@github.com", "npm@github.com"],
+				["Invoice 1841", "Standup notes", "Deploy failed"],
+			),
+			[{ field: "From", value: "npm@github.com" }],
+		);
+	});
+
+	it("matches on the domain when several senders share one", () => {
+		assert.deepEqual(
+			derivePropertyClauses(
+				["npm@github.com", "notifications@github.com", "ci@sub.github.com"],
+				["Invoice 1841", "Standup notes", "Deploy failed"],
+			),
+			[{ field: "FromDomain", value: "github.com" }],
+		);
+	});
+
+	it("prefers the sender over the subject even when the subjects share a run", () => {
+		assert.deepEqual(
+			derivePropertyClauses(
+				["npm@github.com", "npm@github.com"],
+				["Invoice 1841", "Invoice 1902"],
+			),
+			[{ field: "From", value: "npm@github.com" }],
+		);
+	});
+
+	it("falls back to what mixed senders' subjects have in common", () => {
+		assert.deepEqual(
+			derivePropertyClauses(
+				["billing@acme.test", "accounts@globex.test", "ap@initech.test"],
+				["Invoice 1841", "Invoice 1902", "Re: Invoice 2003"],
+			),
+			[{ field: "Subject", value: "Invoice" }],
+		);
+	});
+
+	it("offers one sender chip each when mixed senders share no subject either", () => {
+		assert.deepEqual(
+			derivePropertyClauses(
+				["billing@acme.test", "accounts@globex.test"],
+				["Invoice 1841", "Standup notes"],
+			),
+			[
+				{ field: "From", value: "billing@acme.test" },
+				{ field: "From", value: "accounts@globex.test" },
+			],
+		);
+	});
+
+	it("refuses a filler-only subject run rather than prefilling a wide match", () => {
+		assert.deepEqual(
+			derivePropertyClauses(
+				["billing@acme.test", "accounts@globex.test"],
+				["the report", "the summary"],
+			),
+			[
+				{ field: "From", value: "billing@acme.test" },
+				{ field: "From", value: "accounts@globex.test" },
+			],
+		);
+	});
+
+	it("reads a single message as its own sender", () => {
+		assert.deepEqual(
+			derivePropertyClauses(["billing@acme.test"], ["Invoice 1841"]),
+			[{ field: "From", value: "billing@acme.test" }],
+		);
+	});
+
+	it("offers nothing when the selection carries no sender and no shared subject", () => {
+		assert.deepEqual(derivePropertyClauses([], ["Re:", "   "]), []);
+	});
+});

package/src/lib/property-prefill.ts

@@ -0,0 +1,151 @@
+import type { RuleClause } from "../components/filter-rule.js";
+import { deriveSenderClauses, distinctSenders } from "./sender-derivation.js";
+
+/**
+ * The opening clauses for a rule matched on properties alone — no semantic
+ * anchor (RFC 038 D2/D4). The selection is the only evidence available, so the
+ * prefill reads it in the order the evidence is strongest:
+ *
+ * 1. One sender across the whole selection, or several that collapse to one
+ *    registrable domain — the sender derivation (#251, #262) already decides
+ *    between a `From` and a `FromDomain` clause, and this reuses it rather than
+ *    deciding again.
+ * 2. Mixed senders — what the messages share is their subject, so match on the
+ *    part the subjects have in common instead.
+ * 3. Neither — no clauses. The editor opens empty and asks for one; a wrong
+ *    guess costs more than an absent one.
+ *
+ * Every clause it produces is an ordinary chip: visible, editable, removable.
+ * It is where the user starts, never what the rule is.
+ */
+
+/** Reply, forward, and list-tag decorations that carry no meaning for a match. */
+const SUBJECT_PREFIX =
+	/^\s*(?:(?:re|aw|fwd?|vs|sv|antw|res|enc|tr)\s*(?:\[\d+\])?\s*:|\[[^\]]{1,32}\])\s*/i;
+
+/**
+ * A subject reduced to the part worth matching on: reply and forward markers
+ * and leading list tags stripped (repeatedly — real threads stack them), and
+ * whitespace collapsed.
+ */
+export const normalizeSubject = (subject: string): string => {
+	let value = subject.replace(/\s+/g, " ").trim();
+	for (;;) {
+		const stripped = value.replace(SUBJECT_PREFIX, "");
+		if (stripped === value) return value.trim();
+		value = stripped;
+	}
+};
+
+/**
+ * Words too common to be a rule on their own. A single shared word from this
+ * list matches half a mailbox, which is worse than offering nothing.
+ */
+const WEAK_WORDS = new Set([
+	"a",
+	"an",
+	"and",
+	"are",
+	"as",
+	"at",
+	"be",
+	"by",
+	"for",
+	"from",
+	"has",
+	"have",
+	"in",
+	"is",
+	"it",
+	"me",
+	"my",
+	"new",
+	"of",
+	"on",
+	"or",
+	"our",
+	"the",
+	"this",
+	"to",
+	"was",
+	"we",
+	"with",
+	"you",
+	"your",
+]);
+
+/** The shortest fragment worth prefilling as a `Subject` clause. */
+const MIN_FRAGMENT_LENGTH = 3;
+
+const words = (subject: string): string[] =>
+	subject.split(" ").filter((word) => word !== "");
+
+const isUseful = (fragment: string[]): boolean => {
+	if (fragment.length === 0) return false;
+	if (fragment.join(" ").length < MIN_FRAGMENT_LENGTH) return false;
+	return fragment.some((word) => !WEAK_WORDS.has(word.toLowerCase()));
+};
+
+const runAt = (haystack: string[], needle: string[]): number =>
+	haystack.findIndex((_, start) =>
+		needle.every(
+			(word, offset) =>
+				haystack[start + offset]?.toLowerCase() === word.toLowerCase(),
+		),
+	);
+
+/**
+ * The longest run of whole words every subject carries, compared
+ * case-insensitively and returned in the casing the first subject uses. Whole
+ * words rather than raw characters, so "Invoice 1841" and "Invoice 1902" share
+ * "Invoice" and not "Invoice 18".
+ *
+ * `undefined` when the subjects share nothing worth matching on — a single
+ * filler word does not count.
+ */
+export const sharedSubjectFragment = (
+	subjects: readonly string[],
+): string | undefined => {
+	const normalized = subjects
+		.map(normalizeSubject)
+		.filter((subject) => subject !== "");
+	if (normalized.length === 0) return undefined;
+	const [first, ...rest] = normalized;
+	if (rest.length === 0) return isUseful(words(first)) ? first : undefined;
+
+	const firstWords = words(first);
+	for (let length = firstWords.length; length > 0; length -= 1) {
+		for (let start = 0; start + length <= firstWords.length; start += 1) {
+			const candidate = firstWords.slice(start, start + length);
+			if (!isUseful(candidate)) continue;
+			if (rest.every((subject) => runAt(words(subject), candidate) >= 0)) {
+				return candidate.join(" ");
+			}
+		}
+	}
+	return undefined;
+};
+
+/**
+ * The clauses a properties-only rule opens on, derived from the selected
+ * messages' senders and subjects. Empty when the selection gives nothing to go
+ * on — the editor then holds the commit until the user adds a clause, which is
+ * the honest state.
+ */
+export const derivePropertyClauses = (
+	senders: readonly string[],
+	subjects: readonly string[],
+): Omit<RuleClause, "id">[] => {
+	const senderClauses = deriveSenderClauses(senders);
+	// One sender across the selection, or several on one registrable domain:
+	// a single sharp clause, and sharper than any subject fragment.
+	if (distinctSenders(senders).length === 1) return senderClauses;
+	if (senderClauses.length === 1 && senderClauses[0].field === "FromDomain")
+		return senderClauses;
+
+	const fragment = sharedSubjectFragment(subjects);
+	if (fragment !== undefined) return [{ field: "Subject", value: fragment }];
+	// Mixed senders with nothing shared in their subjects: one `From` chip each,
+	// the sender derivation's own answer (#251).
+	return senderClauses;
+};

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

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+	buildSearchRule,
+	isConvertible,
+	type SearchConversion,
+} from "./search-rule.js";
+
+const conversion = (
+	overrides: Partial<SearchConversion> = {},
+): SearchConversion => ({
+	clauses: [],
+	matchOperator: "all",
+	droppedFacets: [],
+	keptTerms: false,
+	droppedSemantic: false,
+	...overrides,
+});
+
+describe("isConvertible", () => {
+	it("is false when the search yields no clause", () => {
+		assert.equal(
+			isConvertible(
+				conversion({
+					droppedFacets: [{ type: "hasAttachment", label: "Has attachment" }],
+					scopedOut: { mailboxId: "mbx-archive", label: "archive" },
+				}),
+			),
+			false,
+		);
+	});
+
+	it("is true once a term or sender is present", () => {
+		assert.equal(
+			isConvertible(
+				conversion({
+					clauses: [{ field: "HasWords", value: "receipts" }],
+					keptTerms: true,
+				}),
+			),
+			true,
+		);
+	});
+});
+
+describe("buildSearchRule", () => {
+	it("builds a standing rule with stable clause ids, no widen, empty name", () => {
+		const rule = buildSearchRule(
+			conversion({
+				clauses: [
+					{ field: "From", value: "a@b.com" },
+					{ field: "HasWords", value: "nightly" },
+				],
+			}),
+		);
+		assert.equal(rule.scope, "standing");
+		assert.equal(rule.widen, undefined);
+		assert.equal(rule.name, "");
+		assert.deepEqual(
+			rule.clauses.map((clause) => clause.id),
+			["search-0", "search-1"],
+		);
+	});
+
+	it("honors an explicit scope and move target", () => {
+		const rule = buildSearchRule(
+			conversion({ clauses: [{ field: "HasWords", value: "nightly" }] }),
+			{ scope: "once", moveMailboxId: "mbx-archive" },
+		);
+		assert.equal(rule.scope, "once");
+		assert.equal(rule.moveMailboxId, "mbx-archive");
+	});
+});

package/src/lib/search-rule.ts

@@ -0,0 +1,96 @@
+/**
+ * What a search converts to, and the rule built from it (RFC 038 D5). The shape
+ * carries the clauses alongside everything the search held that a filter cannot,
+ * so a conversion can never drop a facet without saying so; `search-conversion.ts`
+ * beside it owns the copy that states it.
+ */
+
+import type {
+	ClauseField,
+	FilterRule,
+	MatchOperator,
+	RuleScope,
+} from "../components/filter-rule.js";
+
+/**
+ * A search facet a filter has no clause for. Attachment, read state, starred,
+ * category and the date bounds are attributes of a message, not text a clause
+ * matches on.
+ */
+export type DroppedFacetType =
+	| "hasAttachment"
+	| "isUnread"
+	| "isRead"
+	| "isStarred"
+	| "category"
+	| "before"
+	| "after";
+
+export interface DroppedFacet {
+	type: DroppedFacetType;
+	/** What was dropped, named for the user (e.g. "Has attachment", "Before 2026-01-01"). */
+	label: string;
+}
+
+export interface ScopedOutFolder {
+	mailboxId: string;
+	/** The folder the search was limited to. */
+	label: string;
+}
+
+export interface SearchConversion {
+	/** Clauses derived from the search — `From` (a `from:` facet) and `HasWords` (the free text). */
+	clauses: { field: ClauseField; value: string }[];
+	matchOperator: MatchOperator;
+	/** A folder an `in:` facet scoped the search to — kept OUT of the rule (never silently unscoped). */
+	scopedOut?: ScopedOutFolder;
+	/** Facets with no clause equivalent, each named. */
+	droppedFacets: DroppedFacet[];
+	/** The account an `account:` facet targets — the filter is created for it. */
+	targetAccountId?: string;
+	/** The search carried free-text terms, kept as a `HasWords` clause. */
+	keptTerms: boolean;
+	/**
+	 * The filter this conversion builds is always literal-only — free text has no
+	 * anchor message for a semantic widen — so the search's semantic "similar mail"
+	 * reach is dropped whenever the search had one (RFC 038 D5). True exactly when
+	 * free text was kept AND the search surfaced semantically-similar mail; on a
+	 * deployment with no semantic reach there was nothing to drop, so no note.
+	 */
+	droppedSemantic: boolean;
+}
+
+/**
+ * Whether the conversion yields a rule with something to match. A search of only
+ * dropped facets or a bare folder scope converts to no clauses, so there is no
+ * filter to open — the entry point offers nothing rather than an empty editor.
+ */
+export const isConvertible = (conversion: SearchConversion): boolean =>
+	conversion.clauses.length > 0;
+
+interface BuildRuleOptions {
+	scope?: RuleScope;
+	moveMailboxId?: string;
+}
+
+/**
+ * The rule the editor opens on, from a conversion. A search-derived rule defaults
+ * to a standing filter — "make this a filter" is a request to keep applying it —
+ * and the editor lets the user drop it back to a one-time apply. It carries no
+ * widen: a free-text query has no message anchor, so the semantic chip is not
+ * offered on this surface (its loss is stated in the conversion notice instead).
+ */
+export const buildSearchRule = (
+	conversion: SearchConversion,
+	{ scope = "standing", moveMailboxId }: BuildRuleOptions = {},
+): FilterRule => ({
+	clauses: conversion.clauses.map((clause, index) => ({
+		id: `search-${index}`,
+		field: clause.field,
+		value: clause.value,
+	})),
+	matchOperator: conversion.matchOperator,
+	moveMailboxId,
+	scope,
+	name: "",
+});