@remit/web-client 0.0.271 → 0.0.273

package/src/components/mail/MessageBody.tsx

@@ -47,9 +47,17 @@ interface MessageBodyProps {
 	/**
 	 * Whether the From-address has the `trusted` flag set. Trusted senders
 	 * auto-load images. The "Load images" bar is suppressed entirely for
-	 * trusted senders.
+	 * trusted senders. Ignored when `isBlocked` is set.
 	 */
 	isTrusted?: boolean;
+	/**
+	 * Whether the From-address has the `blocked` flag set. A blocked sender
+	 * never loads images, "even on explicit click" (`BlockedFlag`), so this
+	 * suppresses auto-load and removes the manual load affordances rather than
+	 * greying them out. Blocked outranks trusted: it is the more restrictive
+	 * instruction, and a sender carrying both is still blocked.
+	 */
+	isBlocked?: boolean;
 	/**
 	 * The current message id. Required for the body-content query cache key
 	 * and by `useToggleTrusted` for the optimistic cache patch.
@@ -99,13 +107,23 @@ export const MessageBody = ({
 	html,
 	text,
 	isTrusted = false,
+	isBlocked = false,
 	messageId,
 	fromAddressId,
 	category,
 	className,
 }: MessageBodyProps) => {
+	// "Load once" is a decision about one message. Reset it when the instance is
+	// handed a different message so the grant can't ride along — today every
+	// caller keys this component by message, which makes the leak unreachable,
+	// but the guarantee should hold structurally rather than by a caller's key.
 	const [allowImagesOnce, setAllowImagesOnce] = useState(false);
-	const allowImages = isTrusted || allowImagesOnce;
+	const [grantedFor, setGrantedFor] = useState(messageId);
+	if (grantedFor !== messageId) {
+		setGrantedFor(messageId);
+		setAllowImagesOnce(false);
+	}
+	const allowImages = !isBlocked && (isTrusted || allowImagesOnce);
 	const isDark = useIsDark();
 	// `useToggleTrusted` surfaces its own failure (banner + rollback) and a fatal
 	// 5xx escalates globally — no consumer-side error effect needed here.
@@ -197,6 +215,7 @@ export const MessageBody = ({
 					blockedImageCount={blockedImageCount}
 					canAlwaysTrust={canAlwaysTrust}
 					isTrustPending={isTrustPending}
+					isSenderBlocked={isBlocked}
 					onLoadOnce={() => setAllowImagesOnce(true)}
 					onAlwaysTrust={handleAlwaysTrust}
 				/>

package/src/components/mail/MessageCard.blocked-sender.test.ts

@@ -0,0 +1,239 @@
+/**
+ * Image gating at the `MessageCard` seam (#352). The expanded card resolves the
+ * From-address flags and hands them to the body: `blocked` is read there
+ * alongside `trusted`, and wins when both are set. Without that read the promise
+ * Settings > Senders makes — a blocked sender never loads images — has no reach
+ * into the one surface that renders mail.
+ */
+
+import assert from "node:assert/strict";
+import { afterEach, describe, it } from "node:test";
+import type {
+	RemitImapAddressFlags,
+	RemitImapDescribeMessageResponse,
+} from "@remit/api-http-client/types.gen.ts";
+import {
+	type AnyRouter,
+	createMemoryHistory,
+	createRootRoute,
+	createRoute,
+	createRouter,
+	Outlet,
+	RouterProvider,
+} from "@tanstack/react-router";
+import { createElement } from "react";
+import { createDomHarness, type DomHarness } from "@/test-support/dom";
+import { makeThreadMessage } from "@/test-support/fixtures";
+import { type HttpMock, mockFetch } from "@/test-support/http";
+import { MessageCard } from "./MessageCard";
+
+const MAILBOX_ID = "mbx-inbox";
+const THREAD_ID = "thread-1";
+const MESSAGE_ID = "msg-1";
+const CONTENT_PATH = "/content/parts/1";
+
+const MARKETING_HTML = `<div><img src="https://tracker.example/hero.png" alt="Hero"><p>Sale ends Sunday.</p></div>`;
+
+let harness: DomHarness | undefined;
+let http: HttpMock | undefined;
+
+// The router reads `self` at construction; the shared jsdom globals stop at
+// `window`.
+(globalThis as { self?: typeof globalThis }).self ??= globalThis;
+
+// The sandboxed frame measures itself once the iframe loads. jsdom fires that
+// load but has no ResizeObserver, and the resulting ReferenceError is raised
+// inside a listener where no assertion can see it.
+(globalThis as { ResizeObserver?: unknown }).ResizeObserver = class {
+	observe() {}
+	unobserve() {}
+	disconnect() {}
+};
+
+afterEach(() => {
+	harness?.close();
+	harness = undefined;
+	http?.restore();
+	http = undefined;
+});
+
+const threadMessage = makeThreadMessage({
+	messageId: MESSAGE_ID,
+	threadId: THREAD_ID,
+	mailboxId: MAILBOX_ID,
+	subject: "Sale ends Sunday",
+	fromName: "Deals",
+	fromEmail: "deals@shop.example",
+	category: "marketing",
+	isRead: true,
+});
+
+const describeMessage = (
+	flags: RemitImapAddressFlags,
+): RemitImapDescribeMessageResponse =>
+	({
+		message: {
+			messageId: MESSAGE_ID,
+			mailboxId: MAILBOX_ID,
+			uid: 1,
+			rfc822Size: 512,
+			internalDate: 1_767_225_600_000,
+			status: "active",
+			syncStatus: "pending",
+		},
+		envelope: {
+			messageId: MESSAGE_ID,
+			date: 1_767_225_600_000,
+			subject: "Sale ends Sunday",
+			messageIdValue: "<deals-1@shop.example>",
+			from: [
+				{
+					addressId: "addr-deals",
+					displayName: "Deals",
+					normalizedEmail: "deals@shop.example",
+					addressRole: "from",
+					addressOrder: 0,
+					flags,
+				},
+			],
+			to: [],
+			cc: [],
+			bcc: [],
+			replyTo: [],
+			category: "marketing",
+			senderTrust: "unknown",
+		},
+		flags: ["\\Seen"],
+		bodyParts: [
+			{
+				bodyPartId: "part-1",
+				mediaType: "TEXT",
+				mediaSubtype: "HTML",
+				contentUrl: `http://localhost${CONTENT_PATH}`,
+				isMultipart: false,
+			},
+		],
+		references: [],
+	}) as unknown as RemitImapDescribeMessageResponse;
+
+const testRouter = (): AnyRouter => {
+	const rootRoute = createRootRoute({ component: () => createElement(Outlet) });
+	const mailboxRoute = createRoute({
+		getParentRoute: () => rootRoute,
+		path: "/mail/$mailboxId",
+		validateSearch: (search: Record<string, unknown>) => search,
+	});
+	const threadRoute = createRoute({
+		getParentRoute: () => mailboxRoute,
+		path: "$threadId",
+	});
+	const messageRoute = createRoute({
+		getParentRoute: () => threadRoute,
+		path: "$messageId",
+		component: () =>
+			createElement(MessageCard, {
+				threadMessage,
+				isExpanded: true,
+				onToggle: () => undefined,
+				onToggleStar: () => undefined,
+			}),
+	});
+	const routeTree = rootRoute.addChildren([
+		mailboxRoute.addChildren([threadRoute.addChildren([messageRoute])]),
+	]);
+	return createRouter({
+		routeTree,
+		history: createMemoryHistory({
+			initialEntries: [`/mail/${MAILBOX_ID}/${THREAD_ID}/${MESSAGE_ID}`],
+		}),
+	}) as unknown as AnyRouter;
+};
+
+const mount = async (flags: RemitImapAddressFlags): Promise<DomHarness> => {
+	http = mockFetch((call) => {
+		if (call.path === CONTENT_PATH) {
+			return new Response(MARKETING_HTML, {
+				status: 200,
+				headers: { "content-type": "text/html" },
+			});
+		}
+		if (call.path.endsWith(`/messages/${MESSAGE_ID}`)) {
+			return describeMessage(flags);
+		}
+		return { items: [] };
+	});
+
+	const router = testRouter();
+	await router.load();
+	const dom = createDomHarness();
+	harness = dom;
+	dom.renderApp(createElement(RouterProvider, { router }));
+	await dom.waitFor(
+		() => dom.query("iframe") !== null,
+		"the message body to render",
+	);
+	return dom;
+};
+
+const frameHtml = (dom: DomHarness): string =>
+	dom.query<HTMLIFrameElement>("iframe")?.getAttribute("srcdoc") ?? "";
+
+// A blocked image keeps its original URL in `data-blocked-src`; only a live
+// `src=` means the browser will fetch it.
+const REMOTE_SRC = /\ssrc="https:\/\/tracker\.example\/hero\.png"/;
+
+const notice = (dom: DomHarness) =>
+	dom.query('[data-testid="blocked-images-notice"]');
+
+// A boolean, not the node: an assertion that fails on a jsdom element makes the
+// runner serialize the whole tree and the process dies on memory, not on a diff.
+const hasTrustedBadge = (dom: DomHarness): boolean =>
+	dom.query('[data-testid="trusted-sender-badge"]') !== null;
+
+describe("MessageCard reads flags.blocked on the render path (#352)", () => {
+	it("keeps a blocked sender's images out and offers no way to load them", async () => {
+		const dom = await mount({ blocked: { value: true, setAt: 1 } });
+
+		assert.doesNotMatch(frameHtml(dom), REMOTE_SRC);
+		assert.match(frameHtml(dom), /data-blocked-src/);
+		assert.match(notice(dom)?.textContent ?? "", /you blocked this sender/);
+		assert.equal(
+			dom.queryAll('[data-testid="blocked-images-notice"] button').length,
+			0,
+			"never load, even on explicit click",
+		);
+	});
+
+	it("stays blocked when the sender carries both blocked and trusted", async () => {
+		const dom = await mount({
+			blocked: { value: true, setAt: 1 },
+			trusted: { value: true, setAt: 1 },
+		});
+
+		assert.doesNotMatch(frameHtml(dom), REMOTE_SRC);
+		assert.match(notice(dom)?.textContent ?? "", /you blocked this sender/);
+		assert.equal(
+			hasTrustedBadge(dom),
+			false,
+			"a trusted badge beside 'you blocked this sender' tells the user two opposite things",
+		);
+	});
+
+	it("still auto-loads a trusted sender's images", async () => {
+		const dom = await mount({ trusted: { value: true, setAt: 1 } });
+
+		assert.match(frameHtml(dom), REMOTE_SRC);
+		assert.equal(notice(dom), null);
+		assert.equal(hasTrustedBadge(dom), true);
+	});
+
+	it("still offers the load affordances to a merely untrusted sender", async () => {
+		const dom = await mount({});
+
+		assert.doesNotMatch(frameHtml(dom), REMOTE_SRC);
+		assert.match(notice(dom)?.textContent ?? "", /blocked for privacy/);
+		assert.ok(
+			dom.queryAll('[data-testid="blocked-images-notice"] button').length > 0,
+		);
+	});
+});

package/src/components/mail/MessageCard.tsx

@@ -200,6 +200,12 @@ const ExpandedCard = ({
 	const isUnread = !threadMessage.isRead;
 	const isTrusted =
 		messageData?.envelope.from[0]?.flags?.trusted?.value === true;
+	// `BlockedFlag`: never load images, even on explicit click. Read alongside
+	// `trusted` and handed to the body, which lets blocked win over trusted —
+	// including on the header, where a trusted badge beside "you blocked this
+	// sender" would tell the user two opposite things about the same address.
+	const isBlocked =
+		messageData?.envelope.from[0]?.flags?.blocked?.value === true;
 	const fromAddressId = messageData?.envelope.from[0]?.addressId;
 	const message = toThreadMessageData(threadMessage, date);
 
@@ -220,7 +226,7 @@ const ExpandedCard = ({
 			message={message}
 			isFocused={mobile ? false : isFocused}
 			onHeaderClick={onToggle}
-			senderBadge={isTrusted ? <TrustedSenderBadge /> : undefined}
+			senderBadge={isTrusted && !isBlocked ? <TrustedSenderBadge /> : undefined}
 			trailing={
 				<span data-testid="message-date" className="text-2xs text-fg-subtle">
 					{date}
@@ -328,6 +334,7 @@ const ExpandedCard = ({
 								messageId={threadMessage.messageId}
 								fromAddressId={messageData?.envelope.from[0]?.addressId}
 								isTrusted={isTrusted}
+								isBlocked={isBlocked}
 								category={toDisplayCategory(threadMessage.category)}
 							/>
 							<MessageAttachments

package/src/components/mail/MessageList.tsx

@@ -24,7 +24,6 @@ import { formatErrorMessage } from "@/components/ui/ErrorState";
 import { useJunkMailbox } from "@/hooks/useArchiveMailbox";
 import { useDeleteOutcome } from "@/hooks/useDeleteOutcome";
 import {
-	type EscalatedAction,
 	type EscalationSearchQuery,
 	useEscalatedActions,
 } from "@/hooks/useEscalatedActions";
@@ -355,21 +354,12 @@ export const MessageList = ({
 	// are loaded. `orderedIds` below feeds `allLoadedSelected`; declared after
 	// this hook so its callback deps stay simple — see the
 	// `orderedIds`/`handleRowSelect` block.
-	const escalationEnabled = isSearching && !!searchPredicate;
-	const predicateKey = `${mailboxId}|${JSON.stringify(searchPredicate ?? {})}`;
-	const escalation = useEscalatedActions({
-		mailboxId,
-		accountId,
-		enabled: escalationEnabled,
-		predicateKey,
-		searchQuery: searchPredicate ?? {},
-	});
-
-	// How a run ended, for the user who is no longer looking at the run screen.
-	// Closing the wizard mid-run is a movement the screen invites, and the run
-	// keeps going past it — so the list is what states the ending, whether the
-	// run covered everything or stopped short of it. The wizard calls this only
-	// once the user has left it, so an ending is never said twice.
+	// How a run ended, for the user who is no longer looking at any screen that
+	// could show it. Closing the wizard mid-run is a movement the screen invites,
+	// and leaving the mailbox on top of that is one nothing prevents — the run
+	// keeps going past both, so this states the ending, whether the run covered
+	// everything or stopped short of it. The run's owner calls it only once no
+	// screen is left reporting in place, so an ending is never said twice.
 	const reportRunOutcome = useCallback(
 		(kind: BulkActionKind, matched: number, outcome: BulkRunOutcome) => {
 			const banner = runEndingBanner(kind, matched, outcome, deleteOutcome);
@@ -380,6 +370,18 @@ export const MessageList = ({
 		[pushError, deleteOutcome],
 	);
 
+	const escalationEnabled = isSearching && !!searchPredicate;
+	const predicateKey = `${mailboxId}|${JSON.stringify(searchPredicate ?? {})}`;
+	const escalation = useEscalatedActions({
+		mailboxId,
+		mailboxLabel: listTitle,
+		accountId,
+		enabled: escalationEnabled,
+		predicateKey,
+		searchQuery: searchPredicate ?? {},
+		reportEnding: reportRunOutcome,
+	});
+
 	// The one way selection mode ends (#115): cancel, a completed delete or
 	// move, a plain click that collapses a range, switching mailboxes, the back
 	// gesture. Nothing calls the selection hook's `clearSelection` directly, so
@@ -690,7 +692,8 @@ export const MessageList = ({
 					scope: describeSearchScope(searchPredicate ?? {}),
 					total: escalation.phase.total,
 					searchQuery: searchPredicate ?? {},
-					run: (action: EscalatedAction) => escalation.runAction(action),
+					run: (action, claimEnding) =>
+						escalation.runAction(action, undefined, claimEnding),
 					stop: escalation.stop,
 				}
 			: undefined;
@@ -1086,10 +1089,16 @@ export const MessageList = ({
 	// The escalation-derived surface state — viewport-independent, fed to both
 	// the mobile sheet and the desktop toolbar so the two never diverge (#212).
 	const selectionIsBusy = isDeleting || isMoving || escalation.isRunning;
+	// A run outlives the selection it came from, and leaving the mailbox and
+	// coming back leaves no selection at all — so while one is in flight the run's
+	// own count is what the bar is about, or the bar would be an empty header over
+	// mail that is still being deleted (#112).
 	const selectionCount =
 		escalation.phase.kind === "escalated"
 			? escalation.phase.total
-			: selectedCount;
+			: escalation.progress
+				? escalation.progress.total
+				: selectedCount;
 
 	// A run reports on the bar from the moment it starts, not from its first
 	// finished batch: the wizard invites the user back here mid-run, and a run
@@ -1128,17 +1137,22 @@ export const MessageList = ({
 		: undefined;
 
 	// At most one escalation notice at a time, ranked by how actionable it is:
-	// an in-progress counting/escalated state and its own action always wins;
-	// otherwise a fresh escalation offer. The (rare) cross-account move hint is
-	// layered on behind them below.
+	// a run in flight and a count both carry Stop, and that always wins; then an
+	// escalated selection's way out; otherwise a fresh escalation offer. The
+	// (rare) cross-account move hint is layered on behind them below.
+	//
+	// Stop rides on the bar rather than only on the wizard's run screen because
+	// the run outlives both the wizard and the route: a user who comes back to
+	// the mailbox mid-run finds the progress there, and has to be able to end it
+	// from the same place (#112).
 	const escalationNotice =
-		escalation.phase.kind === "counting"
+		escalation.isRunning || escalation.phase.kind === "counting"
 			? {
 					tone: "info" as const,
 					text: "",
 					action: { label: "Stop", onClick: escalation.stop },
 				}
-			: escalation.phase.kind === "escalated" && !escalation.isRunning
+			: escalation.phase.kind === "escalated"
 				? {
 						tone: "info" as const,
 						text: "",
@@ -1343,6 +1357,7 @@ export const MessageList = ({
 				verb={wizardVerb}
 				accountId={accountId}
 				mailboxId={mailboxId}
+				mailboxLabel={listTitle}
 				selection={wizardSelection}
 				selectionRestriction={moveDisabledHint ? "spansAccounts" : undefined}
 				escalated={escalatedSelection}

package/src/components/mail/SelectionWizardHost.tsx

@@ -39,7 +39,6 @@ import {
 import { useClauseSuggestions } from "@/hooks/useClauseSuggestions";
 import { useCreateMailbox } from "@/hooks/useCreateMailbox";
 import {
-	type EscalatedAction,
 	type EscalationSearchQuery,
 	useEscalatedActions,
 } from "@/hooks/useEscalatedActions";
@@ -55,6 +54,8 @@ import type {
 	BulkActionProgress,
 	BulkActionTarget,
 	BulkRunOutcome,
+	BulkRunStart,
+	EscalatedAction,
 } from "@/lib/bulk-actions";
 import { NO_JUNK_FOLDER_REASON } from "@/lib/junk-destination";
 import { useMailContext } from "@/lib/mail-context";
@@ -122,7 +123,15 @@ export interface EscalatedSelection {
 	 * screen is what now stands in front of it. The run belongs to the list, so
 	 * it survives the wizard closing over it — as the run screen promises.
 	 */
-	run: (action: EscalatedAction) => Promise<BulkRunOutcome>;
+	run: (
+		action: EscalatedAction,
+		/**
+		 * Handed the release for the ending of the run it starts, so the wizard's
+		 * run screen states that ending in place and the list does not banner it a
+		 * second time (#112).
+		 */
+		claimEnding: (release: () => void) => void,
+	) => Promise<BulkRunStart>;
 	/** Ends that run at the next page boundary, which leaving the wizard does not. */
 	stop: () => void;
 }
@@ -134,6 +143,8 @@ export interface SelectionWizardHostProps {
 	accountId?: string;
 	/** Where the selection was made, so a run invalidates the listing it changed. */
 	mailboxId?: string;
+	/** That mailbox in the user's words, for a commit refused while it runs. */
+	mailboxLabel?: string;
 	selection: readonly WizardSelectionMessage[];
 	/**
 	 * Which scope the ticked rows span more of than the folder and rule steps can
@@ -154,10 +165,11 @@ export interface SelectionWizardHostProps {
 	/** The wizard is done with the selection, and the list drops it. */
 	onFinished: () => void;
 	/**
-	 * How a run ended, once the screen that was reporting on it is gone. The run
-	 * screen invites the user to close it and keep the run going, so the surface
-	 * that outlives the wizard is what states the ending. Called only for a run
-	 * the user walked away from; a run screen still up reports in place.
+	 * How a run ended, once no screen reporting on it is left. Handed to the run's
+	 * owner rather than called here: the run screen invites the user to close it
+	 * and keep the run going, and leaving the mailbox on top of that takes this
+	 * component with it — so the ending is stated by something that outlives both
+	 * (#112). A run screen still up reports in place instead.
 	 */
 	onRunEnded?: (
 		kind: EscalatedAction["kind"],
@@ -298,6 +310,7 @@ function SelectionWizardSession({
 	verb,
 	accountId,
 	mailboxId,
+	mailboxLabel,
 	selection,
 	selectionRestriction,
 	escalated: escalatedSelection,
@@ -361,11 +374,6 @@ function SelectionWizardSession({
 	// cleared, so a failed start can be retried.
 	const [backApplyDraft, setBackApplyDraft] = useState<OrganizeDraft>();
 	const commitSent = useRef(false);
-	// The user left the run screen while it was still reporting. Held here rather
-	// than read back off the URL: the rewind the exit starts lands a frame or two
-	// later, and an outcome arriving in between would find a screen that is on
-	// its way out and say nothing.
-	const walkedAway = useRef(false);
 
 	const messageIds = useMemo(
 		() => selection.map((message) => message.id),
@@ -491,14 +499,36 @@ function SelectionWizardSession({
 		senders,
 	);
 
+	// While this screen is up it states the ending itself, so the run's owner
+	// holds its banner back. The claim is over the run this screen starts and no
+	// other: a commit that starts none — a filter, a back-apply job — has no
+	// ending of its own to hold, and holding one anyway swallowed the banner of
+	// whatever run was going elsewhere. Leaving — closing the wizard, or leaving
+	// the mailbox altogether — unmounts this and releases it, and the ending is
+	// bannered where the user now is (#112, #521).
+	const releaseReport = useRef<(() => void) | undefined>(undefined);
+	const claimEnding = useCallback((release: () => void) => {
+		releaseReport.current?.();
+		releaseReport.current = release;
+	}, []);
+	useEffect(
+		() => () => {
+			releaseReport.current?.();
+			releaseReport.current = undefined;
+		},
+		[],
+	);
+
 	const organizeJob = useOrganizeJob(accountId);
 	const createFilter = useCreateFilter(accountId);
 	const bulk = useEscalatedActions({
 		mailboxId: mailboxId ?? "",
+		mailboxLabel,
 		accountId,
 		enabled: false,
 		predicateKey: "selection-wizard",
 		searchQuery: {},
+		reportEnding: onRunEnded,
 	});
 	const { runAction } = bulk;
 
@@ -661,13 +691,15 @@ function SelectionWizardSession({
 				return;
 			}
 			setBulkRun({ matched: targets.length, sent: targets });
-			const outcome = await runAction(action, targets);
-			setBulkRun({ matched: targets.length, sent: targets, outcome });
-			if (walkedAway.current) {
-				onRunEnded?.(action.kind, targets.length, outcome);
-			}
+			const started = await runAction(action, targets, claimEnding);
+			setBulkRun({
+				matched: targets.length,
+				sent: targets,
+				outcome: started.kind === "ran" ? started.outcome : undefined,
+				failureReason: started.kind === "refused" ? started.reason : undefined,
+			});
 		},
-		[verb, named.moveMailboxId, junkMailboxId, runAction, onRunEnded],
+		[verb, named.moveMailboxId, junkMailboxId, runAction, claimEnding],
 	);
 
 	// The escalated predicate, run by the chunked runner the list already owns.
@@ -685,12 +717,14 @@ function SelectionWizardSession({
 			return;
 		}
 		setBulkRun({ matched: escalated.total, sent: [] });
-		const outcome = await escalated.run(action);
-		setBulkRun({ matched: escalated.total, sent: [], outcome });
-		if (walkedAway.current) {
-			onRunEnded?.(action.kind, escalated.total, outcome);
-		}
-	}, [escalated, verb, named.moveMailboxId, junkMailboxId, onRunEnded]);
+		const started = await escalated.run(action, claimEnding);
+		setBulkRun({
+			matched: escalated.total,
+			sent: [],
+			outcome: started.kind === "ran" ? started.outcome : undefined,
+			failureReason: started.kind === "refused" ? started.reason : undefined,
+		});
+	}, [escalated, verb, named.moveMailboxId, junkMailboxId, claimEnding]);
 
 	const { start: startJob } = organizeJob;
 	const { createFilterAsync } = createFilter;
@@ -909,7 +943,6 @@ function SelectionWizardSession({
 	// run alone: the screen says so in as many words, and stopping it is a
 	// control of its own.
 	const dismiss = useCallback(() => {
-		walkedAway.current = true;
 		closeWizard(steps, current);
 		onFinished();
 	}, [closeWizard, steps, current, onFinished]);