@remit/web-client 0.0.200 → 0.0.201

package/src/components/mail/selection-wizard-run-controls.test.ts

@@ -0,0 +1,230 @@
+/**
+ * What the run screen's controls decide (#521, #526).
+ *
+ * The wizard host wires routing, history and several data hooks together, so
+ * the decision is taken out of it and asserted by its result — the same move
+ * `runEndingBanner` made for the completion banner. What the run screen then
+ * shows for each state is `@remit/ui`'s `selection-wizard.render.test.ts`, and
+ * the poll a refresh re-issues is `../../hooks/useOrganizeJob.render.test.ts`.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { BulkActionTarget, BulkRunOutcome } from "@/lib/bulk-actions";
+import {
+	type RetryContext,
+	retryIntent,
+	runIsInFlight,
+	stopRunner,
+	wizardExit,
+} from "./selection-wizard-run-controls";
+
+const target = (id: string): BulkActionTarget => ({ id, accountId: "acc-1" });
+
+const context = (over: Partial<RetryContext> = {}): RetryContext => ({
+	runState: "backApplyComplete",
+	isEscalated: false,
+	committedScope: "just-these",
+	createFilterFailed: false,
+	backApplyPending: false,
+	widenRunsAsJob: false,
+	failedIds: [],
+	sent: [target("m1"), target("m2")],
+	...over,
+});
+
+describe("retrying a run whose status could not be read", () => {
+	it("looks at the job it already has rather than queuing a second pass", () => {
+		assert.deepEqual(retryIntent(context({ runState: "statusUnknown" })), {
+			kind: "refreshStatus",
+		});
+	});
+
+	// The back-apply is still running on the server, so every other branch —
+	// each of which starts something — has to lose to this one.
+	for (const over of [
+		{ isEscalated: true },
+		{ committedScope: "standing" as const, backApplyPending: true },
+		{ committedScope: "temporary" as const, createFilterFailed: true },
+		{ committedScope: "all-like-these" as const, widenRunsAsJob: true },
+		{ committedScope: "just-these" as const },
+	]) {
+		it(`wins over ${JSON.stringify(over)}`, () => {
+			assert.deepEqual(
+				retryIntent(context({ ...over, runState: "statusUnknown" })).kind,
+				"refreshStatus",
+			);
+		});
+	}
+});
+
+describe("retrying an escalated predicate", () => {
+	it("re-resolves the predicate rather than resuming a page list", () => {
+		assert.deepEqual(retryIntent(context({ isEscalated: true })), {
+			kind: "rerunEscalated",
+		});
+	});
+});
+
+describe("retrying a filter that was being saved", () => {
+	it("clears the failed create before sending the same commit again", () => {
+		assert.deepEqual(
+			retryIntent(
+				context({ committedScope: "standing", createFilterFailed: true }),
+			),
+			{ kind: "resetAndResend" },
+		);
+	});
+
+	it("starts the pass over existing mail when the create landed", () => {
+		assert.deepEqual(
+			retryIntent(
+				context({ committedScope: "temporary", backApplyPending: true }),
+			),
+			{ kind: "startBackApply" },
+		);
+	});
+
+	it("starts nothing for a saved filter with no pass behind it", () => {
+		assert.deepEqual(retryIntent(context({ committedScope: "standing" })), {
+			kind: "waitOnJob",
+		});
+	});
+});
+
+describe("retrying a widened match", () => {
+	it("re-sends the commit when the widen runs as a job", () => {
+		assert.deepEqual(
+			retryIntent(
+				context({ committedScope: "all-like-these", widenRunsAsJob: true }),
+			),
+			{ kind: "resend" },
+		);
+	});
+
+	it("re-sends the resolved ids when it does not", () => {
+		assert.deepEqual(
+			retryIntent(context({ committedScope: "all-like-these" })),
+			{ kind: "rerunBulk", targets: [target("m1"), target("m2")] },
+		);
+	});
+});
+
+describe("retrying a bounded run", () => {
+	it("re-sends only what the run never reached", () => {
+		assert.deepEqual(
+			retryIntent(
+				context({ sent: [target("m1"), target("m2")], failedIds: ["m2"] }),
+			),
+			{ kind: "rerunBulk", targets: [target("m2")] },
+		);
+	});
+
+	// A run that threw before it handed anything back reports no failed ids, and
+	// re-sending nothing is a retry that silently does nothing at all.
+	it("re-sends everything when the run named no id it missed", () => {
+		assert.deepEqual(retryIntent(context()), {
+			kind: "rerunBulk",
+			targets: [target("m1"), target("m2")],
+		});
+	});
+
+	it("keeps each id's own account, so a cross-account retry still batches", () => {
+		const sent = [
+			{ id: "m1", accountId: "acc-work" },
+			{ id: "m2", accountId: "acc-personal" },
+		];
+		assert.deepEqual(retryIntent(context({ sent, failedIds: ["m2"] })), {
+			kind: "rerunBulk",
+			targets: [{ id: "m2", accountId: "acc-personal" }],
+		});
+	});
+});
+
+describe("whether the run screen offers a way to end the run", () => {
+	const outcome: BulkRunOutcome = {
+		done: 2,
+		failedIds: [],
+		cancelled: false,
+	};
+
+	it("offers nothing before a commit has been sent", () => {
+		assert.equal(runIsInFlight(undefined), false);
+	});
+
+	it("offers it while the runner is still paging", () => {
+		assert.equal(runIsInFlight({}), true);
+	});
+
+	it("withdraws it once the runner has handed back an outcome", () => {
+		assert.equal(runIsInFlight({ outcome }), false);
+	});
+
+	// Nothing was sent, so there is nothing paging to end — the screen carries
+	// why instead, and a control claiming to stop a run would stop nothing.
+	it("withdraws it for a commit that could not start", () => {
+		assert.equal(runIsInFlight({ failureReason: "no Junk folder" }), false);
+	});
+});
+
+describe("which runner the stop reaches", () => {
+	const spies = () => {
+		const called: string[] = [];
+		return {
+			called,
+			escalated: { stop: () => called.push("escalated") },
+			stopBulk: () => called.push("bulk"),
+		};
+	};
+
+	it("stops the list's runner when the selection is a predicate", () => {
+		const { called, escalated, stopBulk } = spies();
+		stopRunner(escalated, stopBulk);
+		assert.deepEqual(called, ["escalated"]);
+	});
+
+	// A bounded select-all runs on the wizard's own runner and reaches the same
+	// control, so a stop that only knows about the predicate leaves that button
+	// on screen doing nothing at all.
+	it("stops the wizard's own runner for a bounded selection", () => {
+		const { called, stopBulk } = spies();
+		stopRunner(undefined, stopBulk);
+		assert.deepEqual(called, ["bulk"]);
+	});
+});
+
+describe("which movement the wizard's exit is", () => {
+	const movements = () => {
+		const called: string[] = [];
+		return {
+			called,
+			handlers: {
+				dismiss: () => called.push("dismiss"),
+				cancel: () => called.push("cancel"),
+			},
+		};
+	};
+
+	it("walks away from the run on the run screen, leaving it going", () => {
+		const { called, handlers } = movements();
+		wizardExit("run", handlers)();
+		assert.deepEqual(called, ["dismiss"]);
+	});
+
+	// Rewinding the entries the wizard owns is only safe before anything is
+	// sent; taken off the run screen it offers the commit a second time.
+	for (const step of [
+		"match",
+		"properties",
+		"folder",
+		"rule",
+		"name",
+		"review",
+	] as const) {
+		it(`rewinds the walk from ${step}`, () => {
+			const { called, handlers } = movements();
+			wizardExit(step, handlers)();
+			assert.deepEqual(called, ["cancel"]);
+		});
+	}
+});

package/src/components/mail/selection-wizard-run-controls.ts

@@ -0,0 +1,101 @@
+import type { RunState, StepId } from "@remit/ui";
+import type { BulkActionTarget, BulkRunOutcome } from "@/lib/bulk-actions";
+import type { OrganizeScope } from "@/lib/organize/organize-model";
+
+export interface RetryContext {
+	runState: RunState;
+	isEscalated: boolean;
+	committedScope: OrganizeScope | undefined;
+	createFilterFailed: boolean;
+	backApplyPending: boolean;
+	widenRunsAsJob: boolean;
+	failedIds: readonly string[];
+	sent: readonly BulkActionTarget[];
+}
+
+export type RetryIntent =
+	| { kind: "refreshStatus" }
+	| { kind: "rerunEscalated" }
+	| { kind: "resetAndResend" }
+	| { kind: "resend" }
+	| { kind: "startBackApply" }
+	| { kind: "waitOnJob" }
+	| { kind: "rerunBulk"; targets: readonly BulkActionTarget[] };
+
+/**
+ * What pressing the run screen's retry asks for, given where the commit got to.
+ *
+ * A back-apply whose status could not be read is still running on the server
+ * (#526), so that one is decided before anything that could queue a second pass
+ * over the same mail.
+ */
+export const retryIntent = (context: RetryContext): RetryIntent => {
+	if (context.runState === "statusUnknown") return { kind: "refreshStatus" };
+	// The predicate is re-resolved, not resumed: every verb it carries is
+	// idempotent, so the messages the first pass already reached are a no-op.
+	if (context.isEscalated) return { kind: "rerunEscalated" };
+	if (
+		context.committedScope === "standing" ||
+		context.committedScope === "temporary"
+	) {
+		if (context.createFilterFailed) return { kind: "resetAndResend" };
+		return context.backApplyPending
+			? { kind: "startBackApply" }
+			: { kind: "waitOnJob" };
+	}
+	if (context.committedScope === "all-like-these" && context.widenRunsAsJob) {
+		return { kind: "resend" };
+	}
+	// A run hands back ids, and each one's account came from the batch it was
+	// sent in — so a retry re-sends the targets the run was given, filtered to
+	// what it never reached.
+	const outstanding = new Set(context.failedIds);
+	return {
+		kind: "rerunBulk",
+		targets:
+			outstanding.size > 0
+				? context.sent.filter((target) => outstanding.has(target.id))
+				: context.sent,
+	};
+};
+
+/**
+ * What a commit has left paging. A commit that never started, one whose runner
+ * has handed back its outcome, and one that could not start at all all have
+ * nothing to end — so the run screen offers no control that would claim to end
+ * them (#521).
+ */
+export const runIsInFlight = (
+	bulkRun: { outcome?: BulkRunOutcome; failureReason?: string } | undefined,
+): boolean =>
+	bulkRun !== undefined &&
+	bulkRun.outcome === undefined &&
+	bulkRun.failureReason === undefined;
+
+/**
+ * Ends the run rather than leaving it. An escalated predicate is paged by the
+ * list's own runner and a bounded selection by the wizard's, so the stop has to
+ * follow whichever one is paging: a stop that reaches only one of them leaves
+ * the other's control on screen doing nothing.
+ */
+export const stopRunner = (
+	escalated: { stop: () => void } | undefined,
+	stopBulk: () => void,
+): void => {
+	if (escalated) {
+		escalated.stop();
+		return;
+	}
+	stopBulk();
+};
+
+/**
+ * Which of the two movements the wizard's exit is, on the step it is taken
+ * from. Everywhere but the run screen it rewinds the entries the wizard owns
+ * and leaves the selection where it was; on the run screen the action has
+ * already been sent, so leaving walks away from a run that keeps going.
+ */
+export const wizardExit = (
+	step: StepId,
+	movements: { dismiss: () => void; cancel: () => void },
+): (() => void) => (step === "run" ? movements.dismiss : movements.cancel);

package/src/components/mail/BriefPane.selection.test.ts

@@ -1,51 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { describe, it } from "node:test";
-import { fileURLToPath } from "node:url";
-
-/**
- * The phone brief must mount the same selection surface the multi-pane list
- * does (#203). `BriefPane` wires the bulk verbs and the selection bar into
- * `DailyBrief` from the `BriefList` slot; the phone view used to render
- * `DailyBrief` directly, without `onDeleteMessages`, so a selection made in the
- * brief on a phone raised no action bar — selectable, but nothing to act with.
- *
- * As with `MessageList.selection.test.ts`, `BriefPane` weaves routing and
- * several data hooks together, so the rule is enforced by reading the source:
- * the phone view reuses the list slot rather than a bare `DailyBrief`.
- */
-
-const here = dirname(fileURLToPath(import.meta.url));
-const source = readFileSync(resolve(here, "BriefPane.tsx"), "utf8");
-
-const briefPhoneBody = (): string => {
-	const start = source.indexOf("function BriefPhone(");
-	assert.notEqual(start, -1, "BriefPhone is defined");
-	const next = source.indexOf("\nfunction ", start + 1);
-	return source.slice(start, next === -1 ? undefined : next);
-};
-
-describe("BriefPane phone selection surface (#203)", () => {
-	it("the phone brief reuses the list slot, not a bare DailyBrief", () => {
-		const body = briefPhoneBody();
-		assert.match(
-			body,
-			/<BriefList \/>/,
-			"phone brief renders the list slot that wires the bulk verbs",
-		);
-		assert.doesNotMatch(
-			body,
-			/<DailyBrief\b/,
-			"phone brief must not render DailyBrief directly — that drops onDeleteMessages and the selection bar with it",
-		);
-	});
-
-	it("the list slot hands DailyBrief the delete verb the selection bar gates on", () => {
-		const start = source.indexOf("function BriefList(");
-		assert.notEqual(start, -1, "BriefList is defined");
-		const next = source.indexOf("\nfunction ", start + 1);
-		const body = source.slice(start, next === -1 ? undefined : next);
-		assert.match(body, /onDeleteMessages=\{onDeleteMessages\}/);
-	});
-});

package/src/components/mail/DailyBrief.selection.test.ts

@@ -1,75 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { describe, it } from "node:test";
-import { fileURLToPath } from "node:url";
-
-/**
- * The brief raises one selection surface at every width, and select-all is on
- * it — wired into the touch sheet alone, the same list could be selected whole
- * on a phone and not on a desktop (#453).
- *
- * As with `MessageList.selection.test.ts`, `DailyBrief` weaves routing, the
- * cursor and several data hooks together, so the rule is enforced by reading
- * the source. `resolveBriefSelectionScope` carries the decisions that can be
- * unit-tested on their own.
- */
-
-const here = dirname(fileURLToPath(import.meta.url));
-const source = readFileSync(resolve(here, "DailyBrief.tsx"), "utf8");
-
-const chromeBody = (): string => {
-	const start = source.indexOf("function BriefSelectionChrome(");
-	assert.notEqual(start, -1, "BriefSelectionChrome is defined");
-	const next = source.indexOf("\nfunction ", start + 1);
-	return source.slice(start, next === -1 ? undefined : next);
-};
-
-describe("the brief's select-all", () => {
-	it("reaches the one selection bar from one derivation", () => {
-		const body = chromeBody();
-		const derivations = body.match(/const selectAll = useMemo\(/g) ?? [];
-		assert.equal(derivations.length, 1, "one select-all");
-		const bars = body.match(/<SelectionTopBar\b/g) ?? [];
-		assert.equal(bars.length, 1, "one surface, at every width (#480)");
-		const wired = body.match(/selectAll=\{selectAll\}/g) ?? [];
-		assert.equal(wired.length, 1, "the bar takes it");
-	});
-
-	it("is offered only when there are rows to select", () => {
-		assert.match(chromeBody(), /orderedIds\.length > 0/);
-	});
-
-	it("mounts the bar unconditionally — it is the list header (#480)", () => {
-		assert.match(
-			chromeBody(),
-			/const selectionBar = \(chrome: ListHeaderChrome\) => \(\s*<SelectionTopBar/,
-		);
-	});
-
-	it("carries every verb the bar can offer (#477 1.4)", () => {
-		// That each of them opens the wizard is `selection-verbs.test.ts`, over
-		// every surface at once. What this pins is that none of them was dropped
-		// from the bar the brief raises.
-		const body = chromeBody();
-		for (const prop of [
-			"onDelete",
-			"onMove",
-			"onOrganize",
-			"onJunk",
-			"onMarkRead",
-		]) {
-			assert.match(body, new RegExp(`${prop}=`));
-		}
-		assert.doesNotMatch(body, /onSomethingElse/);
-	});
-
-	it("drives the wizard and the keyboard layer from one control", () => {
-		// Two copies of "which verb is the wizard on" is how the brief came to
-		// offer a verb the mailbox list did not, and how its keyboard came to act
-		// behind a wizard the bar had opened.
-		assert.match(source, /const wizard = useSelectionWizard\(\);/);
-		assert.match(source, /onSelectionVerb={wizard.start}/);
-		assert.match(source, /wizardOpen={wizard.isOpen}/);
-	});
-});

package/src/components/mail/MessageList.selection.test.ts

@@ -1,195 +0,0 @@
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { describe, it } from "node:test";
-import { fileURLToPath } from "node:url";
-
-/**
- * Selection mode has one source of truth and one exit (#115). `MessageList`
- * wires the DOM, the virtualizer, routing and several data hooks together, so
- * — as with this package's other component-level rules (see
- * `../../index.css.test.ts`) — the rule is enforced by reading the source
- * rather than rendering the tree. The decisions themselves are unit-tested in
- * `../../lib/selection-mode.test.ts`.
- */
-
-const here = dirname(fileURLToPath(import.meta.url));
-const source = readFileSync(resolve(here, "MessageList.tsx"), "utf8");
-
-describe("MessageList selection mode", () => {
-	it("keeps no selection-mode flag of its own", () => {
-		assert.doesNotMatch(source, /useState[^\n]*[iI]sMultiSelectMode/);
-		assert.doesNotMatch(source, /setIsMultiSelectMode/);
-	});
-
-	it("derives the mode from the selection count", () => {
-		assert.match(
-			source,
-			/const isMultiSelectMode = deriveIsMultiSelectMode\(\s*selectedCount,/,
-		);
-	});
-
-	it("calls the selection hook's clearSelection from exactly one place", () => {
-		const calls = source.match(/\bclearSelection\(\)/g) ?? [];
-		assert.equal(calls.length, 1);
-		assert.match(
-			source,
-			/const exitSelection = useCallback\(\(\) => \{[^}]*clearSelection\(\);/,
-		);
-	});
-
-	it("exits selection when the mailbox changes", () => {
-		assert.match(source, /previousMailboxIdRef\.current === mailboxId/);
-	});
-
-	it("turns the back gesture into an exit, and only while selecting", () => {
-		assert.match(
-			source,
-			/shouldExitSelectionOnNavigate\(action, hasSelection, wizardStep\)/,
-		);
-		assert.match(source, /disabled: !hasSelection/);
-	});
-
-	it("leaves the back gesture to the wizard while the wizard is open", () => {
-		assert.match(
-			source,
-			/disabled: !hasSelection \|\| wizardStep !== undefined/,
-		);
-	});
-});
-
-/**
- * An escalated selection is a predicate, and it walks the same wizard every
- * other selection walks (#508). The list hands the wizard the predicate — the
- * words it names it with, the count it was escalated to, and the chunked runner
- * that re-resolves it — and keeps no second confirmation of its own.
- */
-describe("MessageList escalated actions", () => {
-	it("hands the escalated predicate to the wizard rather than running it here", () => {
-		assert.match(
-			source,
-			/const escalatedSelection: EscalatedSelection \| undefined =\s*escalation\.phase\.kind === "escalated"/,
-		);
-		assert.match(
-			source,
-			/scope: describeSearchScope\(searchPredicate \?\? \{\}\)/,
-		);
-		assert.match(source, /total: escalation\.phase\.total/);
-		assert.match(
-			source,
-			/run: \(action: EscalatedAction\) => escalation\.runAction\(action\)/,
-		);
-		const host = source.match(/<SelectionWizardHost[\s\S]*?\/>/)?.[0] ?? "";
-		assert.match(host, /escalated=\{escalatedSelection\}/);
-	});
-
-	it("keeps no predicate confirmation of its own", () => {
-		// The review screen names what the predicate covers; a second dialog
-		// asking the same question is the drift the wizard exists to end.
-		assert.doesNotMatch(source, /source: "predicate"/);
-		assert.doesNotMatch(source, /requestEscalatedDelete/);
-		assert.doesNotMatch(source, /pendingDeleteIsEstimate/);
-	});
-
-	it("words the bar's progress per action instead of per delete", () => {
-		assert.match(
-			source,
-			/bulkActionProgressLabel\(\s*escalation\.runningAction\.kind,/,
-		);
-	});
-});
-
-/**
- * Advanced selection is no longer mobile-only (#212): the escalation engine is
- * opened to every width, and the one selection bar renders the
- * offer → counting → escalated → progress → notice states.
- */
-describe("MessageList escalation reaches desktop (#212)", () => {
-	it("no longer gates the escalation engine on the mobile viewport", () => {
-		assert.match(
-			source,
-			/const escalationEnabled = isSearching && !!searchPredicate;/,
-		);
-		assert.doesNotMatch(
-			source,
-			/!isDesktop && isSearching && !!searchPredicate/,
-		);
-	});
-
-	it("feeds the bar the shared escalation state", () => {
-		// Up to the bar's own closing tag, at its own indent — a nested slot
-		// element closes first and would cut the match short.
-		const bar = source.match(/<SelectionTopBar[\s\S]*?\n\t\t\/>/)?.[0] ?? "";
-		assert.match(bar, /statusLabel=\{selectionStatusLabel\}/);
-		assert.match(bar, /notice=\{selectionNotice\}/);
-		assert.match(bar, /progress=\{selectionProgress\}/);
-		assert.match(bar, /selectAll=\{selectionSelectAll\}/);
-		assert.match(bar, /isCounting=\{escalation\.phase\.kind === "counting"\}/);
-	});
-
-	it("raises one selection surface, at every width (#480)", () => {
-		const bars = source.match(/<SelectionTopBar\b/g) ?? [];
-		assert.equal(bars.length, 1, "one bar, so no two surfaces can drift");
-		assert.doesNotMatch(source, /<SelectionSheet\b/);
-	});
-
-	it("mounts that surface unconditionally — it is the list header", () => {
-		// Gated on a selection, the bar's zero-ticked state (the mailbox name,
-		// and select-all inline from 768px up) reaches nothing.
-		assert.match(source, /const activeSelectionBar = \(\s*<SelectionTopBar/);
-		assert.match(source, /title=\{listHeaderChrome\.title \|\| listTitle\}/);
-		assert.match(source, /navSlot=\{listHeaderChrome\.navSlot\}/);
-	});
-
-	it("carries every verb the bar can offer (#477 1.4)", () => {
-		// That each of them opens the wizard is `selection-verbs.test.ts`, over
-		// every surface at once. What this pins is that none of them was dropped
-		// from the one bar the mailbox raises.
-		const bar = source.match(/<SelectionTopBar[\s\S]*?\n\t\t\/>/)?.[0] ?? "";
-		for (const prop of [
-			"onDelete",
-			"onMove",
-			"onOrganize",
-			"onJunk",
-			"onMarkRead",
-		]) {
-			assert.match(bar, new RegExp(`${prop}=`));
-		}
-		// The one selection surface has no second organize entry beside them.
-		assert.doesNotMatch(source, /onSomethingElse/);
-	});
-
-	it("keeps Organize reachable over a predicate rather than dropping it", () => {
-		// A verb that vanishes when a selection escalates leaves the user no route
-		// at all: the make-filter affordance it defers to is hidden while rows are
-		// ticked (#477 1.7).
-		assert.match(source, /if \(escalatedSelection\) \{\s*startFromSearch\(\);/);
-	});
-
-	it("offers the label picker only when the account has labels", () => {
-		assert.match(source, /labels\.length > 0 \? \(/);
-	});
-});
-
-/**
- * A confirmed delete opens the surviving neighbour. On desktop that fills the
- * reading pane beside the list; on a single-pane mobile layout the same
- * navigation replaced the list with a full-screen message, so the delete read as
- * "jumped into a random message" rather than "the row is gone" (#202). Mobile
- * now stays on the list and raises a completion banner instead.
- */
-describe("MessageList confirmed delete stays on the list on mobile (#202)", () => {
-	it("only the desktop two-pane opens the surviving neighbour after a delete", () => {
-		assert.match(
-			source,
-			/if \(isDesktop\) \{\s*openRow\(nextFocus, \{ replace: true \}\);\s*\}/,
-		);
-	});
-
-	it("raises a completion banner on mobile so the delete is not silent", () => {
-		assert.match(
-			source,
-			/if \(!isDesktop\) \{\s*setCompletionBanner\(\s*bulkActionCompletionText\("delete", ids\.length, deleteOutcome\),?\s*\);\s*\}/,
-		);
-	});
-});