@remit/ui 0.0.124 → 0.0.125

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/ui",
-  "version": "0.0.124",
+  "version": "0.0.125",
   "type": "module",
   "files": [
     "src"

package/src/components/selection-wizard.render.test.ts

@@ -7,6 +7,7 @@ import {
 	matchDoorsFor,
 	stepBlockedReason,
 	stepsFor,
+	wizardScopeFor,
 } from "../lib/wizard-steps.js";
 import {
 	type RuleClause,
@@ -413,6 +414,27 @@ describe("FolderStepBody", () => {
 		);
 		assert.match(text(html), /Tap a folder to open it/);
 	});
+
+	it("states the restriction the selection actually carries (#525)", () => {
+		// Told to pick a single account, a selection already inside one account has
+		// nothing to act on and the flow dead-ends here.
+		const spansFolders = renderToString(
+			createElement(FolderStepBody, {
+				...folderProps,
+				restriction: wizardScopeFor("acc-personal", "spansFolders").destination,
+			}),
+		);
+		assert.match(text(spansFolders), /within one folder/);
+		assert.doesNotMatch(text(spansFolders), /single account/);
+
+		const spansAccounts = renderToString(
+			createElement(FolderStepBody, {
+				...folderProps,
+				restriction: wizardScopeFor(undefined, "spansAccounts").destination,
+			}),
+		);
+		assert.match(text(spansAccounts), /single account/);
+	});
 });
 
 describe("RuleStepBody", () => {

package/src/components/selection-wizard.tsx

@@ -636,9 +636,10 @@ export interface FolderStepProps {
 	/** The account's hierarchy separator, which the tree nests on. */
 	delimiter?: string;
 	/**
-	 * Why there is no folder list to choose from — a selection spanning accounts
-	 * has no single account whose folders these could be (#477 5.5). Said here
-	 * rather than left as an empty picker.
+	 * Why no destination can be chosen — the selection spans more accounts, or
+	 * more folders, than a move can take (#477 5.5, #525). In the words of the
+	 * scope it actually spans, so the instruction is one the user can follow. Said
+	 * here rather than left as an empty picker.
 	 */
 	restriction?: string;
 }
@@ -692,9 +693,10 @@ export interface RuleStepProps {
 	onScopeChange: (scope: RuleScope) => void;
 	onUntilChange: (until: string) => void;
 	/**
-	 * Why the two persisting scopes cannot be reached from here — a selection
-	 * spanning accounts has no single account to create the rule for (#477 5.5).
-	 * They stay pressable and say this; the one-off scope is unaffected.
+	 * Why the two persisting scopes cannot be reached from here — the selection
+	 * spans more accounts, or more folders, than a rule can take (#477 5.5, #525),
+	 * in the words of the scope it actually spans. They stay pressable and say
+	 * this; the one-off scope is unaffected.
 	 */
 	restriction?: string;
 }

package/src/index.ts

@@ -989,6 +989,8 @@ export {
 	clauseWords,
 	crossAccountDestinationReason,
 	crossAccountRuleReason,
+	crossFolderDestinationReason,
+	crossFolderRuleReason,
 	ESCALATED_MATCH_HINT,
 	ESCALATED_REVIEW_WARNING,
 	ESCALATED_SCOPE_FALLBACK,
@@ -1006,6 +1008,7 @@ export {
 	type RunState,
 	runCopy,
 	type SampleEmptyReason,
+	type SelectionRestriction,
 	type StepId,
 	sampleEmptyCopy,
 	stepBlockedReason,
@@ -1018,4 +1021,6 @@ export {
 	verbCopy,
 	type WizardAnswers,
 	type WizardDraft,
+	type WizardScope,
+	wizardScopeFor,
 } from "./lib/wizard-steps.js";

package/src/lib/wizard-steps.test.ts

@@ -10,6 +10,8 @@ import {
 	clauseSentence,
 	clauseWords,
 	crossAccountMatchReason,
+	crossFolderDestinationReason,
+	crossFolderRuleReason,
 	ESCALATED_MATCH_HINT,
 	ESCALATED_REVIEW_WARNING,
 	escalatedMatchLabel,
@@ -32,6 +34,7 @@ import {
 	type Verb,
 	verbCopy,
 	type WizardDraft,
+	wizardScopeFor,
 } from "./wizard-steps.js";
 
 const VERBS: Verb[] = ["delete", "move", "junk", "markRead", "organize"];
@@ -858,3 +861,50 @@ describe("the match as words", () => {
 		);
 	});
 });
+
+/**
+ * A selection spanning folders of one account was told to pick a single account
+ * (#525) — an instruction a user holding one account's mail cannot follow, so
+ * the flow dead-ended on the folder step with nowhere to go.
+ */
+describe("the restriction a selection walks the wizard with", () => {
+	it("tells a selection spanning folders about folders, not accounts", () => {
+		const scope = wizardScopeFor("acc-personal", "spansFolders");
+		assert.equal(scope.destination, crossFolderDestinationReason);
+		assert.equal(scope.rule, crossFolderRuleReason);
+		assert.match(scope.destination ?? "", /within one folder/);
+		assert.doesNotMatch(scope.destination ?? "", /account/);
+		assert.doesNotMatch(scope.rule ?? "", /account/);
+	});
+
+	it("keeps the account a folder-spanning selection has", () => {
+		// The widened doors are counted through a preview that account answers, so
+		// there is nothing to withhold them for.
+		const scope = wizardScopeFor("acc-personal", "spansFolders");
+		assert.equal(scope.accountId, "acc-personal");
+		assert.deepEqual(
+			[...matchDoorsFor(scope.accountId)],
+			["selected", "similar", "properties"],
+		);
+	});
+
+	it("tells a selection spanning accounts about accounts", () => {
+		const scope = wizardScopeFor(undefined, "spansAccounts");
+		assert.equal(scope.accountId, undefined);
+		assert.match(scope.destination ?? "", /within one account/);
+		assert.match(scope.rule ?? "", /within one account/);
+		assert.deepEqual([...matchDoorsFor(scope.accountId)], ["selected"]);
+	});
+
+	it("restricts a selection with no account whatever it was handed", () => {
+		const scope = wizardScopeFor(undefined, undefined);
+		assert.match(scope.destination ?? "", /within one account/);
+		assert.match(scope.rule ?? "", /within one account/);
+	});
+
+	it("restricts nothing when one account and one folder answer for it", () => {
+		assert.deepEqual(wizardScopeFor("acc-personal", undefined), {
+			accountId: "acc-personal",
+		});
+	});
+});

package/src/lib/wizard-steps.ts

@@ -232,6 +232,74 @@ export const crossAccountDestinationReason =
 export const crossAccountMatchReason =
 	"Matching beyond the messages you picked only works within one account — clear the selection, or pick messages from a single account.";
 
+/**
+ * Why a selection spanning folders of one account cannot become a rule (#525).
+ * The account is settled and the source folder is not, so the restriction the
+ * wizard states is the folder one — telling a single-account selection to pick
+ * one account is an instruction it cannot follow.
+ */
+export const crossFolderRuleReason =
+	"A rule only works within one folder — clear the selection, or pick messages from a single folder.";
+
+/** The same restriction on the step that asks for a folder. */
+export const crossFolderDestinationReason =
+	"A destination only works within one folder — clear the selection, or pick messages from a single folder.";
+
+/**
+ * Which scope a selection spans more of than the wizard's folder-scoped steps
+ * can take. The surface that resolved the selection knows which one it is, so it
+ * hands the case over rather than a flag both cases collapse into.
+ */
+export type SelectionRestriction = "spansAccounts" | "spansFolders";
+
+const RESTRICTION_COPY: Record<
+	SelectionRestriction,
+	{ rule: string; destination: string }
+> = {
+	spansAccounts: {
+		rule: crossAccountRuleReason,
+		destination: crossAccountDestinationReason,
+	},
+	spansFolders: {
+		rule: crossFolderRuleReason,
+		destination: crossFolderDestinationReason,
+	},
+};
+
+/** What a restricted selection leaves the wizard's account-scoped steps to work with. */
+export interface WizardScope {
+	/**
+	 * The account a filter, a folder create and a widened door's preview all
+	 * belong to. Absent only when the selection has no single account — a
+	 * selection spanning folders of one account keeps it, so its widened doors
+	 * have something to count against.
+	 */
+	accountId?: string;
+	/** What the rule step states, when the selection cannot reach a saved scope. */
+	rule?: string;
+	/** What the folder step states, when the selection cannot reach a destination. */
+	destination?: string;
+}
+
+/**
+ * The scope a selection walks the wizard with. A selection with no single
+ * account is account-restricted whatever it was handed, since the account is
+ * what the filter, the folder create and the preview all hang off.
+ */
+export const wizardScopeFor = (
+	accountId: string | undefined,
+	restriction: SelectionRestriction | undefined,
+): WizardScope => {
+	const applied = accountId === undefined ? "spansAccounts" : restriction;
+	if (!applied) return { accountId };
+	const copy = RESTRICTION_COPY[applied];
+	return {
+		accountId: applied === "spansAccounts" ? undefined : accountId,
+		rule: copy.rule,
+		destination: copy.destination,
+	};
+};
+
 /**
  * The doors the match step offers. Withholding the two widened ones is what
  * keeps a selection spanning accounts off a review that waits on a count nobody