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

package/vendor/@akanjs/native/native/desktop/src/dock.rs

@@ -0,0 +1,209 @@
+//! The app's Dock tile on macOS (dock plugin, plugins.md §5): badge label, progress bar and
+//! whether the app has a Dock icon at all. Everything goes through TAO's event loop target, as
+//! Tauri does (tauri/crates/tauri-runtime-wry/src/lib.rs:3527-3555, 3200-3204):
+//!   dock.getState                              → state
+//!   dock.setBadge {label: string|null}          → state   TAO set_badge_label (tao/src/platform_impl/macos/badge.rs:5-13)
+//!   dock.setProgress {progress: 0..1|null, state?: "normal"|"paused"|"error"} → state
+//!                                                         TAO set_progress_bar (tao/src/platform_impl/macos/progress_bar.rs:14-43)
+//!   dock.setVisible {visible: bool}             → state   TAO set_activation_policy_at_runtime (Regular | Accessory)
+//! state = {"visible","policy","badge","progress","progressState"}
+//!
+//! Know-how from the references:
+//! - TAO draws the progress bar itself: an NSProgressIndicator subclass on an NSImageView of the app
+//!   icon that becomes the tile's content view (progress_bar.rs:45-71). It takes whole percents
+//!   (0–100), draws "indeterminate" like "normal", paused in yellow and error in red
+//!   (progress_bar.rs:145-150). Hiding it keeps that image view, so the tile shows a snapshot of the
+//!   icon taken when the bar first appeared.
+//! - Dock visibility: TAO also has set_dock_visibility, which uses the Carbon TransformProcessType
+//!   and ignores a hide within 1 s of a show, because a fast hide/show left duplicate Dock icons
+//!   (tao/src/platform_impl/macos/dock.rs:42-58). akan-native uses NSApplication.setActivationPolicy (the
+//!   supported API that TAO's set_activation_policy_at_runtime calls), which applies at once and
+//!   reads back. An accessory app has no Dock icon, is not in Cmd+Tab and shows no menu bar; its
+//!   windows stay and key equivalents still work.
+//! - The activation policy is app-wide state that the page cannot see, so every op answers with
+//!   the whole state, and a reloaded page reads it back with getState.
+
+use std::cell::Cell;
+
+use objc2::MainThreadMarker;
+use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy};
+use tao::{
+  event_loop::EventLoopWindowTarget,
+  platform::macos::{ActivationPolicy, EventLoopWindowTargetExtMacOS},
+  window::{ProgressBarState, ProgressState},
+};
+
+use crate::json::{self, V};
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Kind {
+  Normal,
+  Paused,
+  Error,
+}
+
+impl Kind {
+  fn name(self) -> &'static str {
+    match self {
+      Kind::Normal => "normal",
+      Kind::Paused => "paused",
+      Kind::Error => "error",
+    }
+  }
+}
+
+/// A shown progress bar: the fraction the page asked for (0..1) and how it is drawn.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Progress {
+  pub value: f64,
+  pub kind: Kind,
+}
+
+thread_local! {
+  /// The bar last set (main thread). TAO's indicator has no getter.
+  static PROGRESS: Cell<Option<Progress>> = const { Cell::new(None) };
+}
+
+/// `dock.setProgress` arguments: `progress` 0..1 or null (hide), `state` normal | paused | error.
+pub fn parse_progress(cmd: &V) -> Result<Option<Progress>, String> {
+  let value = match cmd.get("progress") {
+    None | Some(V::Null) => return Ok(None),
+    Some(V::Num(n)) if (0.0..=1.0).contains(n) => *n,
+    Some(_) => return Err("progress must be a number from 0 to 1, or null".into()),
+  };
+  let bad_state = || Err("state must be one of normal, paused, error".to_string());
+  let kind = match cmd.get("state") {
+    None | Some(V::Null) => Kind::Normal,
+    Some(V::Str(s)) => match s.as_str() {
+      "normal" => Kind::Normal,
+      "paused" => Kind::Paused,
+      "error" => Kind::Error,
+      _ => return bad_state(),
+    },
+    Some(_) => return bad_state(),
+  };
+  Ok(Some(Progress { value, kind }))
+}
+
+/// TAO's progress takes whole percents.
+pub fn percent(value: f64) -> u64 {
+  (value * 100.0).round().clamp(0.0, 100.0) as u64
+}
+
+fn progress_bar(progress: Option<Progress>) -> ProgressBarState {
+  match progress {
+    None => ProgressBarState { state: Some(ProgressState::None), progress: None, desktop_filename: None },
+    Some(p) => ProgressBarState {
+      state: Some(match p.kind {
+        Kind::Normal => ProgressState::Normal,
+        Kind::Paused => ProgressState::Paused,
+        Kind::Error => ProgressState::Error,
+      }),
+      progress: Some(percent(p.value)),
+      desktop_filename: None,
+    },
+  }
+}
+
+/// `dock.setBadge`'s label: null or "" removes the badge.
+pub fn parse_label(cmd: &V) -> Result<Option<String>, String> {
+  match cmd.get("label") {
+    None | Some(V::Null) => Ok(None),
+    Some(V::Str(s)) if s.is_empty() => Ok(None),
+    Some(V::Str(s)) => Ok(Some(s.clone())),
+    Some(_) => Err("label must be a string or null".into()),
+  }
+}
+
+fn policy_name(policy: NSApplicationActivationPolicy) -> &'static str {
+  match policy {
+    NSApplicationActivationPolicy::Regular => "regular",
+    NSApplicationActivationPolicy::Accessory => "accessory",
+    _ => "prohibited", // `akan-native test` starts the app this way (lib.rs Config::activation)
+  }
+}
+
+pub fn state_json(badge: Option<&str>, policy: &str, progress: Option<Progress>) -> String {
+  let badge = badge.map_or_else(|| "null".into(), json::quote);
+  let (value, kind) = progress.map_or(("null".into(), "null".into()), |p| (format!("{}", p.value), format!(r#""{}""#, p.kind.name())));
+  format!(r#"{{"visible":{},"policy":"{policy}","badge":{badge},"progress":{value},"progressState":{kind}}}"#, policy == "regular")
+}
+
+fn state(mtm: MainThreadMarker) -> String {
+  let app = NSApplication::sharedApplication(mtm);
+  let badge = app.dockTile().badgeLabel().map(|b| b.to_string());
+  state_json(badge.as_deref(), policy_name(app.activationPolicy()), PROGRESS.with(Cell::get))
+}
+
+/// dock.* shell ops; None for other ops.
+pub fn shell_op<T>(op: &str, cmd: &V, target: &EventLoopWindowTarget<T>) -> Option<Result<String, String>> {
+  if !op.starts_with("dock.") {
+    return None;
+  }
+  Some(run(op, cmd, target))
+}
+
+fn run<T>(op: &str, cmd: &V, target: &EventLoopWindowTarget<T>) -> Result<String, String> {
+  let mtm = MainThreadMarker::new().ok_or("the Dock tile is changed on the main thread")?;
+  match op {
+    "dock.getState" => {}
+    "dock.setBadge" => target.set_badge_label(parse_label(cmd)?),
+    "dock.setProgress" => {
+      let progress = parse_progress(cmd)?;
+      target.set_progress_bar(progress_bar(progress));
+      PROGRESS.with(|p| p.set(progress));
+    }
+    "dock.setVisible" => {
+      let visible = cmd.get("visible").and_then(|v| v.as_bool()).ok_or("visible must be a boolean")?;
+      target.set_activation_policy_at_runtime(if visible { ActivationPolicy::Regular } else { ActivationPolicy::Accessory });
+    }
+    _ => return Err(format!("unknown op {op}")),
+  }
+  Ok(state(mtm))
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  fn cmd(s: &str) -> V {
+    json::parse(s).unwrap()
+  }
+
+  #[test]
+  fn progress_arguments() {
+    assert_eq!(parse_progress(&cmd(r#"{}"#)), Ok(None));
+    assert_eq!(parse_progress(&cmd(r#"{"progress":null}"#)), Ok(None));
+    assert_eq!(parse_progress(&cmd(r#"{"progress":0.25}"#)), Ok(Some(Progress { value: 0.25, kind: Kind::Normal })));
+    assert_eq!(parse_progress(&cmd(r#"{"progress":1,"state":"normal"}"#)), Ok(Some(Progress { value: 1.0, kind: Kind::Normal })));
+    assert_eq!(parse_progress(&cmd(r#"{"progress":0,"state":"paused"}"#)), Ok(Some(Progress { value: 0.0, kind: Kind::Paused })));
+    assert_eq!(parse_progress(&cmd(r#"{"progress":0.5,"state":"error"}"#)), Ok(Some(Progress { value: 0.5, kind: Kind::Error })));
+    for bad in [r#"{"progress":1.01}"#, r#"{"progress":-0.1}"#, r#"{"progress":"0.5"}"#, r#"{"progress":0.5,"state":"indeterminate"}"#, r#"{"progress":0.5,"state":1}"#] {
+      assert!(parse_progress(&cmd(bad)).is_err(), "{bad}");
+    }
+  }
+
+  #[test]
+  fn whole_percents() {
+    assert_eq!(percent(0.0), 0);
+    assert_eq!(percent(0.004), 0);
+    assert_eq!(percent(0.335), 34);
+    assert_eq!(percent(1.0), 100);
+  }
+
+  #[test]
+  fn labels() {
+    assert_eq!(parse_label(&cmd(r#"{"label":"3"}"#)), Ok(Some("3".into())));
+    assert_eq!(parse_label(&cmd(r#"{"label":""}"#)), Ok(None));
+    assert_eq!(parse_label(&cmd(r#"{"label":null}"#)), Ok(None));
+    assert!(parse_label(&cmd(r#"{"label":3}"#)).is_err());
+  }
+
+  #[test]
+  fn state_is_json() {
+    let s = state_json(Some("new \"1\""), "regular", Some(Progress { value: 0.5, kind: Kind::Paused }));
+    assert_eq!(s, r#"{"visible":true,"policy":"regular","badge":"new \"1\"","progress":0.5,"progressState":"paused"}"#);
+    assert!(json::parse(&s).is_ok());
+    assert_eq!(state_json(None, "prohibited", None), r#"{"visible":false,"policy":"prohibited","badge":null,"progress":null,"progressState":null}"#);
+  }
+}

package/vendor/@akanjs/native/native/desktop/src/hotkey.rs

@@ -0,0 +1,209 @@
+//! Global shortcuts on macOS (global-shortcut plugin, plugins.md §5) with Carbon's
+//! RegisterEventHotKey, declared here and linked from Carbon.framework (no crate).
+//!
+//! Why Carbon and not an NSEvent global monitor (electrobun nativeWrapper.mm:9171): a global
+//! monitor sees no events while the app itself is frontmost and needs the accessibility
+//! permission. RegisterEventHotKey fires in every case and needs no permission; global-hotkey
+//! (Tauri) and most macOS apps use it. Its handler runs on the main thread from the app's event
+//! loop (the application event target).
+//!
+//! Limits: key codes are ANSI-layout positions (accelerator.rs); RegisterEventHotKey only refuses
+//! a combination another process registered exclusively, so a system shortcut such as Cmd+Space
+//! may register and never fire.
+
+use std::{
+  ffi::c_void,
+  ptr,
+  sync::{
+    atomic::{AtomicU32, Ordering},
+    Mutex,
+  },
+};
+
+use crate::{accelerator, json, push_event};
+
+type OSStatus = i32;
+type EventTargetRef = *mut c_void;
+type EventHandlerRef = *mut c_void;
+type EventHotKeyRef = *mut c_void;
+type EventRef = *mut c_void;
+type EventHandlerCallRef = *mut c_void;
+type EventHandlerUPP = extern "C" fn(EventHandlerCallRef, EventRef, *mut c_void) -> OSStatus;
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct EventHotKeyID {
+  signature: u32,
+  id: u32,
+}
+
+#[repr(C)]
+struct EventTypeSpec {
+  event_class: u32,
+  event_kind: u32,
+}
+
+#[link(name = "Carbon", kind = "framework")]
+extern "C" {
+  fn GetApplicationEventTarget() -> EventTargetRef;
+  fn InstallEventHandler(
+    target: EventTargetRef,
+    handler: EventHandlerUPP,
+    num_types: usize,
+    list: *const EventTypeSpec,
+    user_data: *mut c_void,
+    out_ref: *mut EventHandlerRef,
+  ) -> OSStatus;
+  fn RegisterEventHotKey(code: u32, modifiers: u32, id: EventHotKeyID, target: EventTargetRef, options: u32, out_ref: *mut EventHotKeyRef) -> OSStatus;
+  fn UnregisterEventHotKey(hotkey: EventHotKeyRef) -> OSStatus;
+  fn GetEventParameter(
+    event: EventRef,
+    name: u32,
+    desired_type: u32,
+    actual_type: *mut u32,
+    buffer_size: usize,
+    actual_size: *mut usize,
+    data: *mut c_void,
+  ) -> OSStatus;
+}
+
+const fn four_cc(code: &[u8; 4]) -> u32 {
+  u32::from_be_bytes(*code)
+}
+
+const SIGNATURE: u32 = four_cc(b"akan");
+const K_EVENT_CLASS_KEYBOARD: u32 = four_cc(b"keyb");
+const K_EVENT_HOT_KEY_PRESSED: u32 = 5;
+const K_EVENT_PARAM_DIRECT_OBJECT: u32 = four_cc(b"----");
+const TYPE_EVENT_HOT_KEY_ID: u32 = four_cc(b"hkid");
+const EVENT_NOT_HANDLED: OSStatus = -9874;
+const EVENT_HOT_KEY_EXISTS: OSStatus = -9878;
+
+struct Entry {
+  /// Key code and Carbon modifiers: Cmd+K and CmdOrCtrl+K are the same shortcut on macOS.
+  combo: (u32, u32),
+  /// As the page wrote it; `pressed` reports this.
+  accelerator: String,
+  /// EventHotKeyRef (main thread only; stored as an address).
+  hotkey: usize,
+}
+
+static HOTKEYS: Mutex<Vec<(u32, Entry)>> = Mutex::new(Vec::new());
+static NEXT_ID: AtomicU32 = AtomicU32::new(1);
+static HANDLER: Mutex<bool> = Mutex::new(false);
+
+extern "C" fn on_hot_key(_call: EventHandlerCallRef, event: EventRef, _data: *mut c_void) -> OSStatus {
+  let mut id = EventHotKeyID { signature: 0, id: 0 };
+  let status = unsafe {
+    GetEventParameter(
+      event,
+      K_EVENT_PARAM_DIRECT_OBJECT,
+      TYPE_EVENT_HOT_KEY_ID,
+      ptr::null_mut(),
+      std::mem::size_of::<EventHotKeyID>(),
+      ptr::null_mut(),
+      &mut id as *mut EventHotKeyID as *mut c_void,
+    )
+  };
+  if status != 0 || id.signature != SIGNATURE {
+    return EVENT_NOT_HANDLED;
+  }
+  let hotkeys = HOTKEYS.lock().unwrap();
+  match hotkeys.iter().find(|(key, _)| *key == id.id) {
+    Some((_, entry)) => {
+      push_event(&format!(r#"{{"type":"hotkey","accelerator":{}}}"#, json::quote(&entry.accelerator)));
+      0
+    }
+    None => EVENT_NOT_HANDLED,
+  }
+}
+
+fn ensure_handler() -> Result<(), String> {
+  let mut installed = HANDLER.lock().unwrap();
+  if *installed {
+    return Ok(());
+  }
+  let spec = EventTypeSpec { event_class: K_EVENT_CLASS_KEYBOARD, event_kind: K_EVENT_HOT_KEY_PRESSED };
+  let mut handler: EventHandlerRef = ptr::null_mut();
+  let status = unsafe { InstallEventHandler(GetApplicationEventTarget(), on_hot_key, 1, &spec, ptr::null_mut(), &mut handler) };
+  if status != 0 {
+    return Err(format!("cannot install the hot key handler (OSStatus {status})"));
+  }
+  *installed = true;
+  Ok(())
+}
+
+/// Registers a shortcut. Registering one this app already has succeeds (a reloaded page
+/// registers again). Returns the canonical spelling.
+fn combo(text: &str) -> Result<(accelerator::Accelerator, (u32, u32)), String> {
+  let accel = accelerator::parse(text)?;
+  let code = accel.mac_key_code().ok_or_else(|| format!("{text} has no key code on macOS"))?;
+  let mods = accel.carbon_modifiers();
+  Ok((accel, (code, mods)))
+}
+
+pub fn register(text: &str) -> Result<String, String> {
+  let (accel, combo) = combo(text)?;
+  let canonical = accel.canonical();
+  if HOTKEYS.lock().unwrap().iter().any(|(_, e)| e.combo == combo) {
+    return Ok(canonical);
+  }
+  let (code, _) = combo;
+  ensure_handler()?;
+  let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
+  let mut hotkey: EventHotKeyRef = ptr::null_mut();
+  let status = unsafe {
+    RegisterEventHotKey(code, accel.carbon_modifiers(), EventHotKeyID { signature: SIGNATURE, id }, GetApplicationEventTarget(), 0, &mut hotkey)
+  };
+  match status {
+    0 => {}
+    EVENT_HOT_KEY_EXISTS => return Err(format!("{text} is already taken by another app")),
+    _ => return Err(format!("cannot register {text} (OSStatus {status})")),
+  }
+  HOTKEYS.lock().unwrap().push((id, Entry { combo, accelerator: text.to_string(), hotkey: hotkey as usize }));
+  Ok(canonical)
+}
+
+/// Returns whether the shortcut was registered.
+pub fn unregister(text: &str) -> Result<bool, String> {
+  let (_, combo) = combo(text)?;
+  let mut hotkeys = HOTKEYS.lock().unwrap();
+  let Some(index) = hotkeys.iter().position(|(_, e)| e.combo == combo) else { return Ok(false) };
+  let (_, entry) = hotkeys.remove(index);
+  unsafe { UnregisterEventHotKey(entry.hotkey as EventHotKeyRef) };
+  Ok(true)
+}
+
+pub fn unregister_all() {
+  for (_, entry) in HOTKEYS.lock().unwrap().drain(..) {
+    unsafe { UnregisterEventHotKey(entry.hotkey as EventHotKeyRef) };
+  }
+}
+
+pub fn is_registered(text: &str) -> Result<bool, String> {
+  let (_, combo) = combo(text)?;
+  Ok(HOTKEYS.lock().unwrap().iter().any(|(_, e)| e.combo == combo))
+}
+
+fn accelerator_arg(cmd: &json::V) -> Result<&str, String> {
+  cmd.get("accelerator").and_then(|v| v.as_str()).ok_or_else(|| "accelerator must be a string".to_string())
+}
+
+/// hotkey.* shell ops; None for other ops.
+pub fn shell_op(op: &str, cmd: &json::V) -> Option<Result<String, String>> {
+  let result = match op {
+    "hotkey.register" => accelerator_arg(cmd).and_then(register).map(|c| format!(r#"{{"accelerator":{}}}"#, json::quote(&c))),
+    "hotkey.unregister" => accelerator_arg(cmd).and_then(unregister).map(|removed| format!(r#"{{"removed":{removed}}}"#)),
+    "hotkey.unregisterAll" => {
+      unregister_all();
+      Ok("null".into())
+    }
+    "hotkey.isRegistered" => accelerator_arg(cmd).and_then(is_registered).map(|r| format!(r#"{{"registered":{r}}}"#)),
+    "hotkey.list" => {
+      let hotkeys = HOTKEYS.lock().unwrap();
+      Ok(format!("[{}]", hotkeys.iter().map(|(_, e)| json::quote(&e.accelerator)).collect::<Vec<_>>().join(",")))
+    }
+    _ => return None,
+  };
+  Some(result)
+}

package/vendor/@akanjs/native/native/desktop/src/js_panels.rs

@@ -0,0 +1,125 @@
+//! D7: JavaScript alert / confirm / prompt on macOS. WRY's WKUIDelegate (the objc class
+//! `WryWebViewUIDelegate`, wry/src/wkwebview/class/wry_web_view_ui_delegate.rs) has no JavaScript
+//! panel methods, so WebKit returned at once (confirm false, prompt null) without showing anything.
+//! The three methods are added to that class at runtime, like D4 adds applicationShouldTerminate:
+//! to TAO's delegate, and show NSAlert sheets on the page's window.
+//!
+//! As on iOS (native/ios AkanNativeViewController, S7): no page URL in the title, prompt keeps its
+//! default text, and a panel that cannot be shown completes at once: a completion handler that is
+//! never called hangs the page.
+
+use std::sync::{
+  atomic::{AtomicBool, Ordering},
+  Once,
+};
+
+use block2::{Block, RcBlock};
+use objc2::{
+  msg_send,
+  rc::Retained,
+  runtime::{AnyClass, AnyObject, Bool, Imp, Sel},
+  sel, MainThreadMarker,
+};
+use objc2_app_kit::{NSAlertFirstButtonReturn, NSModalResponse, NSWindow};
+use objc2_foundation::NSString;
+
+use crate::panels::{end_alert_later, make_alert, TestAnswers};
+
+static DEV: AtomicBool = AtomicBool::new(false);
+
+/// Adds the panel methods to the class of the webview's UI delegate (WRY's `WryWebViewUIDelegate`,
+/// registered by objc2 under a versioned module path) once, then sets the delegate again: WebKit
+/// reads which delegate methods exist when the delegate is set, so this webview would not see them.
+pub fn install(dev: bool, webview: &wry::WebView) {
+  use wry::WebViewExtMacOS;
+  let wk = webview.webview();
+  let delegate: *mut AnyObject = unsafe { msg_send![&*wk, UIDelegate] };
+  let Some(delegate_ref) = (unsafe { delegate.as_ref() }) else {
+    log!("the webview has no UI delegate: JavaScript alert/confirm/prompt stay silent");
+    return;
+  };
+  add_methods(dev, delegate_ref.class());
+  unsafe {
+    let _: () = msg_send![&*wk, setUIDelegate: delegate];
+  }
+}
+
+fn add_methods(dev: bool, class: &'static AnyClass) {
+  static ONCE: Once = Once::new();
+  ONCE.call_once(|| {
+    DEV.store(dev, Ordering::Relaxed);
+    let alert = alert_panel as extern "C-unwind" fn(&AnyObject, Sel, *mut AnyObject, *mut NSString, *mut AnyObject, *mut Block<dyn Fn()>);
+    let confirm = confirm_panel as extern "C-unwind" fn(&AnyObject, Sel, *mut AnyObject, *mut NSString, *mut AnyObject, *mut Block<dyn Fn(Bool)>);
+    let prompt = prompt_panel as extern "C-unwind" fn(&AnyObject, Sel, *mut AnyObject, *mut NSString, *mut NSString, *mut AnyObject, *mut Block<dyn Fn(*mut NSString)>);
+    // Safety: each signature matches its type encoding (void; self, _cmd, objects, a block).
+    unsafe {
+      add(class, sel!(webView:runJavaScriptAlertPanelWithMessage:initiatedByFrame:completionHandler:), std::mem::transmute::<_, Imp>(alert), c"v@:@@@@?");
+      add(class, sel!(webView:runJavaScriptConfirmPanelWithMessage:initiatedByFrame:completionHandler:), std::mem::transmute::<_, Imp>(confirm), c"v@:@@@@?");
+      add(class, sel!(webView:runJavaScriptTextInputPanelWithPrompt:defaultText:initiatedByFrame:completionHandler:), std::mem::transmute::<_, Imp>(prompt), c"v@:@@@@@?");
+    }
+  });
+}
+
+/// Never replaces a method the class (or a superclass) already has: a newer WRY may implement it.
+unsafe fn add(class: &AnyClass, sel: Sel, imp: Imp, types: &std::ffi::CStr) {
+  if class.instance_method(sel).is_some() {
+    log!("{} already implements {}; keeping it", class.name().to_string_lossy(), sel.name().to_string_lossy());
+    return;
+  }
+  objc2::ffi::class_addMethod(class as *const AnyClass as *mut AnyClass, sel, imp, types.as_ptr());
+}
+
+fn text(s: *mut NSString) -> String {
+  unsafe { s.as_ref() }.map(|s| s.to_string()).unwrap_or_default()
+}
+
+/// Shows the alert as a sheet on the webview's window and calls `done(button, text)` once.
+/// Without a visible window it answers `None` at once.
+fn show(webview: *mut AnyObject, message: &str, buttons: &[(&str, &str)], input: Option<&str>, done: impl Fn(Option<isize>, Option<String>) + 'static) {
+  let window: Option<Retained<NSWindow>> = unsafe { webview.as_ref() }.and_then(|w| unsafe { msg_send![w, window] });
+  let (Some(mtm), Some(window)) = (MainThreadMarker::new(), window) else { return done(None, None) };
+  if !window.isVisible() {
+    return done(None, None);
+  }
+  let buttons: Vec<(String, String)> = buttons.iter().map(|(t, s)| (t.to_string(), s.to_string())).collect();
+  let (alert, field) = make_alert(mtm, "", message, &buttons, input.map(|t| (t, "")));
+  let f = field.clone();
+  let handler = RcBlock::new(move |response: NSModalResponse| {
+    done(Some(response - NSAlertFirstButtonReturn), f.as_ref().map(|f| f.stringValue().to_string()));
+  });
+  alert.beginSheetModalForWindow_completionHandler(&window, Some(&handler));
+  if let Some(t) = TestAnswers::get(DEV.load(Ordering::Relaxed)) {
+    end_alert_later(t, &window, &alert, field);
+  }
+}
+
+extern "C-unwind" fn alert_panel(_this: &AnyObject, _cmd: Sel, webview: *mut AnyObject, message: *mut NSString, _frame: *mut AnyObject, handler: *mut Block<dyn Fn()>) {
+  let Some(handler) = (unsafe { RcBlock::copy(handler) }) else { return };
+  show(webview, &text(message), &[("OK", "default")], None, move |_, _| handler.call(()));
+}
+
+extern "C-unwind" fn confirm_panel(_this: &AnyObject, _cmd: Sel, webview: *mut AnyObject, message: *mut NSString, _frame: *mut AnyObject, handler: *mut Block<dyn Fn(Bool)>) {
+  let Some(handler) = (unsafe { RcBlock::copy(handler) }) else { return };
+  show(webview, &text(message), &[("OK", "default"), ("Cancel", "cancel")], None, move |button, _| handler.call((Bool::new(button == Some(0)),)));
+}
+
+extern "C-unwind" fn prompt_panel(
+  _this: &AnyObject,
+  _cmd: Sel,
+  webview: *mut AnyObject,
+  prompt: *mut NSString,
+  default_text: *mut NSString,
+  _frame: *mut AnyObject,
+  handler: *mut Block<dyn Fn(*mut NSString)>,
+) {
+  let Some(handler) = (unsafe { RcBlock::copy(handler) }) else { return };
+  let default_text = text(default_text);
+  show(webview, &text(prompt), &[("OK", "default"), ("Cancel", "cancel")], Some(&default_text), move |button, typed| {
+    if button == Some(0) {
+      let value = NSString::from_str(&typed.unwrap_or_default());
+      handler.call((Retained::as_ptr(&value) as *mut NSString,));
+    } else {
+      handler.call((std::ptr::null_mut(),));
+    }
+  });
+}