@remit/web-client 0.0.93 → 0.0.95

package/src/lib/bulk-action-copy.test.ts

@@ -5,7 +5,6 @@ import {
 	bulkActionCompletionText,
 	bulkActionFailureDetail,
 	bulkActionFailureTitle,
-	bulkActionPartialText,
 	bulkActionProgressLabel,
 	bulkActionProgressTone,
 } from "./bulk-action-copy.js";
@@ -46,23 +45,6 @@ describe("bulkActionCompletionText", () => {
 	});
 });
 
-describe("bulkActionPartialText", () => {
-	test("splits what landed from what is still selected", () => {
-		assert.equal(
-			bulkActionPartialText("delete", 3072, 340),
-			"3,072 moved to Trash. 340 couldn't be deleted.",
-		);
-		assert.equal(
-			bulkActionPartialText("move", 3072, 340),
-			"3,072 moved. 340 couldn't be moved.",
-		);
-		assert.equal(
-			bulkActionPartialText("markRead", 3072, 340),
-			"3,072 marked as read. 340 couldn't be marked as read.",
-		);
-	});
-});
-
 describe("bulkActionFailureTitle", () => {
 	test("reports where a partly-done run stopped", () => {
 		assert.equal(
@@ -87,7 +69,6 @@ describe("every action carries its own wording", () => {
 	test("no two actions share a sentence", () => {
 		const sentences: Array<(kind: BulkActionKind) => string> = [
 			(kind) => bulkActionCompletionText(kind, 5),
-			(kind) => bulkActionPartialText(kind, 5, 2),
 			(kind) => bulkActionFailureTitle(kind, 0),
 			(kind) => bulkActionFailureTitle(kind, 5),
 			bulkActionFailureDetail,

package/src/lib/bulk-action-copy.ts

@@ -59,14 +59,6 @@ export const bulkActionCompletionText = (
 ): string =>
 	`${formatNumber(done)} ${pastTense[kind]}. Your mail server is still catching up.`;
 
-/** Shown when part of a run landed and the rest is still selected for Retry. */
-export const bulkActionPartialText = (
-	kind: BulkActionKind,
-	succeeded: number,
-	remaining: number,
-): string =>
-	`${formatNumber(succeeded)} ${pastTense[kind]}. ${formatNumber(remaining)} ${negated[kind]}.`;
-
 /** Error-banner title for a run stopped by an infrastructure failure. */
 export const bulkActionFailureTitle = (
 	kind: BulkActionKind,

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/list-header-chrome.ts

@@ -1,3 +1,4 @@
+import type { SearchConversion } from "@remit/ui";
 import { createContext, type ReactNode, useContext } from "react";
 
 /**
@@ -31,6 +32,15 @@ export interface ListHeaderChrome {
 	searchResults: ReactNode;
 	/** The search's make-this-a-filter row, up only while nothing is ticked. */
 	makeFilterSlot: ReactNode;
+	/**
+	 * The active query as clauses, which is what the wizard's search entry opens
+	 * on (#484). It travels with the chrome for the same reason the rest does:
+	 * the query belongs to `MailListHeader` and the wizard is mounted by the body
+	 * below it, and one conversion computed in one place is what keeps the reason
+	 * the affordance gives and the clauses the wizard seeds from disagreeing.
+	 * Absent when no query is up.
+	 */
+	searchConversion?: SearchConversion;
 }
 
 const NO_CHROME: ListHeaderChrome = {

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/organize/rule-model.ts

@@ -207,10 +207,6 @@ export const isEvaluablePredicate = (
 	predicate.anchorMessageId !== undefined ||
 	!predicate.literalClauses.some((clause) => clause.field === "HasWords");
 
-/** What the count says when the predicate cannot be counted at all. */
-export const UNCOUNTABLE_PREDICATE_REASON =
-	"Can't count matches — “has the words” reads message bodies, which only a saved rule does.";
-
 /**
  * A stable key for a predicate's match set. Two predicates with the same key
  * match the same messages; a change to the key is what marks the live count

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

@@ -15,6 +15,8 @@ import {
 } from "@remit/ui";
 import {
 	ownedHistoryEntries,
+	wizardEntryFromParam,
+	wizardEntryValue,
 	wizardStepFromParam,
 	wizardStepValue,
 } from "./wizard-history.js";
@@ -72,6 +74,17 @@ describe("re-rooting a wizard that was loaded into", () => {
 		);
 	});
 
+	// The root is the wizard-closed state, so it carries neither the step nor
+	// the affordance that opened it; otherwise closing the wizard leaves the
+	// entry marker behind in the address bar (#484).
+	it("puts the wizard back on a root that names no entry", () => {
+		assert.match(source, /wizard: undefined,\s*\n\s*wizardFrom: undefined,/);
+		assert.match(
+			source,
+			/wizard: openingStep,\s*\n\s*wizardFrom: openingEntry,/,
+		);
+	});
+
 	it("is never armed by a step the app pushed", () => {
 		const goToStep = source.slice(source.indexOf("const goToStep"));
 		assert.doesNotMatch(goToStep, /loadedHoldingStep/);
@@ -107,6 +120,24 @@ describe("the wizard step in the URL", () => {
 	});
 });
 
+describe("which affordance opened the wizard", () => {
+	it("reads the search entry, and everything else as the selection bar", () => {
+		assert.equal(wizardEntryFromParam("search"), "search");
+		for (const value of [undefined, "", "Search", "bar", 1, null, {}]) {
+			assert.equal(wizardEntryFromParam(value), undefined);
+		}
+	});
+
+	it("never fails validation, so a mistyped link still lands on the mail", () => {
+		for (const value of ["nope", "SEARCH", 7, [], null, undefined]) {
+			const parsed = wizardEntryValue.safeParse(value);
+			assert.ok(parsed.success);
+			assert.equal(parsed.data, undefined);
+		}
+		assert.equal(wizardEntryValue.parse("search"), "search");
+	});
+});
+
 describe("the history entries the wizard owns", () => {
 	it("is one per step reached, on every shape of the list", () => {
 		for (const answers of answerSets()) {

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([
@@ -37,6 +37,33 @@ export const wizardStepFromParam = (value: unknown): StepId | undefined => {
 	return parsed.success ? parsed.data : undefined;
 };
 
+/**
+ * Which affordance opened the wizard. Absent is the selection bar; `search` is
+ * the make-filter affordance in the search results header, whose clauses come
+ * from the query rather than from ticked rows (#477 1.8).
+ *
+ * It rides the URL beside the step for the same reason the step does: a
+ * reloaded document has to know which walk it is in the middle of, and the
+ * query it was seeded from is in the URL already. It decides two things and no
+ * more — which step the wizard opens on, and whether the query seeds the
+ * clauses (#477 3.4). One host answers either way.
+ */
+const wizardEntry = z.literal("search");
+
+export type WizardEntry = z.infer<typeof wizardEntry>;
+
+export const wizardEntryFromParam = (
+	value: unknown,
+): WizardEntry | undefined => {
+	const parsed = wizardEntry.safeParse(value);
+	return parsed.success ? parsed.data : undefined;
+};
+
+export const wizardEntryValue = z.unknown().transform(wizardEntryFromParam);
+
+export const useWizardEntryValue = (): WizardEntry | undefined =>
+	useSearch({ from: "/mail", select: (search) => search.wizardFrom });
+
 /**
  * The route's `wizard` field. A value the wizard cannot be on reads as no step
  * rather than as a validation failure, so a truncated or hand-typed link lands
@@ -54,19 +81,66 @@ export const useWizardStepValue = (): StepId | undefined =>
 
 /**
  * Opens the wizard on a step, from a surface that does not drive it — a verb on
- * the selection bar. The push is the wizard's first owned entry, so the back
- * that leaves it lands on the list with the selection still ticked.
+ * the selection bar, or the make-filter affordance on a search. The push is the
+ * wizard's first owned entry, so the back that leaves it lands on the list with
+ * the selection still ticked.
  */
-export const useOpenWizard = (): ((step: StepId) => void) => {
+export const useOpenWizard = (): ((
+	step: StepId,
+	entry?: WizardEntry,
+) => void) => {
 	const navigate = useNavigate();
 	return useCallback(
-		(step: StepId) => {
-			navigate({ to: ".", search: (prev) => ({ ...prev, wizard: step }) });
+		(step: StepId, entry?: WizardEntry) => {
+			navigate({
+				to: ".",
+				search: (prev) => ({ ...prev, wizard: step, wizardFrom: entry }),
+			});
 		},
 		[navigate],
 	);
 };
 
+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;
@@ -78,10 +152,15 @@ export const useWizardStep = (openingStep: StepId): WizardStepNavigation => {
 	const router = useRouter();
 	const navigate = useNavigate();
 	const step = useWizardStepValue();
+	const entry = useWizardEntryValue();
 	// Whether this document loaded already holding a step, which is the one
 	// entrance that leaves the wizard unrooted. A step the app itself pushed
 	// arrives rooted, so re-rooting it would duplicate the entry underneath it.
 	const loadedHoldingStep = useRef(step !== undefined);
+	// The entry that step was reached by, so the root the wizard is put back on
+	// carries neither the step nor the affordance that opened it, and the entry
+	// pushed over it carries both.
+	const loadedEntry = useRef(entry);
 	const pushedTo = useRef<StepId | undefined>(undefined);
 
 	// Two taps on Continue land before the URL settles, and both would push the
@@ -94,15 +173,24 @@ export const useWizardStep = (openingStep: StepId): WizardStepNavigation => {
 	useEffect(() => {
 		if (!loadedHoldingStep.current) return;
 		loadedHoldingStep.current = false;
+		const openingEntry = loadedEntry.current;
 		void (async () => {
 			await navigate({
 				to: ".",
-				search: (prev) => ({ ...prev, wizard: undefined }),
+				search: (prev) => ({
+					...prev,
+					wizard: undefined,
+					wizardFrom: undefined,
+				}),
 				replace: true,
 			});
 			await navigate({
 				to: ".",
-				search: (prev) => ({ ...prev, wizard: openingStep }),
+				search: (prev) => ({
+					...prev,
+					wizard: openingStep,
+					wizardFrom: openingEntry,
+				}),
 			});
 		})();
 	}, [openingStep, navigate]);

package/src/routes/mail.tsx

@@ -43,7 +43,7 @@ import {
 	searchInputForView,
 	shouldMirrorQuery,
 } from "@/lib/search-view";
-import { wizardStepValue } from "@/lib/wizard-history";
+import { wizardEntryValue, wizardStepValue } from "@/lib/wizard-history";
 import "@/lib/client";
 
 // `MailContext` / `useMailContext` live in `@/lib/mail-context` so the provider
@@ -57,6 +57,8 @@ const mailSearchSchema = z.object({
 	// The selection wizard's step (#477 clause 1.6). The router owns history, so
 	// the step is a validated search param rather than a raw pushState entry.
 	wizard: wizardStepValue,
+	// Which affordance opened it, so a reload lands back on the walk it was in.
+	wizardFrom: wizardEntryValue,
 });
 
 export const Route = createFileRoute("/mail")({

package/src/components/mail/organize/SearchFilterDialog.render.test.ts

@@ -1,47 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import React, { createElement } from "react";
-import { renderToString } from "react-dom/server";
-import { parseSearchTokens } from "@/lib/search-tokens";
-import { SearchFilterDialog } from "./SearchFilterDialog";
-
-// The node test loader transpiles remit-ui's `.tsx` with the classic JSX
-// runtime, which references a global `React`.
-(globalThis as { React?: typeof React }).React = React;
-
-const render = (open: boolean, query = "from:receipts@stripe.com") =>
-	renderToString(
-		createElement(
-			QueryClientProvider,
-			{ client: new QueryClient() },
-			createElement(SearchFilterDialog, {
-				open,
-				accountId: "acc-1",
-				parsed: parseSearchTokens(query, {}),
-				searchHadSemanticReach: true,
-				onClose: () => undefined,
-			}),
-		) as never,
-	);
-
-describe("SearchFilterDialog", () => {
-	it("renders nothing when closed", () => {
-		assert.equal(render(false), "");
-	});
-
-	it("shows the conversion step while the seed preview is in flight", () => {
-		assert.match(render(true), /Turning your search into a filter/);
-	});
-
-	it("opens the editor for a free-text search instead of failing to count it", () => {
-		// The free text converts to a `HasWords` clause, which the vector-free
-		// matcher refuses outright. Asking for a count is a 500, so nothing is
-		// asked: the editor opens and the count region carries the reason.
-		const html = render(true, "receipts");
-		assert.doesNotMatch(html, /Turning your search into a filter/);
-		assert.doesNotMatch(html, /Couldn't build the filter/);
-		assert.match(html, /These chips are the whole rule/);
-		assert.match(html, /reads message bodies/);
-	});
-});

package/src/components/mail/organize/SearchFilterDialog.tsx

@@ -1,90 +0,0 @@
-import { Button, buildSearchRule, Dialog } from "@remit/ui";
-import { Loader2 } from "lucide-react";
-import { useMemo } from "react";
-import { useSearchFilterSeed } from "@/hooks/useSearchFilterSeed";
-import { rulePredicate } from "@/lib/organize/rule-model";
-import { convertSearchToRule } from "@/lib/organize/search-to-rule";
-import type { ParsedSearchQuery } from "@/lib/search-tokens";
-import { SearchFilterEditor } from "./SearchFilterEditor";
-
-interface SearchFilterDialogProps {
-	open: boolean;
-	/** The account the filter is created for (an `account:` facet, else the active account). */
-	accountId: string;
-	/** The current search, already split into free text and facets. */
-	parsed: ParsedSearchQuery;
-	/**
-	 * The search surfaced semantically-similar mail (a non-empty "Related"
-	 * section). The literal filter cannot reproduce that reach, so the conversion
-	 * states it — read from the search's own results, never probed (RFC 038 D5).
-	 */
-	searchHadSemanticReach: boolean;
-	onClose: () => void;
-}
-
-/**
- * "Make this a filter" (RFC 038 D5). Converts the current search to clauses and
- * hands off to the shared chip editor pre-filled. No new endpoint: the seed
- * count rides `POST /organize/preview` and the commit drives the existing filter
- * CRUD.
- */
-export function SearchFilterDialog({
-	open,
-	accountId,
-	parsed,
-	searchHadSemanticReach,
-	onClose,
-}: SearchFilterDialogProps) {
-	const conversion = useMemo(
-		() => convertSearchToRule(parsed, { searchHadSemanticReach }),
-		[parsed, searchHadSemanticReach],
-	);
-	const literalPredicate = useMemo(
-		() => rulePredicate(buildSearchRule(conversion)),
-		[conversion],
-	);
-
-	const { seedCount, isPending, isError, retry } = useSearchFilterSeed(
-		open ? accountId : undefined,
-		literalPredicate,
-	);
-	// A search kept as a `HasWords` clause has no seed count and never will; the
-	// editor opens on the uncountable reason rather than a dead end.
-
-	if (!open) return null;
-
-	return (
-		<Dialog open={open} onClose={onClose} title="Filter rule">
-			{isError ? (
-				<div className="flex flex-col items-center gap-3 px-5 py-8 text-center">
-					<p className="text-sm font-medium text-danger">
-						Couldn't build the filter
-					</p>
-					<p className="max-w-xs text-xs text-fg-muted">Please try again.</p>
-					<div className="mt-2 flex gap-2">
-						<Button variant="primary" onClick={retry}>
-							Try again
-						</Button>
-						<Button variant="ghost" onClick={onClose}>
-							Not now
-						</Button>
-					</div>
-				</div>
-			) : isPending ? (
-				<div className="flex flex-col items-center gap-3 px-5 py-10 text-center">
-					<Loader2 className="size-8 animate-spin text-accent-2" />
-					<p className="text-sm font-medium text-fg">
-						Turning your search into a filter…
-					</p>
-				</div>
-			) : (
-				<SearchFilterEditor
-					accountId={accountId}
-					conversion={conversion}
-					seedCount={seedCount}
-					onClose={onClose}
-				/>
-			)}
-		</Dialog>
-	);
-}