@remit/web-client 0.0.94 → 0.0.95

package/src/lib/bulk-actions.test.ts

@@ -6,7 +6,6 @@ import {
 	countMatches,
 	type FetchIdsPageResult,
 	honestProgress,
-	resolveSelectionAfterRun,
 	runChunkedAction,
 	runPredicateAction,
 } from "./bulk-actions.js";
@@ -355,65 +354,6 @@ describe("countMatches", () => {
 	});
 });
 
-describe("resolveSelectionAfterRun", () => {
-	test("a clean run with nothing failed exits selection mode", () => {
-		assert.deepEqual(
-			resolveSelectionAfterRun({
-				done: 3412,
-				failedIds: [],
-				cancelled: false,
-			}),
-			{ exit: true, retryIds: [] },
-		);
-	});
-
-	test("unreached ids stay selected for a precise retry, even alongside a clean stop", () => {
-		assert.deepEqual(
-			resolveSelectionAfterRun({
-				done: 3072,
-				failedIds: ["a", "b"],
-				cancelled: false,
-			}),
-			{ exit: false, retryIds: ["a", "b"] },
-		);
-	});
-
-	test("a clean cancel with nothing yet confirmed failed leaves nothing to retry, but does not exit", () => {
-		assert.deepEqual(
-			resolveSelectionAfterRun({
-				done: 100,
-				failedIds: [],
-				cancelled: true,
-			}),
-			{ exit: false, retryIds: [] },
-		);
-	});
-
-	test("an infra failure with nothing left unreached still keeps selection mode open", () => {
-		assert.deepEqual(
-			resolveSelectionAfterRun({
-				done: 0,
-				failedIds: [],
-				cancelled: false,
-				error: new Error("network blip"),
-			}),
-			{ exit: false, retryIds: [] },
-		);
-	});
-
-	test("failedIds wins over cancelled/error when both are present", () => {
-		assert.deepEqual(
-			resolveSelectionAfterRun({
-				done: 10,
-				failedIds: ["x"],
-				cancelled: true,
-				error: new Error("boom"),
-			}),
-			{ exit: false, retryIds: ["x"] },
-		);
-	});
-});
-
 describe("honestProgress", () => {
 	// Regression for #109: `countMatches` and `runPredicateAction` page the
 	// same predicate independently, so the delete can outrun the frozen

package/src/lib/bulk-actions.ts

@@ -275,29 +275,3 @@ export interface BulkRunOutcome {
 	cancelled: boolean;
 	error?: unknown;
 }
-
-export interface SelectionAfterRun {
-	/** The action reached everything targeted — selection mode should exit. */
-	exit: boolean;
-	/** The bounded selection to leave in place, empty when exiting. */
-	retryIds: string[];
-}
-
-/**
- * What a caller does with selection once a run ends, for any reason. Every id
- * the action never reached — a chunk the bounded run skipped because it was
- * stopped or errored — belongs in `retryIds`: it is exactly what Retry should
- * resend, and it is what stays selected so the count on screen never claims
- * more was done than actually was (#92 requirement 8).
- */
-export const resolveSelectionAfterRun = (
-	outcome: BulkRunOutcome,
-): SelectionAfterRun => {
-	if (outcome.failedIds.length > 0) {
-		return { exit: false, retryIds: outcome.failedIds };
-	}
-	if (outcome.cancelled || outcome.error) {
-		return { exit: false, retryIds: [] };
-	}
-	return { exit: true, retryIds: [] };
-};

package/src/lib/format.test.ts

@@ -119,31 +119,4 @@ describe("formatDeleteToTrashTitle", () => {
 			"Move 3,412 messages to Trash?",
 		);
 	});
-
-	// #109: an escalated-predicate count is paged once by `countMatches` and
-	// re-paged independently by the delete itself — never provably the number
-	// that gets deleted. `isEstimate` says so instead of stating an exact
-	// number the run may not honour.
-	describe("isEstimate (#109 — an escalated-predicate count, not a materialized selection)", () => {
-		test("prefixes 'about' for a plural estimate", () => {
-			assert.strictEqual(
-				formatDeleteToTrashTitle(3412, true),
-				"Move about 3,412 messages to Trash?",
-			);
-		});
-
-		test("prefixes 'about' for a singular estimate", () => {
-			assert.strictEqual(
-				formatDeleteToTrashTitle(1, true),
-				"Move about 1 message to Trash?",
-			);
-		});
-
-		test("defaults to false — a bounded selection's count stays exact", () => {
-			assert.strictEqual(
-				formatDeleteToTrashTitle(3412),
-				formatDeleteToTrashTitle(3412, false),
-			);
-		});
-	});
 });

package/src/lib/format.ts

@@ -152,21 +152,11 @@ export const formatEmailDate = (date: Date | string | number): string => {
 /**
  * Confirmation title for the move-to-Trash delete flow. Reflects that delete
  * moves messages to Trash (not a permanent delete) and pluralizes on count.
- * Thousands-separated: at escalated-selection scale this is exactly the digit
- * count someone checks against what they meant to select.
- *
- * `isEstimate` marks an escalated-predicate count (#109): it was paged to a
- * total once, and the delete itself re-pages the same predicate independently
- * — mail arriving or leaving between the two can make them differ. "about"
- * says so up front instead of stating a number the run may not honour; a
- * materialized (bounded) selection's count is exact and never passes it.
+ * The count is always a concrete list of ids — every predicate delete ends on
+ * the wizard's review screen instead, which states what the predicate covers.
  */
-export const formatDeleteToTrashTitle = (
-	count: number,
-	isEstimate = false,
-): string => {
+export const formatDeleteToTrashTitle = (count: number): string => {
 	const quantity = count === 1 ? "1" : formatNumber(count);
 	const noun = count === 1 ? "message" : "messages";
-	const prefix = isEstimate ? "about " : "";
-	return `Move ${prefix}${quantity} ${noun} to Trash?`;
+	return `Move ${quantity} ${noun} to Trash?`;
 };

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

@@ -6,7 +6,7 @@ import type {
 	RemitImapOrganizeInput,
 } from "@remit/api-http-client/types.gen.ts";
 import type {
-	MatchMode,
+	MatchDoor,
 	MatchOperator,
 	RuleClause,
 	RuleScope,
@@ -105,7 +105,13 @@ export const buildOrganizeInput = (
  * it holds, and the four `OrganizeScope` values fall out of the pair.
  */
 export interface WizardCommitAnswers {
-	mode: MatchMode;
+	/**
+	 * The door the match came through. An escalated predicate is not one: it has
+	 * no clauses to build a rule from and no anchor to widen, so a scope
+	 * reconstructed for it would be a rule matching everything. Typed to the
+	 * three doors so that cannot be written rather than merely not written.
+	 */
+	mode: MatchDoor;
 	/** Absent on the verbs that never reach the scope step — those act once. */
 	ruleScope?: RuleScope;
 }

package/src/lib/wizard-history.ts

@@ -17,9 +17,9 @@
  * rewinds every entry the wizard owns.
  */
 
-import { type StepId, stepIndex } from "@remit/ui";
+import { type StepId, stepIndex, type Verb } from "@remit/ui";
 import { useNavigate, useRouter, useSearch } from "@tanstack/react-router";
-import { useCallback, useEffect, useRef } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { z } from "zod";
 
 const stepId = z.enum([
@@ -101,6 +101,46 @@ export const useOpenWizard = (): ((
 	);
 };
 
+export interface SelectionWizardControl {
+	/** The verb the wizard was opened for, for the host that renders it. */
+	verb: Verb;
+	/** Opens the wizard on a verb, from the match step — every bar verb, and
+	 *  every keyboard verb aimed at a selection, comes through here. */
+	start: (verb: Verb) => void;
+	/** Opens it on the search entry instead: the property step, with the query
+	 *  converted (#477 1.8). The route for a verb whose match is a predicate
+	 *  rather than a set of clauses. */
+	startFromSearch: () => void;
+	/**
+	 * A step is held, so the wizard owns the screen. Every selection surface
+	 * suspends its keyboard layer on this: a shortcut acting behind the screen
+	 * already asking about an action is a second flow nobody asked for.
+	 */
+	isOpen: boolean;
+}
+
+/**
+ * The wizard as a selection surface drives it. The step lives in the URL and
+ * the verb beside it in state, in one place rather than one copy per surface —
+ * three of them had drifted apart on which verbs they even offered.
+ */
+export const useSelectionWizard = (): SelectionWizardControl => {
+	const step = useWizardStepValue();
+	const openWizard = useOpenWizard();
+	const [verb, setVerb] = useState<Verb>("organize");
+	const start = useCallback(
+		(next: Verb) => {
+			setVerb(next);
+			openWizard("match");
+		},
+		[openWizard],
+	);
+	const startFromSearch = useCallback(() => {
+		openWizard("properties", "search");
+	}, [openWizard]);
+	return { verb, start, startFromSearch, isOpen: step !== undefined };
+};
+
 export interface WizardStepNavigation {
 	step: StepId | undefined;
 	goToStep: (step: StepId) => void;