@remit/ui 0.0.58 → 0.0.59

package/src/index.ts

@@ -167,10 +167,12 @@ export {
 	matchOperatorLabel,
 	type PreviewCount,
 	previewCountSummary,
+	previewSettledReason,
 	type RuleClause,
 	type RuleMatchMode,
 	type RuleScope,
 	type RuleWiden,
+	ruleBlockedCopy,
 	scopeLabel,
 	unreadableBodyClauses,
 	widenChipLabel,
@@ -483,6 +485,28 @@ export {
 	type SelectionTopBarNoticeAction,
 	type SelectionTopBarProps,
 } from "./components/selection-top-bar.js";
+export {
+	FolderStepBody,
+	type FolderStepProps,
+	MatchStepBody,
+	type MatchStepProps,
+	NameStepBody,
+	type NameStepProps,
+	PropertiesStepBody,
+	type PropertiesStepProps,
+	ReviewStepBody,
+	type ReviewStepProps,
+	RuleStepBody,
+	type RuleStepProps,
+	RunFooter,
+	RunStepBody,
+	type RunStepProps,
+	SelectionSample,
+	type SelectionSampleProps,
+	SelectionWizard,
+	type SelectionWizardProps,
+	type WizardMessage,
+} from "./components/selection-wizard.js";
 export {
 	demoLogsCommand,
 	demoRelease,
@@ -611,6 +635,7 @@ export {
 	type UseRovingFocusOptions,
 	useRovingFocus,
 } from "./lib/roving-focus.js";
+export { type RuleNameParts, suggestRuleName } from "./lib/rule-name.js";
 export {
 	buildSearchRule,
 	type DroppedFacet,
@@ -622,7 +647,9 @@ export {
 	collapsibleDomain,
 	deriveSenderClauses,
 	distinctSenders,
+	dominantSender,
 	senderDomain,
+	senderLabel,
 } from "./lib/sender-derivation.js";
 export {
 	type SuggestAction,
@@ -640,3 +667,32 @@ export {
 	type UseSuggestListInput,
 	useSuggestList,
 } from "./lib/use-suggest-list.js";
+export {
+	backExits,
+	clauseSentence,
+	clauseWords,
+	type MatchCount,
+	type MatchDescription,
+	type MatchMode,
+	matchDoorHint,
+	matchDoorLabel,
+	matchPhrase,
+	matchSummary,
+	type RunCopy,
+	type RunOutcome,
+	type RunState,
+	runCopy,
+	type SampleEmptyReason,
+	type StepId,
+	sampleEmptyCopy,
+	stepBlockedReason,
+	stepIndex,
+	stepLabel,
+	stepsFor,
+	unreadableDraftClauses,
+	type Verb,
+	type VerbCopy,
+	verbCopy,
+	type WizardAnswers,
+	type WizardDraft,
+} from "./lib/wizard-steps.js";

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

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { suggestRuleName } from "./rule-name.js";
+
+describe("suggestRuleName", () => {
+	it("names the match and its destination when it knows both", () => {
+		assert.equal(
+			suggestRuleName({ match: "Your receipt", folder: "Receipts" }),
+			"Your receipt → Receipts",
+		);
+	});
+
+	it("falls back through match, then sender, then destination", () => {
+		assert.equal(
+			suggestRuleName({ match: "Your receipt" }),
+			"Mail matching Your receipt",
+		);
+		assert.equal(
+			suggestRuleName({ sender: "Booking.com" }),
+			"Mail from Booking.com",
+		);
+		assert.equal(suggestRuleName({ folder: "Travel" }), "Mail to Travel");
+	});
+
+	it("suggests nothing when it knows nothing", () => {
+		assert.equal(suggestRuleName({}), "");
+	});
+});

package/src/lib/rule-name.ts

@@ -0,0 +1,27 @@
+/**
+ * The name a rule is offered under before the user writes their own (#477 4.10).
+ * A suggestion and never a decision: the field it fills is editable and
+ * clearable, and a rule with no name is held by `ruleBlockedCopy.unnamed`, not
+ * by a guess.
+ */
+
+export interface RuleNameParts {
+	/** What a property match is anchored on — the leading clause value. */
+	match?: string;
+	/** The sender carrying most of the selection, as it reads on screen. */
+	sender?: string;
+	/** The destination, once one has been chosen. */
+	folder?: string;
+}
+
+export const suggestRuleName = ({
+	match,
+	sender,
+	folder,
+}: RuleNameParts): string => {
+	const subject = match ?? sender;
+	if (!subject) return folder ? `Mail to ${folder}` : "";
+	if (folder) return `${subject} → ${folder}`;
+	if (match) return `Mail matching ${match}`;
+	return `Mail from ${subject}`;
+};

package/src/lib/sender-derivation.test.ts

@@ -4,6 +4,8 @@ import {
 	collapsibleDomain,
 	deriveSenderClauses,
 	distinctSenders,
+	dominantSender,
+	senderLabel,
 } from "./sender-derivation.js";
 
 describe("distinctSenders", () => {
@@ -104,3 +106,54 @@ describe("deriveSenderClauses", () => {
 		]);
 	});
 });
+
+describe("dominantSender", () => {
+	const envelope = (normalizedEmail: string, displayName?: string) => ({
+		normalizedEmail,
+		displayName,
+	});
+
+	it("takes the sender carrying most of the selection", () => {
+		assert.deepEqual(
+			dominantSender([
+				envelope("noreply@booking.com", "Booking.com"),
+				envelope("automated@airbnb.com", "Airbnb"),
+				envelope("noreply@booking.com", "Booking.com"),
+			]),
+			envelope("noreply@booking.com", "Booking.com"),
+		);
+	});
+
+	it("counts one address writing under two names as one sender", () => {
+		assert.deepEqual(
+			dominantSender([
+				envelope("info@klm.com", "KLM"),
+				envelope("INFO@klm.com", "KLM Royal Dutch Airlines"),
+				envelope("noreply@sixt.com", "Sixt"),
+			]),
+			envelope("info@klm.com", "KLM"),
+		);
+	});
+
+	it("has no answer for an empty selection", () => {
+		assert.equal(dominantSender([]), undefined);
+		assert.equal(dominantSender([envelope("  ")]), undefined);
+	});
+});
+
+describe("senderLabel", () => {
+	it("reads the display name, and the address when there is none", () => {
+		assert.equal(
+			senderLabel({ normalizedEmail: "a@b.example", displayName: "Ada" }),
+			"Ada",
+		);
+		assert.equal(
+			senderLabel({ normalizedEmail: "a@b.example", displayName: "  " }),
+			"a@b.example",
+		);
+		assert.equal(
+			senderLabel({ normalizedEmail: "a@b.example" }),
+			"a@b.example",
+		);
+	});
+});

package/src/lib/sender-derivation.ts

@@ -10,6 +10,7 @@
  */
 
 import { getDomain } from "tldts";
+import type { EnvelopeAddress } from "../components/address-display.js";
 import type { RuleClause } from "../components/filter-rule.js";
 
 /**
@@ -83,3 +84,37 @@ export const deriveSenderClauses = (
 		(value): Omit<RuleClause, "id"> => ({ field: "From", value }),
 	);
 };
+
+/**
+ * The sender carrying most of a selection, or `undefined` when it carries none.
+ * Whole envelope addresses rather than bare strings: this reads the display name
+ * a person recognises, where the clause derivations above read the address a
+ * matcher compares, and the two are not interchangeable.
+ *
+ * Counted on the normalized address, so one sender writing under two display
+ * names is one sender; the answer is the first envelope seen for the winner.
+ */
+export const dominantSender = (
+	senders: readonly EnvelopeAddress[],
+): EnvelopeAddress | undefined => {
+	const counts = new Map<string, { sender: EnvelopeAddress; count: number }>();
+	for (const sender of senders) {
+		const key = sender.normalizedEmail.trim().toLowerCase();
+		if (key === "") continue;
+		const seen = counts.get(key);
+		if (seen) seen.count += 1;
+		else counts.set(key, { sender, count: 1 });
+	}
+	let best: EnvelopeAddress | undefined;
+	let bestCount = 0;
+	for (const { sender, count } of counts.values()) {
+		if (count <= bestCount) continue;
+		best = sender;
+		bestCount = count;
+	}
+	return best;
+};
+
+/** What a sender is called on screen — the display name, or the address when it has none. */
+export const senderLabel = (sender: EnvelopeAddress): string =>
+	sender.displayName?.trim() || sender.normalizedEmail;