akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/plugins/dialog/android/DialogPlugin.kt

@@ -0,0 +1,260 @@
+package com.akanjs.plugins.dialog
+
+import android.app.AlertDialog
+import android.content.Context
+import android.content.DialogInterface
+import android.text.SpannableString
+import android.text.Spanned
+import android.text.style.ForegroundColorSpan
+import android.util.Log
+import android.util.TypedValue
+import android.view.KeyEvent
+import android.view.WindowManager
+import android.view.inputmethod.EditorInfo
+import android.widget.EditText
+import android.widget.FrameLayout
+import android.widget.LinearLayout
+import android.widget.TextView
+import com.akanjs.runtime.AkanNativeErrorCode
+import com.akanjs.runtime.AkanNativePluginContext
+import com.akanjs.runtime.AkanNativeReply
+import com.akanjs.runtime.AkanNativeVoidReply
+
+/**
+ * alert / confirm / prompt / actionSheet with the framework android.app.AlertDialog: no AndroidX,
+ * no Material (docs/plugins.md §2, §4.2). Argument rules are those of src/options.ts: the generated
+ * DialogPluginSpec (PL-10) decodes and type-checks the arguments, the rules beyond the types keep
+ * src/options.ts's messages.
+ * - AlertDialog.Builder(activity) takes the activity's Theme.DeviceDefault.DayNight, so dark mode and
+ *   the device's dialog look come with it. Default button titles are the framework's localized
+ *   android.R.string.ok / cancel.
+ * - Back and a tap outside cancel, as in Capacitor (capacitor-plugins/dialog/…/Dialog.java:57-60) and
+ *   wry (wry/src/android/kotlin/RustWebChromeClient.kt:141-160). Every dialog also answers from
+ *   onDismiss, which runs after a button's listener; react-native consumes its callback once the same
+ *   way (react-native/…/modules/dialog/DialogModule.kt:73-93), and AkanNativeCall ignores the second answer.
+ * - At most three buttons fit an AlertDialog (react-native/…/Alert/Alert.js:128-136). That is enough for
+ *   alert/confirm/prompt; action-sheet options are list rows and only the cancel option is a button.
+ */
+class DialogPlugin(private val context: AkanNativePluginContext) : DialogPluginSpec {
+    private val showing = LinkedHashSet<AlertDialog>()
+
+    override fun destroy() {
+        // The activity is going away and the page with it: close without answering, without leaking windows.
+        for (dialog in showing.toList()) {
+            dialog.setOnDismissListener(null)
+            dialog.dismiss()
+        }
+        showing.clear()
+    }
+
+    // ---------------------------------------------------------------- methods
+
+    override fun alert(args: DialogAlertOptions, reply: AkanNativeVoidReply) {
+        val (title, message) = heading(args.title, args.message, reply) ?: return
+        val ok = label(args.buttonTitle, android.R.string.ok)
+        val builder = builder(title).setMessage(message).setPositiveButton(ok) { _, _ -> answer(reply, Unit) }
+        show(reply, builder.create(), Unit)
+    }
+
+    override fun confirm(args: DialogConfirmOptions, reply: AkanNativeReply<DialogConfirmResult>) {
+        val (title, message) = heading(args.title, args.message, reply) ?: return
+        val ok = label(args.okButtonTitle, android.R.string.ok)
+        val cancel = label(args.cancelButtonTitle, android.R.string.cancel)
+        val cancelled = DialogConfirmResult(value = false)
+        val builder = builder(title)
+            .setMessage(message)
+            .setPositiveButton(ok) { _, _ -> answer(reply, DialogConfirmResult(value = true)) }
+            .setNegativeButton(cancel) { _, _ -> answer(reply, cancelled) }
+        show(reply, builder.create(), cancelled)
+    }
+
+    override fun prompt(args: DialogPromptOptions, reply: AkanNativeReply<DialogPromptResult>) {
+        val (title, message) = heading(args.title, args.message, reply) ?: return
+        val ok = label(args.okButtonTitle, android.R.string.ok)
+        val cancel = label(args.cancelButtonTitle, android.R.string.cancel)
+        val placeholder = args.inputPlaceholder ?: ""
+        // wry's onJsPrompt drops the default value (RustWebChromeClient.kt:206-221); keep it.
+        val initial = args.inputText ?: ""
+        val cancelled = DialogPromptResult(value = "", cancelled = true)
+
+        val builder = builder(title).setMessage(message)
+        val themed = builder.context // the alert dialog theme, for the field and its padding
+        val input = EditText(themed).apply {
+            setSingleLine()
+            imeOptions = EditorInfo.IME_ACTION_DONE
+            hint = placeholder
+            setText(initial)
+            setSelection(initial.length) // caret at the end, as UITextField does
+        }
+        // Capacitor and wry add the EditText edge to edge; the dialog's content padding aligns it with the message.
+        val pad = dimension(themed, android.R.attr.dialogPreferredPadding, 24)
+        val box = FrameLayout(themed).apply {
+            setPadding(pad, 0, pad, 0)
+            addView(input)
+        }
+        builder.setView(box)
+            // Not trimmed: Capacitor trims on Android only (capacitor-plugins/dialog/…/Dialog.java:143).
+            .setPositiveButton(ok) { _, _ -> answer(reply, DialogPromptResult(value = input.text.toString(), cancelled = false)) }
+            .setNegativeButton(cancel) { _, _ -> answer(reply, cancelled) }
+        val dialog = builder.create()
+        dialog.setCanceledOnTouchOutside(false) // a stray tap beside the keyboard must not throw the text away
+        input.setOnEditorActionListener { _, action, event ->
+            val enter = action == EditorInfo.IME_ACTION_DONE ||
+                (event?.keyCode == KeyEvent.KEYCODE_ENTER && event.action == KeyEvent.ACTION_DOWN)
+            if (enter) dialog.getButton(DialogInterface.BUTTON_POSITIVE)?.performClick()
+            enter
+        }
+        dialog.window?.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE)
+        input.requestFocus()
+        show(reply, dialog, cancelled)
+    }
+
+    override fun actionSheet(args: DialogActionSheetOptions, reply: AkanNativeReply<DialogActionSheetResult>) {
+        val title = args.title?.ifEmpty { null }
+        val message = args.message?.ifEmpty { null }
+        val options = sheetOptions(args.options, reply) ?: return
+        val cancelled = DialogActionSheetResult(index = -1.0, cancelled = true)
+
+        val builder = AlertDialog.Builder(context.activity)
+        val themed = builder.context
+        val cancelIndex = options.indexOfFirst { it.second == DialogActionSheetOptionStyle.CANCEL }
+        val rows = options.indices.filter { it != cancelIndex }
+        val danger = color(themed, android.R.attr.colorError)
+        val items = rows.map<Int, CharSequence> { i ->
+            val (label, style) = options[i]
+            if (style == DialogActionSheetOptionStyle.DESTRUCTIVE && danger != null) {
+                SpannableString(label).apply { setSpan(ForegroundColorSpan(danger), 0, length, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE) }
+            } else {
+                label
+            }
+        }.toTypedArray()
+        // setMessage hides the setItems list (react-native/…/modules/dialog/AlertFragment.kt:158-162),
+        // so a message goes into a custom title.
+        if (message != null) builder.setCustomTitle(header(themed, title, message)) else if (title != null) builder.setTitle(title)
+        builder.setItems(items) { _, which -> answer(reply, DialogActionSheetResult(index = rows[which].toDouble(), cancelled = false)) }
+        if (cancelIndex >= 0) builder.setNegativeButton(options[cancelIndex].first) { _, _ -> answer(reply, cancelled) }
+        show(reply, builder.create(), cancelled)
+    }
+
+    // ---------------------------------------------------------------- showing
+
+    private fun builder(title: String?): AlertDialog.Builder =
+        AlertDialog.Builder(context.activity).apply { if (title != null) setTitle(title) }
+
+    private fun <T> show(reply: AkanNativeReply<T>, dialog: AlertDialog, cancelled: T) {
+        val activity = context.activity
+        // Showing on a finishing activity throws BadTokenException. Capacitor rejects and wry returns
+        // without answering (capacitor-plugins/dialog/…/DialogPlugin.java:25-28, RustWebChromeClient.kt:142);
+        // answering as cancelled keeps the page going.
+        if (activity.isFinishing || activity.isDestroyed) return answer(reply, cancelled)
+        dialog.setOnDismissListener {
+            showing.remove(dialog)
+            answer(reply, cancelled)
+        }
+        showing.add(dialog)
+        try {
+            dialog.show()
+        } catch (e: WindowManager.BadTokenException) {
+            showing.remove(dialog)
+            return answer(reply, cancelled)
+        }
+        // The dialog belongs to its call: the page gave up on it (AbortSignal) or went away (reload,
+        // navigation), so it goes too instead of staying on screen for a page that cannot hear it.
+        reply.onCancel {
+            dialog.setOnDismissListener(null)
+            showing.remove(dialog)
+            dialog.dismiss()
+        }
+        // The title as an accessibility heading, as react-native does (AlertFragment.kt:99-131).
+        val titleId = dialog.context.resources.getIdentifier("alertTitle", "id", "android")
+        if (titleId != 0) dialog.findViewById<TextView>(titleId)?.isAccessibilityHeading = true
+    }
+
+    /** After a page reload the shell's reply port is closed; that must not crash a button click. */
+    private fun <T> answer(reply: AkanNativeReply<T>, result: T) {
+        try {
+            reply.resolve(result)
+        } catch (e: RuntimeException) {
+            Log.w("AkanNative", "dialog: answer dropped", e)
+        }
+    }
+
+    /** Title and message for an action sheet with a message (the stock title is a single line). */
+    private fun header(themed: Context, title: String?, message: String): LinearLayout {
+        val pad = dimension(themed, android.R.attr.dialogPreferredPadding, 24)
+        val dp = themed.resources.displayMetrics.density
+        return LinearLayout(themed).apply {
+            orientation = LinearLayout.VERTICAL
+            setPadding(pad, (18 * dp).toInt(), pad, (4 * dp).toInt())
+            if (title != null) {
+                addView(TextView(themed, null, android.R.attr.windowTitleStyle).apply {
+                    text = title
+                    isAccessibilityHeading = true
+                })
+            }
+            addView(TextView(themed).apply {
+                text = message
+                color(themed, android.R.attr.textColorSecondary)?.let(::setTextColor)
+                if (title != null) setPadding(0, (8 * dp).toInt(), 0, 0)
+            })
+        }
+    }
+
+    private fun dimension(themed: Context, attr: Int, fallbackDp: Int): Int {
+        val value = TypedValue()
+        val metrics = themed.resources.displayMetrics
+        return if (themed.theme.resolveAttribute(attr, value, true) && value.type == TypedValue.TYPE_DIMENSION) {
+            TypedValue.complexToDimensionPixelSize(value.data, metrics)
+        } else {
+            (fallbackDp * metrics.density).toInt()
+        }
+    }
+
+    private fun color(themed: Context, attr: Int): Int? =
+        themed.obtainStyledAttributes(intArrayOf(attr)).let { a ->
+            // recycle(), not use {}: TypedArray is AutoCloseable only from API 31.
+            try { if (a.hasValue(0)) a.getColor(0, 0) else null } finally { a.recycle() }
+        }
+
+    // ---------------------------------------------------------------- arguments (src/options.ts)
+
+    /** The rules the types cannot express, with src/options.ts's "<method>: …" messages. */
+    private fun invalid(reply: AkanNativeReply<*>, message: String) =
+        reply.reject(AkanNativeErrorCode.INVALID_ARGS, "${reply.call.method}: $message")
+
+    /** Title and message for the dialog, null when empty. Rejects (and returns null) when both are empty. */
+    private fun heading(title: String?, message: String, reply: AkanNativeReply<*>): Pair<String?, String?>? {
+        if (title.isNullOrEmpty() && message.isEmpty()) {
+            invalid(reply, "title or message must not be empty")
+            return null
+        }
+        return title?.ifEmpty { null } to message.ifEmpty { null }
+    }
+
+    /** "" means the default, not an invisible button (react-native/…/Alert/Alert.js:145-148). */
+    private fun label(text: String?, fallback: Int): String =
+        text?.ifEmpty { null } ?: context.activity.getString(fallback)
+
+    private fun sheetOptions(
+        raw: List<DialogActionSheetOption>,
+        reply: AkanNativeReply<*>,
+    ): List<Pair<String, DialogActionSheetOptionStyle>>? {
+        if (raw.isEmpty()) {
+            invalid(reply, "options must be a non-empty array")
+            return null
+        }
+        val options = raw.mapIndexed { i, option ->
+            if (option.title.isEmpty()) {
+                invalid(reply, "options[$i].title must be a non-empty string")
+                return null
+            }
+            option.title to (option.style ?: DialogActionSheetOptionStyle.DEFAULT)
+        }
+        // One cancel option, as UIAlertController allows one .cancel action.
+        if (options.count { it.second == DialogActionSheetOptionStyle.CANCEL } > 1) {
+            invalid(reply, "only one option may have the cancel style")
+            return null
+        }
+        return options
+    }
+}

package/vendor/@akanjs/native/plugins/dialog/ios/DialogPlugin.swift

@@ -0,0 +1,198 @@
+import UIKit
+
+/// alert / confirm / prompt / actionSheet with UIAlertController (docs/plugins.md §4.2).
+/// Argument rules are the ones of src/options.ts: the generated DialogPluginSpec (PL-10) decodes and
+/// type-checks the arguments, the rules beyond the types keep src/options.ts's messages.
+/// - Presented from the topmost view controller of the app's own window, so dark mode follows the
+///   app by itself. react-native copies the window's overrideUserInterfaceStyle only because it
+///   presents from a window of its own (react-native/…/RCTAlertController.mm:42-48).
+/// - Default button titles are UIKit's own localized "OK"/"Cancel"
+///   (react-native/…/RCTUtils.mm:1301-1305 RCTUIKitLocalizedString).
+/// - When nothing can present, the call answers as cancelled: a call that never answers hangs the
+///   page's await (the rule of AkanNativeViewController.presentPanel).
+/// - A dialog belongs to its call: when the page gives up on it (AbortSignal) or goes away (reload,
+///   navigation), it is dismissed, so no dialog of a gone page stays on screen and blocks the next.
+final class DialogPlugin: DialogPluginSpec {
+    static let id = "dialog"
+    private let context: AkanNativePluginContext
+
+    init(context: AkanNativePluginContext) {
+        self.context = context
+    }
+
+    // MARK: Methods
+
+    func alert(_ args: DialogAlertOptions, _ reply: AkanNativeReply<Void>) {
+        guard let text = Self.heading(args.title, args.message, reply) else { return }
+        let alert = UIAlertController(title: text.title, message: text.message, preferredStyle: .alert)
+        let ok = UIAlertAction(title: Self.label(args.buttonTitle, Self.uikit("OK")), style: .default) { _ in reply.resolve() }
+        alert.addAction(ok)
+        alert.preferredAction = ok
+        present(alert, for: reply.call) { reply.resolve() }
+    }
+
+    func confirm(_ args: DialogConfirmOptions, _ reply: AkanNativeReply<DialogConfirmResult>) {
+        guard let text = Self.heading(args.title, args.message, reply) else { return }
+        let alert = UIAlertController(title: text.title, message: text.message, preferredStyle: .alert)
+        // .cancel (Capacitor uses .default for both) puts Cancel where iOS users expect it and lets a
+        // hardware keyboard's Escape pick it; preferredAction makes OK the bold, Return-key button
+        // (react-native/…/RCTAlertManager.mm:152-156, 186-188).
+        alert.addAction(UIAlertAction(title: Self.label(args.cancelButtonTitle, Self.uikit("Cancel")), style: .cancel) { _ in
+            reply.resolve(DialogConfirmResult(value: false))
+        })
+        let ok = UIAlertAction(title: Self.label(args.okButtonTitle, Self.uikit("OK")), style: .default) { _ in
+            reply.resolve(DialogConfirmResult(value: true))
+        }
+        alert.addAction(ok)
+        alert.preferredAction = ok
+        present(alert, for: reply.call) { reply.resolve(DialogConfirmResult(value: false)) }
+    }
+
+    func prompt(_ args: DialogPromptOptions, _ reply: AkanNativeReply<DialogPromptResult>) {
+        guard let text = Self.heading(args.title, args.message, reply) else { return }
+        let placeholder = args.inputPlaceholder
+        let initial = args.inputText
+        let cancelled = DialogPromptResult(value: "", cancelled: true)
+        let alert = UIAlertController(title: text.title, message: text.message, preferredStyle: .alert)
+        alert.addTextField { field in
+            field.placeholder = placeholder
+            field.text = initial
+        }
+        alert.addAction(UIAlertAction(title: Self.label(args.cancelButtonTitle, Self.uikit("Cancel")), style: .cancel) { _ in
+            reply.resolve(cancelled)
+        })
+        // Not trimmed: Capacitor trims on Android only (capacitor-plugins/dialog/…/Dialog.java:143).
+        let ok = UIAlertAction(title: Self.label(args.okButtonTitle, Self.uikit("OK")), style: .default) { [weak alert] _ in
+            reply.resolve(DialogPromptResult(value: alert?.textFields?.first?.text ?? "", cancelled: false))
+        }
+        alert.addAction(ok)
+        alert.preferredAction = ok
+        present(alert, for: reply.call) { reply.resolve(cancelled) }
+    }
+
+    func actionSheet(_ args: DialogActionSheetOptions, _ reply: AkanNativeReply<DialogActionSheetResult>) {
+        guard let options = Self.sheetOptions(args.options, reply) else { return }
+        let sheet = UIAlertController(title: Self.nonEmpty(args.title), message: Self.nonEmpty(args.message), preferredStyle: .actionSheet)
+        let responder = SheetResponder(reply) // retained by the actions below
+        for (index, option) in options.enumerated() {
+            // iOS 26 does not show a .cancel action (verified in the iPad popover; iPhone per
+            // capacitor-plugins/action-sheet/README.md:121) and runs it on a tap outside instead,
+            // so choosing it counts as a dismissal.
+            sheet.addAction(UIAlertAction(title: option.title, style: option.style) { _ in
+                responder.answer(option.style == .cancel ? nil : index)
+            })
+        }
+        // iPad (and Mac): the sheet is a popover and UIKit throws without an anchor. Centered with no
+        // arrow like Capacitor's setCenteredPopover (capacitor/ios/Capacitor/Capacitor/CAPPlugin.m:149-155).
+        // Not on iPhone: since iOS 26 an anchor turns the sheet into a popover there too and leaves the
+        // page behind it interactive (react-native/…/RCTActionSheetManager.mm:64-74).
+        if UIDevice.current.userInterfaceIdiom != .phone, let popover = sheet.popoverPresentationController,
+            let anchor = context.webView ?? context.viewController?.view
+        {
+            popover.sourceView = anchor
+            popover.sourceRect = CGRect(x: anchor.bounds.midX, y: anchor.bounds.midY, width: 0, height: 0)
+            popover.permittedArrowDirections = []
+        }
+        present(sheet, for: reply.call, presented: {
+            // Without a cancel action a tap outside dismisses the sheet with no action at all; the
+            // delegate hears it. Only on action sheets: an alert-style controller's presentation
+            // controller must not get a delegate (capacitor-plugins/action-sheet/…/ActionSheetPlugin.swift:57-73).
+            sheet.presentationController?.delegate = responder
+        }, otherwise: { responder.answer(nil) })
+    }
+
+    // MARK: Presenting
+
+    /// AkanNativePresent: waits out a running transition; `otherwise` answers the call when nothing can
+    /// present. The controller goes away with its call (cancelled, or its page ended).
+    private func present(_ controller: UIViewController, for call: AkanNativeCall, presented: (@MainActor () -> Void)? = nil, otherwise: @escaping @MainActor () -> Void) {
+        call.onCancel { [weak controller] in
+            guard let controller, controller.presentingViewController != nil else { return }
+            controller.dismiss(animated: true)
+        }
+        context.present(controller, completion: presented, otherwise: otherwise)
+    }
+
+    // MARK: Arguments (src/options.ts)
+
+    /// The rules the types cannot express. The generated DialogPluginSpec has already checked the
+    /// types (PL-10); these keep src/options.ts's "<method>: …" messages.
+    private static func invalid<T>(_ reply: AkanNativeReply<T>, _ message: String) {
+        reply.reject(.invalidArgs, "\(reply.call.method): \(message)")
+    }
+
+    /// Title and message for the controller, nil when empty. Rejects when both are empty.
+    private static func heading<T>(_ title: String?, _ message: String, _ reply: AkanNativeReply<T>) -> (title: String?, message: String?)? {
+        let title = nonEmpty(title), message = nonEmpty(message)
+        if title == nil && message == nil {
+            invalid(reply, "title or message must not be empty")
+            return nil
+        }
+        return (title, message)
+    }
+
+    /// "" means the default, not an invisible button (react-native/…/Alert/Alert.js:145-148).
+    private static func label(_ text: String?, _ fallback: String) -> String {
+        nonEmpty(text) ?? fallback
+    }
+
+    private static func sheetOptions(_ raw: [DialogActionSheetOption], _ reply: AkanNativeReply<DialogActionSheetResult>) -> [(title: String, style: UIAlertAction.Style)]? {
+        guard !raw.isEmpty else {
+            invalid(reply, "options must be a non-empty array")
+            return nil
+        }
+        var options: [(title: String, style: UIAlertAction.Style)] = []
+        for (i, option) in raw.enumerated() {
+            guard !option.title.isEmpty else {
+                invalid(reply, "options[\(i)].title must be a non-empty string")
+                return nil
+            }
+            let style: UIAlertAction.Style =
+                switch option.style ?? .default {
+                case .default: .default
+                case .destructive: .destructive
+                case .cancel: .cancel
+                }
+            options.append((option.title, style))
+        }
+        // UIAlertController raises NSInternalInconsistencyException for a second .cancel action.
+        if options.count(where: { $0.style == .cancel }) > 1 {
+            invalid(reply, "only one option may have the cancel style")
+            return nil
+        }
+        return options
+    }
+
+    private static func nonEmpty(_ text: String?) -> String? {
+        text?.isEmpty == false ? text : nil
+    }
+
+    private static func uikit(_ key: String) -> String {
+        Bundle(for: UIApplication.self).localizedString(forKey: key, value: key, table: nil)
+    }
+
+    /// Answers an action sheet once: an option, the cancel option, or a dismissal without an action.
+    /// The sheet's actions retain it, so it lives exactly as long as the sheet (the presentation
+    /// controller's delegate is weak). If the sheet goes away unanswered, the call is released and
+    /// AkanNativeCall rejects it instead of leaving the page waiting.
+    private final class SheetResponder: NSObject, UIAdaptivePresentationControllerDelegate {
+        private let reply: AkanNativeReply<DialogActionSheetResult>
+
+        init(_ reply: AkanNativeReply<DialogActionSheetResult>) {
+            self.reply = reply
+        }
+
+        func answer(_ index: Int?) {
+            if let index {
+                reply.resolve(DialogActionSheetResult(index: Double(index), cancelled: false))
+            } else {
+                reply.resolve(DialogActionSheetResult(index: -1, cancelled: true))
+            }
+        }
+
+        func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {
+            answer(nil)
+        }
+    }
+}
+

package/vendor/@akanjs/native/plugins/dialog/native-plugin.json

@@ -0,0 +1,18 @@
+{
+  "id": "dialog",
+  "apiVersion": 1,
+  "methods": ["alert", "confirm", "prompt", "actionSheet"],
+  "events": [],
+  "codegen": true,
+  "web": "./src/web.ts",
+  "desktop": "./src/desktop.ts",
+  "ios": {
+    "sources": ["ios/*.swift"],
+    "class": "DialogPlugin",
+    "frameworks": ["UIKit"]
+  },
+  "android": {
+    "sources": ["android/*.kt"],
+    "class": "com.akanjs.plugins.dialog.DialogPlugin"
+  }
+}

package/vendor/@akanjs/native/plugins/dialog/src/desktop.ts

@@ -0,0 +1,80 @@
+
+
+import { type DesktopContext, defineDesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import type { ActionSheetResult, DialogApi } from "./index.ts";
+import { normalizeActionSheet, normalizeAlert, normalizeConfirm, normalizePrompt } from "./options.ts";
+
+interface Button {
+  title: string;
+  style?: "default" | "cancel" | "destructive";
+}
+
+interface Answer {
+  /** Index of the button that ended the sheet; -1 when none did. */
+  button: number;
+  text?: string;
+}
+
+/**
+ * Shows the alert under a tag of its own; when the call's signal fires (the page gave up on it, or
+ * the page is gone) the shell takes it off the screen (`alert.dismiss`).
+ */
+const show = async (
+  ctx: DesktopContext,
+  args: { title: string; message: string; buttons: Button[]; input?: { text: string; placeholder: string } },
+) => {
+  const tag = crypto.randomUUID();
+  const dismiss = () =>
+    void ctx
+      .shell("alert.dismiss", { tag })
+      .catch((error: unknown) => console.warn("[akan-native] dialog: alert.dismiss failed", error));
+  ctx.signal?.addEventListener("abort", dismiss, { once: true });
+  try {
+    return (await ctx.shell("alert.show", { ...args, tag })) as Answer;
+  } finally {
+    ctx.signal?.removeEventListener("abort", dismiss);
+  }
+};
+
+export default defineDesktopPlugin<DialogApi>({
+  id: "dialog",
+  methods: {
+    async alert(args, ctx) {
+      const a = normalizeAlert(args);
+      await show(ctx, { title: a.title, message: a.message, buttons: [{ title: a.buttonTitle }] });
+    },
+    async confirm(args, ctx) {
+      const c = normalizeConfirm(args);
+      const { button } = await show(ctx, {
+        title: c.title,
+        message: c.message,
+        buttons: [{ title: c.okButtonTitle }, { title: c.cancelButtonTitle, style: "cancel" }],
+      });
+      return { value: button === 0 };
+    },
+    async prompt(args, ctx) {
+      const p = normalizePrompt(args);
+      const { button, text } = await show(ctx, {
+        title: p.title,
+        message: p.message,
+        buttons: [{ title: p.okButtonTitle }, { title: p.cancelButtonTitle, style: "cancel" }],
+        input: { text: p.inputText, placeholder: p.inputPlaceholder },
+      });
+      return button === 0 ? { value: text ?? "", cancelled: false } : { value: "", cancelled: true };
+    },
+    async actionSheet(args, ctx): Promise<ActionSheetResult> {
+      const a = normalizeActionSheet(args);
+      const order = a.options
+        .map((_, i) => i)
+        .sort((x, y) => Number(a.options[x]!.style === "cancel") - Number(a.options[y]!.style === "cancel"));
+      const { button } = await show(ctx, {
+        title: a.title,
+        message: a.message,
+        buttons: order.map((i) => ({ title: a.options[i]!.title, style: a.options[i]!.style })),
+      });
+      const index = order[button];
+      if (index === undefined || a.options[index]!.style === "cancel") return { index: -1, cancelled: true };
+      return { index, cancelled: false };
+    },
+  },
+});

package/vendor/@akanjs/native/plugins/dialog/src/index.ts

@@ -0,0 +1,87 @@
+import { definePlugin } from "../../../packages/core/src/index.ts";
+import { web } from "./web.ts";
+
+export interface AlertOptions {
+  title?: string;
+  /** Required; may be "" when there is a title. */
+  message: string;
+  /** Default: "OK" (the OS's localized OK on iOS and Android). */
+  buttonTitle?: string;
+}
+
+export interface ConfirmOptions {
+  title?: string;
+  message: string;
+  okButtonTitle?: string;
+  cancelButtonTitle?: string;
+}
+
+export interface ConfirmResult {
+  /** true only for the OK button. */
+  value: boolean;
+}
+
+export interface PromptOptions extends ConfirmOptions {
+  inputPlaceholder?: string;
+  /** Text the field starts with. */
+  inputText?: string;
+}
+
+export interface PromptResult {
+  /** The text as typed (not trimmed). "" when cancelled. */
+  value: string;
+  cancelled: boolean;
+}
+
+export type ActionSheetOptionStyle = "default" | "destructive" | "cancel";
+
+export interface ActionSheetOption {
+  title: string;
+  /**
+   * "destructive" is shown in red. At most one option may be "cancel": it is shown apart
+   * (iOS hides it on iPhone and iPad and cancels on a tap outside instead) and choosing it
+   * answers `{ index: -1, cancelled: true }` like any other dismissal.
+   */
+  style?: ActionSheetOptionStyle;
+}
+
+export interface ActionSheetOptions {
+  title?: string;
+  message?: string;
+  /** At least one. */
+  options: ActionSheetOption[];
+}
+
+export interface ActionSheetResult {
+  /** Index into `options` of the chosen option, or -1 when cancelled. */
+  index: number;
+  cancelled: boolean;
+}
+
+export interface DialogApi {
+  alert(options: AlertOptions): Promise<void>;
+  confirm(options: ConfirmOptions): Promise<ConfirmResult>;
+  prompt(options: PromptOptions): Promise<PromptResult>;
+  actionSheet(options: ActionSheetOptions): Promise<ActionSheetResult>;
+}
+
+export const dialog = definePlugin<DialogApi>("dialog", {
+  methods: ["alert", "confirm", "prompt", "actionSheet"],
+  web,
+});
+
+export interface UseDialog extends DialogApi {
+  supported: boolean;
+}
+
+const methods: DialogApi = {
+  alert: dialog.alert,
+  confirm: dialog.confirm,
+  prompt: dialog.prompt,
+  actionSheet: dialog.actionSheet,
+};
+
+/** The dialog functions for components. They hold no state, so they are stable across renders. */
+export function useDialog(): UseDialog {
+  return { supported: dialog.isSupported("alert"), ...methods };
+}