From bfee96a859aa0d225b845d67625d34ea6ae773d2 Mon Sep 17 00:00:00 2001 From: Luke Parker <10430890+Hona@users.noreply.github.com> Date: Fri, 20 Nov 2026 06:03:42 -0600 Subject: [PATCH] fix(browser): confirm before clearing browsing data (#65124) --- .../component-tests/browser-settings.spec.ts | 102 +++++++++++++++--- packages/gui-plugins/src/browser/i18n/en.ts | 5 +- .../src/browser/jobs-machine.test.ts | 89 +++++++++++++-- .../gui-plugins/src/browser/jobs-machine.ts | 40 +++++-- packages/gui-plugins/src/browser/jobs.ts | 27 ++++- .../src/browser/settings.fixture.tsx | 46 +++++++- 6 files changed, 278 insertions(+), 31 deletions(-) diff --git a/packages/app/component-tests/browser-settings.spec.ts b/packages/app/component-tests/browser-settings.spec.ts index aaa73e85830..bd3edb0c261 100644 --- a/packages/app/component-tests/browser-settings.spec.ts +++ b/packages/app/component-tests/browser-settings.spec.ts @@ -6,20 +6,37 @@ const source = (path: string) => sourceURL(new URL(path, import.meta.url)) const modules = { fixture: source("../../gui-plugins/src/browser/settings.fixture.tsx"), ui: source("../src/runtime/plugin/ui.tsx"), + // The app's own confirmation dialog, which `Dialogs.confirm` shows, and the language it reads. + dialogs: source("../src/runtime/plugin/dialogs.tsx"), + language: source("../src/runtime/i18n/language.tsx"), } // Any story loads the app styles; the fixture mounts the real Settings > Browser page beside it. `target` is the entry // a settings search or the command palette is revealing. async function open( page: Page, - options?: { target?: string; extensions?: boolean; installed?: boolean; historyKept?: boolean; file?: { imported: number; failed: number } | "unreadable" }, + options?: { + target?: string + extensions?: boolean + installed?: boolean + historyKept?: boolean + clearFails?: boolean + file?: { imported: number; failed: number } | "unreadable" + }, ) { await page.evaluate( async (input) => { - const [{ mountBrowserSettings }, { ui }] = await Promise.all([import(input.modules.fixture), import(input.modules.ui)]) + const [{ mountBrowserSettings }, { ui }, { PluginConfirmDialog }, { LanguageProvider }] = await Promise.all([ + import(input.modules.fixture), + import(input.modules.ui), + import(input.modules.dialogs), + import(input.modules.language), + ]) mountBrowserSettings({ ui, + host: { Confirm: PluginConfirmDialog, LanguageProvider }, + clearFails: input.options?.clearFails, target: input.options?.target, extensions: input.options?.extensions, installed: input.options?.installed, @@ -36,6 +53,13 @@ async function open( root, advanced: root.getByRole("button", { name: /^Advanced/ }), stored: root.getByTestId("browser-settings-stored"), + data: root.getByRole("region", { name: "Browser data", exact: true }), + // The red button, and the question it asks before anything is cleared. + clear: root.getByRole("region", { name: "Browser data", exact: true }).getByRole("button", { name: "Clear browsing data", exact: true }), + confirm: page.getByRole("dialog", { name: "Clear browsing data?", exact: true }), + // How often main was asked to clear. The dialog is modal, so this is hidden from the accessibility tree meanwhile. + clears: root.getByTestId("browser-settings-clears"), + visits: root.getByTestId("browser-settings-visits"), } } @@ -99,18 +123,72 @@ story("each switch is named by its row's title, and each row says what it does i await expect(sites.locator("p")).toHaveText("Agent and remote server tabs ask again. Clearing browsing data keeps saved permissions.") }) -story("clearing browsing data that left the history behind says so in its row, and still forgets the window's last pages", async ({ page }) => { - const view = await open(page, { target: "settings-browser-cookies", historyKept: true }) - const data = view.root.getByRole("region", { name: "Browser data", exact: true }) - const clear = data.getByRole("button", { name: "Clear browsing data", exact: true }) +story("the red button asks first: Cancel, Escape, Enter on Cancel and a click outside clear nothing, and the confirm clears once", async ({ page }) => { + const view = await open(page, { target: "settings-browser-cookies" }) + const cancel = view.confirm.getByRole("button", { name: "Cancel", exact: true }) + const confirm = view.confirm.getByRole("button", { name: "Clear data", exact: true }) - await expect(view.root.getByTestId("browser-settings-visits")).toHaveText("1") - await expect(data.getByText("0 cookies. Sign-ins are shared across sessions.", { exact: true })).toBeVisible() - await clear.click() + await expect(view.data.getByText("0 cookies. Sign-ins are shared across sessions.", { exact: true })).toBeVisible() + await view.clear.click() + // One title, one line, two buttons: no close button, as the app's other confirmations. + await expect(view.confirm.getByText("This signs you out of all sites and deletes history in OpenCode, leaving your other browsers untouched.", { exact: true })).toBeVisible() + await expect(view.confirm.getByRole("button")).toHaveText(["Cancel", "Clear data"]) + // As the app's destructive confirmations do, it opens on Cancel, so Enter does not clear by accident. + await expect(cancel).toBeFocused() + await page.keyboard.press("Tab") + await expect(confirm).toBeFocused() + await page.keyboard.press("Shift+Tab") + await page.keyboard.press("Enter") + await expect(view.confirm).toHaveCount(0) + await expect(view.clears).toHaveText("0") + + for (const dismiss of [ + () => cancel.click(), + () => page.keyboard.press("Escape"), + // Outside the dialog: the dimmed page behind it. + () => page.mouse.click(8, 8), + ]) { + await view.clear.click() + await expect(cancel).toBeFocused() + await dismiss() + await expect(view.confirm).toHaveCount(0) + await expect(view.clears).toHaveText("0") + } + + // Nothing ran: the row still shows the count, the window's last pages are there, and the button is ready again. + await expect(view.data.getByText("0 cookies. Sign-ins are shared across sessions.", { exact: true })).toBeVisible() + await expect(view.visits).toHaveText("1") + await expect(view.clear).toBeEnabled() + + // Confirmed, with a second press on its way: main is asked once, and the row says how it ended. + await view.clear.click() + await confirm.dblclick() + await expect(view.confirm).toHaveCount(0) + await expect(view.data.getByText("Cleared browsing data.", { exact: true })).toBeVisible() + await expect(view.clears).toHaveText("1") + await expect(view.visits).toHaveText("0") +}) + +story("a confirmed clear that left the history behind says so in its row", async ({ page }) => { + const kept = await open(page, { target: "settings-browser-cookies", historyKept: true }) + + await kept.clear.click() + await kept.confirm.getByRole("button", { name: "Clear data", exact: true }).click() // The sign-ins and site data went, so the row does not call it failed; it says what stayed. - await expect(data.getByText("Cleared browsing data. The history could not be cleared.", { exact: true })).toBeVisible() - await expect(view.root.getByTestId("browser-settings-visits")).toHaveText("0") - await expect(clear).toBeEnabled() + await expect(kept.data.getByText("Cleared sign-ins and site data, but history could not be cleared.", { exact: true })).toBeVisible() + await expect(kept.visits).toHaveText("0") + await expect(kept.clear).toBeEnabled() +}) + +story("a confirmed clear that main rejects says that it could not clear, and can be tried again", async ({ page }) => { + const view = await open(page, { target: "settings-browser-cookies", clearFails: true }) + + await view.clear.click() + await view.confirm.getByRole("button", { name: "Clear data", exact: true }).click() + await expect(view.data.getByText("Couldn't clear browsing data. Try again.", { exact: true })).toBeVisible() + await expect(view.clears).toHaveText("1") + await expect(view.visits).toHaveText("1") + await expect(view.clear).toBeEnabled() }) // A cookie file is cookies, so its row counts them: the one place an import says "cookies". diff --git a/packages/gui-plugins/src/browser/i18n/en.ts b/packages/gui-plugins/src/browser/i18n/en.ts index 81ad28a17fb..3c0daab63da 100644 --- a/packages/gui-plugins/src/browser/i18n/en.ts +++ b/packages/gui-plugins/src/browser/i18n/en.ts @@ -239,7 +239,10 @@ export default { "settings.cookies.count.other": "{{count}} cookies. Sign-ins are shared across sessions.", "settings.cookies.clear": "Clear browsing data", "settings.cleared": "Cleared browsing data.", - "settings.cleared.history": "Cleared browsing data. The history could not be cleared.", + "settings.cleared.history": "Cleared sign-ins and site data, but history could not be cleared.", + "settings.clear.confirm.title": "Clear browsing data?", + "settings.clear.confirm.description": "This signs you out of all sites and deletes history in OpenCode, leaving your other browsers untouched.", + "settings.clear.confirm.action": "Clear data", "menu.back": "Back", "menu.forward": "Forward", "menu.reload": "Reload", diff --git a/packages/gui-plugins/src/browser/jobs-machine.test.ts b/packages/gui-plugins/src/browser/jobs-machine.test.ts index 12db2a2e435..809f76001ab 100644 --- a/packages/gui-plugins/src/browser/jobs-machine.test.ts +++ b/packages/gui-plugins/src/browser/jobs-machine.test.ts @@ -42,7 +42,7 @@ function replay(events: readonly JobsEvent[]) { test("runs one job at a time and reports the outcome with the job that ran", () => { const result = replay([ { type: "started", job: edge }, - // A second click while the import runs starts nothing. + // A second click while the import runs starts nothing, and asks nothing. { type: "started", job: { type: "clear" } }, { type: "finished", attempt: 1, outcome: imported }, ]) @@ -65,7 +65,7 @@ test("a timed-out job ends in an error, and its late reply changes nothing", () { type: "started", job: store }, { type: "timed-out", attempt: 1 }, { type: "finished", attempt: 1, outcome: imported }, - { type: "started", job: { type: "clear" } }, + { type: "started", job: edge }, { type: "failed", attempt: 1 }, ]) @@ -74,7 +74,7 @@ test("a timed-out job ends in an error, and its late reply changes nothing", () { type: "abort", attempt: 1 }, { type: "notify", finished: { job: store, outcome: { type: "error" } } }, ]) - expect(runningJob(result.state)).toEqual({ type: "clear" }) + expect(runningJob(result.state)).toEqual(edge) }) test("dismissing clears the last outcome only while nothing runs", () => { @@ -93,15 +93,90 @@ test("dismissing clears the last outcome only while nothing runs", () => { test("leaving the surface aborts the running job, and nothing runs after", () => { const result = replay([ - { type: "started", job: { type: "clear" } }, + { type: "started", job: edge }, { type: "disposed" }, - { type: "finished", attempt: 1, outcome: { type: "cleared", history: true } }, - { type: "started", job: { type: "clear" } }, + { type: "finished", attempt: 1, outcome: imported }, + { type: "started", job: edge }, ]) expect(result.effects).toEqual([ - { type: "run", attempt: 1, job: { type: "clear" }, timeoutMs: 60_000 }, + { type: "run", attempt: 1, job: edge, timeoutMs: 300_000 }, { type: "abort", attempt: 1 }, ]) expect(result.state).toEqual({ status: "disposed" }) }) + +// Clearing the browsing data cannot be undone, so the person is asked first. The pane's driver answers "no" for +// Cancel, Escape, a click outside and a question that closed with its surface, so each of those is `confirmed: false`. +const clear: Job = { type: "clear" } + +const cleared = { type: "cleared" as const, history: true } + +const ran: JobsEffect = { type: "run", attempt: 1, job: clear, timeoutMs: 60_000 } + +const asked: JobsEffect = { type: "confirm", attempt: 1, job: clear } + +test("clearing asks first: nothing runs until the person confirms, and a no leaves the surface as it was", () => { + const before = replay([{ type: "started", job: edge }, { type: "finished", attempt: 1, outcome: imported }]) + const open = transitionJobs(before.state, { type: "started", job: clear }) + + // Only the question: no call to main. The last result stays on the surface behind it. + expect(open.effects).toEqual([{ type: "confirm", attempt: 2, job: clear }]) + expect(runningJob(open.state)).toBeUndefined() + expect(lastFinished(open.state)).toEqual({ job: edge, outcome: imported }) + + // Cancel, Escape or a click outside: nothing ran, and the surface is as before the question. + const declined = transitionJobs(open.state, { type: "answered", attempt: 2, confirmed: false }) + expect(declined.effects).toEqual([]) + expect(declined.state).toEqual({ status: "idle", attempt: 2, last: { job: edge, outcome: imported } }) + + // Asked again and confirmed, it runs once, under the attempt its question claimed. + const again = transitionJobs(declined.state, { type: "started", job: clear }) + const confirmed = transitionJobs(again.state, { type: "answered", attempt: 3, confirmed: true }) + expect(confirmed.effects).toEqual([{ type: "run", attempt: 3, job: clear, timeoutMs: 60_000 }]) + expect(runningJob(confirmed.state)).toEqual(clear) +}) + +test("a confirmed clear runs once, however often the button or the answer is pressed", () => { + const result = replay([ + { type: "started", job: clear }, + // The red button again, and another job, while the question is open: neither starts anything. + { type: "started", job: clear }, + { type: "started", job: edge }, + { type: "answered", attempt: 1, confirmed: true }, + // A second press of the dialog's button, and a late no, change nothing. + { type: "answered", attempt: 1, confirmed: true }, + { type: "answered", attempt: 1, confirmed: false }, + { type: "finished", attempt: 1, outcome: cleared }, + ]) + + expect(result.effects).toEqual([asked, ran, { type: "abort", attempt: 1 }, { type: "notify", finished: { job: clear, outcome: cleared } }]) + expect(lastFinished(result.state)).toEqual({ job: clear, outcome: cleared }) +}) + +test("an answer to an earlier question, or after the surface went, clears nothing", () => { + const stale = replay([ + { type: "started", job: clear }, + { type: "answered", attempt: 1, confirmed: false }, + { type: "started", job: clear }, + // The first question's yes arrives late: the open question is the second. + { type: "answered", attempt: 1, confirmed: true }, + ]) + + expect(stale.effects).toEqual([asked, { type: "confirm", attempt: 2, job: clear }]) + expect(stale.state).toMatchObject({ status: "confirming", attempt: 2 }) + + // The surface goes while the question is open: no call was made, so there is none to abort, and a yes runs nothing. + const gone = replay([{ type: "started", job: clear }, { type: "disposed" }, { type: "answered", attempt: 1, confirmed: true }]) + expect(gone.effects).toEqual([asked]) + expect(gone.state).toEqual({ status: "disposed" }) +}) + +test("a confirmed clear that fails or times out ends in an error the surface says", () => { + for (const failure of [{ type: "failed" as const, attempt: 1 }, { type: "timed-out" as const, attempt: 1 }]) { + const result = replay([{ type: "started", job: clear }, { type: "answered", attempt: 1, confirmed: true }, failure]) + + expect(result.effects).toEqual([asked, ran, { type: "abort", attempt: 1 }, { type: "notify", finished: { job: clear, outcome: { type: "error" } } }]) + expect(lastFinished(result.state)).toEqual({ job: clear, outcome: { type: "error" } }) + } +}) diff --git a/packages/gui-plugins/src/browser/jobs-machine.ts b/packages/gui-plugins/src/browser/jobs-machine.ts index dbda0eb92e3..9b97a07dba5 100644 --- a/packages/gui-plugins/src/browser/jobs-machine.ts +++ b/packages/gui-plugins/src/browser/jobs-machine.ts @@ -46,15 +46,20 @@ export type Finished = { readonly job: Job; readonly outcome: Outcome } /** * A surface runs one job at a time; main runs the jobs of every surface one after another. * - `idle`: nothing runs; `last` is the previous job and its outcome, until the next one starts. + * - `confirming`: the person is asked whether `job` should run, as `attempt`; nothing has run yet, and `last` comes + * back if they say no. An answer to any other attempt is stale. * - `running`: `job` runs as `attempt`; a result of any other attempt is stale. */ export type JobsState = | { readonly status: "idle"; readonly attempt: number; readonly last: Finished | undefined } + | { readonly status: "confirming"; readonly attempt: number; readonly job: Job; readonly last: Finished | undefined } | { readonly status: "running"; readonly attempt: number; readonly job: Job } | { readonly status: "disposed" } export type JobsEvent = | { readonly type: "started"; readonly job: Job } + /** The person answered the question of `attempt`. Closing the question any other way is a no. */ + | { readonly type: "answered"; readonly attempt: number; readonly confirmed: boolean } | { readonly type: "finished"; readonly attempt: number; readonly outcome: Outcome } | { readonly type: "failed"; readonly attempt: number } | { readonly type: "timed-out"; readonly attempt: number } @@ -63,6 +68,8 @@ export type JobsEvent = | { readonly type: "disposed" } export type JobsEffect = + /** Asks the person whether `job` should run; the answer names `attempt`. */ + | { readonly type: "confirm"; readonly attempt: number; readonly job: Job } | { readonly type: "run"; readonly attempt: number; readonly job: Job; readonly timeoutMs: number } /** Ends the attempt's timer and drops its call's reply. */ | { readonly type: "abort"; readonly attempt: number } @@ -104,13 +111,24 @@ export function transitionJobs(state: JobsState, event: JobsEvent): JobsTransiti } if (event.type === "started") { - if (state.status === "running") return { state, effects: [] } + // One job at a time: a second press while one runs, or while its question is open, starts nothing. + if (state.status !== "idle") return { state, effects: [] } const attempt = state.attempt + 1 - return { - state: { status: "running", attempt, job: event.job }, - effects: [{ type: "run", attempt, job: event.job, timeoutMs: JOB_TIMEOUT_MS[event.job.type] }], - } + // What a job deletes cannot be brought back, so it asks first, wherever it was started from. + if (deletes(event.job)) + return { state: { status: "confirming", attempt, job: event.job, last: state.last }, effects: [{ type: "confirm", attempt, job: event.job }] } + + return run(attempt, event.job) + } + + if (event.type === "answered") { + if (state.status !== "confirming" || event.attempt !== state.attempt) return { state, effects: [] } + + if (event.confirmed) return run(state.attempt, state.job) + + // Nothing ran: the surface is as it was before the question. + return { state: { status: "idle", attempt: state.attempt, last: state.last }, effects: [] } } if (state.status !== "running" || event.attempt !== state.attempt) return { state, effects: [] } @@ -132,8 +150,18 @@ export function runningJob(state: JobsState) { return state.status === "running" ? state.job : undefined } +/** The last job and its outcome, which stay on the surface while the person is asked about the next one. */ export function lastFinished(state: JobsState) { - return state.status === "idle" ? state.last : undefined + return state.status === "idle" || state.status === "confirming" ? state.last : undefined +} + +/** Whether a job deletes what cannot be brought back, so the person is asked before it runs. */ +function deletes(job: Job) { + return job.type === "clear" +} + +function run(attempt: number, job: Job): JobsTransition { + return { state: { status: "running", attempt, job }, effects: [{ type: "run", attempt, job, timeoutMs: JOB_TIMEOUT_MS[job.type] }] } } /** Whether an import wrote cookies, so the user is signed in where the other browser was. */ diff --git a/packages/gui-plugins/src/browser/jobs.ts b/packages/gui-plugins/src/browser/jobs.ts index 78b78f7c674..eba7b43cc6c 100644 --- a/packages/gui-plugins/src/browser/jobs.ts +++ b/packages/gui-plugins/src/browser/jobs.ts @@ -1,4 +1,4 @@ -import { createSignal, onCleanup, untrack } from "solid-js" +import { createSignal, getOwner, onCleanup, runWithOwner, untrack } from "solid-js" import { createKeyed, createLatest, usePlugin, type IpcClient } from "@opencode/plugin/gui" import type { Choice } from "./choices" import type definition from "./index" @@ -69,6 +69,18 @@ export function createProfileJobs( return current.status === "active" ? `${current.generation}:${version()}` : undefined } + // A question belongs to the surface that asked, so it goes with it. + const owner = getOwner() + + // What the person is asked before the one job that deletes: clearing the browsing data. + const question = () => ({ + title: ctx.t("settings.clear.confirm.title"), + description: ctx.t("settings.clear.confirm.description"), + confirm: ctx.t("settings.clear.confirm.action"), + cancel: ctx.t("common.cancel"), + danger: true, + }) + const dispatch = (event: JobsEvent) => { const next = transitionJobs(untrack(state), event) setState(next.state) @@ -76,6 +88,19 @@ export function createProfileJobs( } const run = (effect: JobsEffect) => { + if (effect.type === "confirm") { + const attempt = effect.attempt + + // The app's own confirmation: it starts on Cancel, and Escape or a click outside answers no. It closes with + // the surface that asked, which is a no too, as is a question that could not be asked. + const asked = runWithOwner(owner, () => ctx.dialogs.confirm(question())) ?? Promise.resolve(false) + + return void asked.then( + (confirmed) => dispatch({ type: "answered", attempt, confirmed }), + () => dispatch({ type: "answered", attempt, confirmed: false }), + ) + } + if (effect.type === "notify") { setVersion((value) => value + 1) input.finished?.(effect.finished) diff --git a/packages/gui-plugins/src/browser/settings.fixture.tsx b/packages/gui-plugins/src/browser/settings.fixture.tsx index aba76bcbacd..e7a90fbcfee 100644 --- a/packages/gui-plugins/src/browser/settings.fixture.tsx +++ b/packages/gui-plugins/src/browser/settings.fixture.tsx @@ -1,9 +1,9 @@ import { DialogProvider, useDialog } from "@opencode/ui/context/dialog" -import type { JSX } from "solid-js" +import type { Component, JSX } from "solid-js" import { createStore, produce } from "solid-js/store" import { render } from "solid-js/web" import { liveAccessor, PluginContext } from "@opencode/plugin/gui/host" -import type { Context, SetupContext, Ui } from "@opencode/plugin/gui" +import type { ConfirmOptions, Context, SetupContext, Ui } from "@opencode/plugin/gui" import browserEn from "./i18n/en" import type definition from "./index" import type { ExtensionAccess, ExtensionCompatibility, ImportResult, InstallResult, ProfileSource } from "./profile/ipc" @@ -23,6 +23,12 @@ const badge = (bg: string, fg: string, glyph: string) => `${glyph.replaceAll("FG", fg)}`, )}` +/** What the fixture takes from the app, which this package cannot import. */ +type SettingsHost = { + readonly Confirm: Component<{ options: ConfirmOptions; done: (confirmed: boolean) => void }> + readonly LanguageProvider: Component<{ locale: string; children: JSX.Element }> +} + const sampleSources: readonly ProfileSource[] = [ { id: "helium", name: "Helium", engine: "chromium", profiles: [{ id: "Default", name: "Default" }] }, { id: "chrome", name: "Chrome", engine: "chromium", profiles: [{ id: "Default", name: "Default" }] }, @@ -78,13 +84,17 @@ const sampleExtensionEntries: readonly (readonly [string, readonly SampleExtensi // which stays set for the whole visit, as the host leaves it. With `extensions`, Chromium browsers and their extensions // are populated so the real Add an extension dialog can be driven end to end. `historyKept` is a sign-out that left // main's history behind: its file could not be removed. `file` is what importing the cookie file the person picks -// brings: how many cookies came and how many could not be imported, or that the file could not be read. +// brings: how many cookies came and how many could not be imported, or that the file could not be read. `clearFails` +// is main rejecting the clear. `host` is the app's own confirmation dialog, which `Dialogs.confirm` shows, with the +// language it reads its default labels from. export function mountBrowserSettings(input: { ui: Ui + host: SettingsHost target?: string extensions?: boolean installed?: boolean historyKept?: boolean + clearFails?: boolean file?: { imported: number; failed: number } | "unreadable" }) { const host = document.createElement("main") @@ -105,6 +115,9 @@ export function mountBrowserSettings(input: { welcomed: true, }) + // How often main was asked to clear the browsing data. + const [calls, setCalls] = createStore({ clear: 0 }) + // The window's list of the last pages, which a sign-out empties. const [history, setHistory] = createStore<{ visits: readonly { url: string; title: string }[] }>({ visits: [{ url: "https://alpha.example/", title: "Alpha" }], @@ -134,7 +147,13 @@ export function mountBrowserSettings(input: { on: () => () => undefined, sources: async () => (input.extensions ? [...sampleSources] : []), summary: async () => ({ cookies: 0, persistent: true }), - clear: async () => ({ history: !input.historyKept }), + clear: async () => { + setCalls("clear", (count) => count + 1) + + if (input.clearFails) throw new Error("the profile could not be cleared") + + return { history: !input.historyKept } + }, importFile: async (): Promise => { if (input.file === "unreadable") return { type: "failed", reason: "read" } @@ -227,6 +246,24 @@ export function mountBrowserSettings(input: { return handle }, + // As the host does: the content's answer, or no once the dialog ends without one; the first wins. + confirm: (options: ConfirmOptions) => + new Promise((resolve) => + dialog.show( + () => ( + + { + resolve(confirmed) + dialog.close() + }} + /> + + ), + () => resolve(false), + ), + ), }, stores: { preferences: { @@ -248,6 +285,7 @@ export function mountBrowserSettings(input: { {JSON.stringify(preferences)} {history.visits.length} + {calls.clear} ) }