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

package/vendor/@akanjs/native/native/desktop/src/linux/appearance.rs

@@ -0,0 +1,177 @@
+//! Light and dark on Linux (appearance plugin; window.setTheme and window.getState's `theme` in
+//! lib.rs), app-wide as on macOS. WebKitGTK draws prefers-color-scheme dark when GTK's
+//! gtk-application-prefer-dark-theme is on, when gtk-theme-name ends in -dark, -Dark or :dark, or
+//! when $GTK_THEME ends in :dark, and follows changes of those settings live (WebKit's
+//! PageClientImpl::effectiveAppearanceIsDark, GTK 3 port). So the shell sets GTK's settings and
+//! reads the same rule back for `theme`:
+//! - "dark": prefer-dark on.
+//! - "light": prefer-dark off, and a dark theme name swapped for its light variant ("Yaru-dark" →
+//!   "Yaru"), which Ubuntu's dark style sets. $GTK_THEME cannot be overridden.
+//! - system (null): GTK's own settings (XSETTINGS, what the desktop set), plus prefer-dark while
+//!   the desktop portal's color-scheme is 1, "prefer dark" (org.freedesktop.portal.Settings,
+//!   namespace org.freedesktop.appearance): GNOME's and KDE's dark style, which GTK 3 itself
+//!   ignores and libadwaita follows.
+//! TAO reads the portal only with its dbus feature (the dbus crate, 5 s blocking calls:
+//! tao/src/platform_impl/linux/portal.rs), which the shell does not enable: then Window::theme() is
+//! always Light, and set_theme(None) switches prefer-dark off on a dark desktop
+//! (tao/src/platform_impl/linux/event_loop.rs:967-980). So lib.rs asks this module instead of TAO.
+//! The portal is read asynchronously (ReadOne, else the older Read, whose value is boxed twice) and
+//! watched through SettingChanged, so a missing or slow portal never holds up a window. When what
+//! WebKit draws changes (the portal, GTK's settings, set_theme), UserEvent::ThemeChanged repaints
+//! the windows and reports themeChanged, as TAO's ThemeChanged does on macOS and Windows.
+
+use std::cell::{Cell, RefCell};
+
+use gtk::{gio, glib, prelude::*};
+use tao::window::Theme;
+
+const PORTAL: &str = "org.freedesktop.portal.Desktop";
+const PORTAL_PATH: &str = "/org/freedesktop/portal/desktop";
+const SETTINGS: &str = "org.freedesktop.portal.Settings";
+const NAMESPACE: &str = "org.freedesktop.appearance";
+
+thread_local! {
+  static STARTED: Cell<bool> = const { Cell::new(false) };
+  /// set_theme's value: Some(true) dark, Some(false) light, None the system's.
+  static FORCED: Cell<Option<bool>> = const { Cell::new(None) };
+  /// The portal's color-scheme: 0 no preference, 1 prefer dark, 2 prefer light; None unknown.
+  static SCHEME: Cell<Option<u32>> = const { Cell::new(None) };
+  /// The theme name before "light" swapped it.
+  static SWAPPED: RefCell<Option<String>> = const { RefCell::new(None) };
+  /// What was last reported, so that only real changes repaint.
+  static LAST: Cell<Option<bool>> = const { Cell::new(None) };
+}
+
+fn dark_name(name: &str) -> bool {
+  name.ends_with("-dark") || name.ends_with("-Dark") || name.ends_with(":dark")
+}
+
+/// "Yaru-dark" → "Yaru".
+fn light_name(name: &str) -> &str {
+  name.strip_suffix("-dark").or_else(|| name.strip_suffix("-Dark")).unwrap_or(name)
+}
+
+/// WebKitGTK's rule (see above).
+fn draws_dark(settings: &gtk::Settings) -> bool {
+  settings.is_gtk_application_prefer_dark_theme()
+    || settings.gtk_theme_name().is_some_and(|n| dark_name(&n))
+    || std::env::var("GTK_THEME").is_ok_and(|t| t.ends_with(":dark"))
+}
+
+/// Whether windows draw dark now.
+pub fn is_dark() -> bool {
+  start();
+  gtk::Settings::default().is_some_and(|s| draws_dark(&s))
+}
+
+pub fn theme() -> Theme {
+  if is_dark() {
+    Theme::Dark
+  } else {
+    Theme::Light
+  }
+}
+
+/// Sets GTK's settings for the forced theme, or the system's.
+fn apply() {
+  let Some(settings) = gtk::Settings::default() else { return };
+  let want = FORCED.get().or_else(|| (SCHEME.get() == Some(1)).then_some(true));
+  if want != Some(false) && SWAPPED.take().is_some() {
+    settings.reset_property("gtk-theme-name"); // back to the desktop's (XSETTINGS) value
+  }
+  match want {
+    Some(true) => settings.set_gtk_application_prefer_dark_theme(true),
+    Some(false) => {
+      settings.set_gtk_application_prefer_dark_theme(false);
+      if let Some(name) = settings.gtk_theme_name().filter(|n| dark_name(n)) {
+        SWAPPED.with(|s| s.borrow_mut().get_or_insert_with(|| name.to_string()).clone());
+        settings.set_gtk_theme_name(Some(light_name(&name)));
+      }
+    }
+    None => settings.reset_property("gtk-application-prefer-dark-theme"),
+  }
+}
+
+/// Reports a change of what the windows draw.
+fn changed() {
+  let dark = gtk::Settings::default().is_some_and(|s| draws_dark(&s));
+  if LAST.replace(Some(dark)) != Some(dark) {
+    crate::send(crate::UserEvent::ThemeChanged);
+  }
+}
+
+pub fn set_theme(theme: Option<Theme>) {
+  start();
+  FORCED.set(theme.map(|t| t == Theme::Dark));
+  apply();
+  changed();
+}
+
+/// The portal's value: ReadOne answers (v), Read (v) holding another v.
+fn scheme_of(mut value: glib::Variant) -> Option<u32> {
+  while let Some(inner) = value.as_variant() {
+    value = inner;
+  }
+  value.get::<u32>()
+}
+
+fn portal_scheme(scheme: Option<u32>) {
+  if SCHEME.replace(scheme) != scheme {
+    apply();
+    changed();
+  }
+}
+
+fn read_portal(conn: &gio::DBusConnection, method: &'static str) {
+  let args = (NAMESPACE, "color-scheme").to_variant();
+  let retry = conn.clone();
+  conn.call(Some(PORTAL), PORTAL_PATH, SETTINGS, method, Some(&args), glib::VariantTy::new("(v)").ok(), gio::DBusCallFlags::NONE, 5000, gio::Cancellable::NONE, move |result| match result {
+    Ok(reply) => portal_scheme(scheme_of(reply.child_value(0))),
+    // Portals before version 2 have no ReadOne.
+    Err(e) if method == "ReadOne" && e.message().contains("UnknownMethod") => read_portal(&retry, "Read"),
+    Err(e) => log!("appearance: no color-scheme from the desktop portal: {e}"),
+  });
+}
+
+/// Once, on the main thread, after GTK started: watch GTK's settings and the portal.
+fn start() {
+  if STARTED.replace(true) {
+    return;
+  }
+  if let Some(settings) = gtk::Settings::default() {
+    LAST.set(Some(draws_dark(&settings)));
+    settings.connect_gtk_application_prefer_dark_theme_notify(|_| changed());
+    settings.connect_gtk_theme_name_notify(|_| changed());
+  }
+  let conn = match gio::bus_get_sync(gio::BusType::Session, gio::Cancellable::NONE) {
+    Ok(conn) => conn,
+    Err(e) => return log!("appearance: no session bus for the desktop portal: {e}"),
+  };
+  conn.signal_subscribe(Some(PORTAL), Some(SETTINGS), Some("SettingChanged"), Some(PORTAL_PATH), Some(NAMESPACE), gio::DBusSignalFlags::NONE, |_, _, _, _, _, params| {
+    // (namespace, key, value)
+    if params.n_children() == 3 && params.child_value(1).str() == Some("color-scheme") {
+      portal_scheme(scheme_of(params.child_value(2)));
+    }
+  });
+  read_portal(&conn, "ReadOne");
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn theme_names() {
+    assert!(dark_name("Adwaita-dark") && dark_name("Yaru-Dark") && dark_name("Adwaita:dark"));
+    assert!(!dark_name("Adwaita") && !dark_name("Darkly"));
+    assert_eq!(light_name("Yaru-dark"), "Yaru");
+    assert_eq!(light_name("Adwaita"), "Adwaita");
+  }
+
+  #[test]
+  fn portal_values() {
+    assert_eq!(scheme_of(1u32.to_variant()), Some(1));
+    assert_eq!(scheme_of(glib::Variant::from_variant(&glib::Variant::from_variant(&2u32.to_variant()))), Some(2));
+    assert_eq!(scheme_of("x".to_variant()), None);
+  }
+}

package/vendor/@akanjs/native/native/desktop/src/linux/camera.rs

@@ -0,0 +1,11 @@
+//! Camera permission for the camera plugin on Linux, answered like macOS's camera.rs with an
+//! AVAuthorizationStatus number:
+//!   camera.status, camera.request → {"status":3}   authorized
+//! An unsandboxed app has no camera permission of the system to ask for (Flatpak's
+//! org.freedesktop.portal.Camera is for sandboxed apps), and the shell allows WebKitGTK's camera
+//! requests itself (lib.rs permission handler); a missing camera is getUserMedia's NotFoundError.
+
+/// `camera.*` ops; None for other ops.
+pub fn shell_op(op: &str) -> Option<Result<String, String>> {
+  matches!(op, "camera.status" | "camera.request").then(|| Ok(r#"{"status":3}"#.to_string()))
+}

package/vendor/@akanjs/native/native/desktop/src/linux/clipboard.rs

@@ -0,0 +1,48 @@
+//! Plain text on the Linux clipboard (clipboard plugin): GTK's CLIPBOARD selection (Ctrl+C/V),
+//! not PRIMARY (the middle-click selection), on the main thread.
+//!   clipboard.writeText {text} → null
+//!   clipboard.readText         → {"text"}   "" when the clipboard holds no text
+//! readText asks the owner asynchronously (gtk_clipboard_request_text) and answers through
+//! crate::reply: gtk_clipboard_wait_for_text, which electrobun uses
+//! (electrobun/package/src/native/linux/nativeWrapper.cpp:10249-10275), spins a nested main loop
+//! that runs the other windows' sources meanwhile and blocks for as long as the owner takes.
+//! writeText also hands the text to the clipboard manager (gtk_clipboard_store, as electrobun
+//! does), so it survives the app: GTK does that by itself only at gtk_main's end, which TAO never
+//! runs. Without a manager (or on Wayland) that returns at once.
+
+use gtk::gdk;
+
+use crate::json;
+
+fn clipboard() -> gtk::Clipboard {
+  gtk::Clipboard::get(&gdk::SELECTION_CLIPBOARD)
+}
+
+/// `clipboard.writeText`; None for other ops.
+pub fn shell_op(op: &str, cmd: &json::V) -> Option<Result<String, String>> {
+  if op != "clipboard.writeText" {
+    return None;
+  }
+  Some(match cmd.get("text").and_then(|v| v.as_str()) {
+    Some(text) => {
+      let clipboard = clipboard();
+      clipboard.set_text(text);
+      clipboard.store();
+      Ok("null".into())
+    }
+    None => Err("text must be a string".into()),
+  })
+}
+
+/// `clipboard.readText`, answered from GTK's callback; false for other ops.
+pub fn async_op(id: u64, json_text: &str) -> bool {
+  if !json_text.contains("\"clipboard.readText\"") {
+    return false;
+  }
+  let Ok(cmd) = json::parse(json_text) else { return false };
+  if cmd.get("op").and_then(|v| v.as_str()) != Some("clipboard.readText") {
+    return false;
+  }
+  clipboard().request_text(move |_, text| crate::reply(id, Ok(format!(r#"{{"text":{}}}"#, json::quote(text.unwrap_or(""))))));
+  true
+}

package/vendor/@akanjs/native/native/desktop/src/linux/device.rs

@@ -0,0 +1,9 @@
+//! What the device plugin cannot read from files on Linux.
+//!   webview.version → {"version"}   the WebKitGTK version (wry::webview_version: webkit_get_*_version)
+
+use crate::json;
+
+/// `webview.version`; None for other ops.
+pub fn shell_op(op: &str) -> Option<Result<String, String>> {
+  (op == "webview.version").then(|| Ok(format!(r#"{{"version":{}}}"#, wry::webview_version().map_or("null".into(), |v| json::quote(&v)))))
+}

package/vendor/@akanjs/native/native/desktop/src/linux/dialogs.rs

@@ -0,0 +1,348 @@
+//! Native dialogs on Linux (GTK 3) for the dialog and file-picker plugins, with the ops and JSON of
+//! the macOS sheets (panels.rs, dialog_args.rs): `alert.show` → GtkMessageDialog, `panel.open` and
+//! `panel.save` → GtkFileChooserNative, `panel.mime` → GIO's shared-mime-info database. And D7
+//! (JavaScript alert/confirm/prompt) under tests.
+//!
+//! - No nested main loop (not gtk_dialog_run / gtk_native_dialog_run as in electrobun/package/src/
+//!   native/linux/nativeWrapper.cpp): a dialog is shown and answers from its response signal, so the
+//!   TAO loop, IPC responses and the other windows keep running meanwhile.
+//! - Modal to its window only, like a sheet: the window gets a window group of its own, which the
+//!   transient dialog joins, and GTK's modal grab covers one group. The window is shown first when it
+//!   is hidden.
+//! - GtkFileChooserNative goes through the XDG desktop portal where GTK does (Flatpak, Snap,
+//!   GTK_USE_PORTAL=1) and is GTK's own chooser otherwise (electrobun/package/src/native/linux/
+//!   native_file_dialog.h). GTK does not keep a native dialog alive: its response handler does.
+//! - Types: extensions become case-insensitive patterns, MIME types (also "image/*") GTK MIME filters.
+//!   A MIME type shared-mime-info does not know turns the filter off, so a file is never unpickable
+//!   (the macOS rule). One filter, no "All files" choice, as on macOS.
+
+use std::{
+  cell::{Cell, RefCell},
+  rc::Rc,
+  time::Duration,
+};
+
+use gtk::{gio, glib, prelude::*};
+use tao::platform::unix::WindowExtUnix;
+
+use crate::dialog_args::{alert_answer, mime_answer, open_answer, save_answer, strings, Alert, TestAnswers, CANCELLED};
+use crate::json::{self, V};
+
+/// Handles `panel.open`, `panel.save`, `panel.mime` and `alert.show`. false: another op (also
+/// `panel.types`, macOS UTIs, which lib.rs answers UNSUPPORTED).
+pub fn async_op(id: u64, json: &str, windows: &crate::Windows) -> bool {
+  if !json.contains("\"panel.") && !json.contains("\"alert.") {
+    return false;
+  }
+  let Ok(cmd) = json::parse(json) else { return false };
+  match cmd.get("op").and_then(|v| v.as_str()) {
+    Some("panel.mime") => crate::reply(id, Ok(mime_answer(&strings(cmd.get("exts")), mime_for_ext))),
+    // The call that showed it was cancelled or its page ended: the dialog goes, answering -1.
+    Some("alert.dismiss") => {
+      let tag = cmd.get("tag").and_then(|v| v.as_str()).unwrap_or("");
+      let end = OPEN_ALERTS.with(|m| m.borrow_mut().remove(tag));
+      let dismissed = end.is_some();
+      if let Some(end) = end {
+        end();
+      }
+      crate::reply(id, Ok(format!(r#"{{"dismissed":{dismissed}}}"#)));
+    }
+    Some(op @ ("panel.open" | "panel.save" | "alert.show")) => {
+      if let Err(e) = show(id, op, &cmd, windows) {
+        crate::reply(id, Err(e));
+      }
+    }
+    _ => return false,
+  }
+  true
+}
+
+fn show(id: u64, op: &str, cmd: &V, windows: &crate::Windows) -> Result<(), String> {
+  let wid = match crate::window_arg(cmd)? {
+    Some(w) => w,
+    None => windows.primary().ok_or("there is no window")?,
+  };
+  let win = windows.map.get(&wid).ok_or_else(|| format!("no window {wid}"))?;
+  if !win.window.is_visible() {
+    win.window.set_visible(true);
+  }
+  let parent = win.window.gtk_window();
+  if !parent.has_group() {
+    gtk::WindowGroup::new().add_window(parent);
+  }
+  let test = TestAnswers::get(windows.shell.devtools);
+  match op {
+    "alert.show" => alert(id, &Alert::parse(cmd), parent, test),
+    "panel.save" => chooser(id, Chooser::Save, cmd, parent, test),
+    _ if cmd.get("directory").and_then(|v| v.as_bool()).unwrap_or(false) => chooser(id, Chooser::Folder, cmd, parent, test),
+    _ => chooser(id, Chooser::Files, cmd, parent, test),
+  }
+  Ok(())
+}
+
+/// Tests: runs `f` on the main loop after the delay.
+fn later(t: &'static TestAnswers, f: impl FnOnce() + 'static) {
+  glib::timeout_add_local_once(Duration::from_millis(t.delay_ms().into()), f);
+}
+
+// ───────────────────────── alerts ─────────────────────────
+
+thread_local! {
+  /// Alerts on screen by tag (main thread): what ends one without an answer.
+  static OPEN_ALERTS: std::cell::RefCell<std::collections::HashMap<String, Box<dyn Fn()>>> = Default::default();
+}
+
+/// `alert.show` as a GtkMessageDialog: the title is the bold line, the message the text under it
+/// (NSAlert's messageText / informativeText). GNOME order: the default (first) button is the
+/// rightmost one, so the buttons are added last to first. Escape and the close button answer with
+/// the cancel button; without one the dialog has no close button and Escape does nothing.
+fn alert(id: u64, a: &Alert, parent: &gtk::ApplicationWindow, test: Option<&'static TestAnswers>) {
+  let (primary, secondary) = a.lines();
+  let dialog = gtk::MessageDialog::new(Some(parent), gtk::DialogFlags::MODAL | gtk::DialogFlags::DESTROY_WITH_PARENT, gtk::MessageType::Other, gtk::ButtonsType::None, primary);
+  if !secondary.is_empty() {
+    dialog.set_secondary_text(Some(secondary));
+  }
+  for (i, (label, style)) in a.buttons.iter().enumerate().rev() {
+    let button = dialog.add_button(label, gtk::ResponseType::Other(i as u16));
+    match style.as_str() {
+      "destructive" => button.style_context().add_class("destructive-action"),
+      "default" if i == 0 => button.style_context().add_class("suggested-action"),
+      _ => {}
+    }
+  }
+  dialog.set_default_response(gtk::ResponseType::Other(0));
+  let cancel = a.cancel();
+  dialog.set_deletable(cancel.is_some());
+  let entry = a.input.as_ref().map(|(text, placeholder)| {
+    let entry = gtk::Entry::new();
+    entry.set_text(text);
+    if !placeholder.is_empty() {
+      entry.set_placeholder_text(Some(placeholder));
+    }
+    entry.set_activates_default(true); // Return: the first button
+    if let Ok(area) = dialog.message_area().downcast::<gtk::Box>() {
+      area.pack_end(&entry, false, false, 0);
+    }
+    entry
+  });
+
+  let done = Cell::new(false);
+  let tag = a.tag.clone();
+  let finish = Rc::new({
+    let entry = entry.clone();
+    let tag = tag.clone();
+    move |dialog: &gtk::MessageDialog, button: isize| {
+      if done.replace(true) {
+        return;
+      }
+      if let Some(tag) = &tag {
+        OPEN_ALERTS.with(|m| m.borrow_mut().remove(tag));
+      }
+      let text = entry.as_ref().map(|e| e.text().to_string());
+      crate::reply(id, Ok(alert_answer(button, text.as_deref())));
+      // Safety: nothing uses the dialog after this; destroying it also drops this handler.
+      unsafe { dialog.destroy() };
+    }
+  });
+  dialog.connect_response({
+    let finish = finish.clone();
+    move |dialog, response| match response {
+      gtk::ResponseType::Other(i) => finish(dialog, i as isize),
+      gtk::ResponseType::DeleteEvent => {
+        if let Some(c) = cancel {
+          finish(dialog, c as isize);
+        }
+      }
+      _ => {}
+    }
+  });
+  if let Some(tag) = tag {
+    let (finish, dialog) = (finish.clone(), dialog.clone());
+    OPEN_ALERTS.with(|m| m.borrow_mut().insert(tag, Box::new(move || finish(&dialog, -1))));
+  }
+  // Not show_all: it would also show the dialog's hidden placeholder image ("image-missing").
+  dialog.show();
+  if let Some(entry) = &entry {
+    entry.show();
+    entry.grab_focus();
+  }
+  if let Some(t) = test {
+    let n = a.buttons.len() as isize;
+    later(t, move || {
+      if let (Some(entry), Some(text)) = (&entry, &t.text) {
+        entry.set_text(text);
+      }
+      // A click's path (the response signal); a button the dialog does not have is answered as is.
+      if (0..n).contains(&t.button) {
+        dialog.response(gtk::ResponseType::Other(t.button as u16));
+      } else {
+        finish(&dialog, t.button);
+      }
+    });
+  }
+}
+
+// ───────────────────────── file choosers ─────────────────────────
+
+#[derive(Clone, Copy, PartialEq)]
+enum Chooser {
+  Files,
+  Folder,
+  Save,
+}
+
+/// `panel.open` (files or a folder) and `panel.save` as a GtkFileChooserNative on the window.
+fn chooser(id: u64, kind: Chooser, cmd: &V, parent: &gtk::ApplicationWindow, test: Option<&'static TestAnswers>) {
+  let (action, title) = match kind {
+    Chooser::Files => (gtk::FileChooserAction::Open, "Open File"),
+    Chooser::Folder => (gtk::FileChooserAction::SelectFolder, "Select Folder"),
+    Chooser::Save => (gtk::FileChooserAction::Save, "Save File"),
+  };
+  // None: GTK's own (translated) Open / Save / Select and Cancel labels.
+  let native = gtk::FileChooserNative::new(Some(title), Some(parent), action, None, None);
+  native.set_modal(true);
+  match kind {
+    Chooser::Files => {
+      native.set_select_multiple(cmd.get("multiple").and_then(|v| v.as_bool()).unwrap_or(false));
+      if let Some(filter) = filter(&strings(cmd.get("types"))) {
+        native.add_filter(filter.clone());
+        native.set_filter(&filter);
+      }
+    }
+    Chooser::Save => {
+      // The plugin writes the file without asking again, as after NSSavePanel.
+      native.set_do_overwrite_confirmation(true);
+      native.set_create_folders(true);
+      if let Some(name) = cmd.get("name").and_then(|v| v.as_str()) {
+        native.set_current_name(name);
+      }
+    }
+    Chooser::Folder => {}
+  }
+  // Tests: the answer's folder and name, set before the chooser is shown (as on macOS).
+  if let Some(t) = test {
+    if let Some(dir) = &t.directory {
+      native.set_current_folder(dir);
+    }
+    if let (Some(name), Chooser::Save) = (&t.name, kind) {
+      native.set_current_name(name);
+    }
+  }
+
+  let keep = RefCell::new(Some(native.clone()));
+  let respond = Rc::new(move |native: &gtk::FileChooserNative, accepted: bool| {
+    let Some(_alive) = keep.borrow_mut().take() else { return }; // answered already
+    let answer = match (accepted, kind) {
+      (false, _) => CANCELLED.into(),
+      (true, Chooser::Save) => save_answer(native.filename().as_deref().and_then(|p| p.to_str())),
+      (true, _) => open_answer(&native.filenames().iter().filter_map(|p| p.to_str().map(str::to_string)).collect::<Vec<_>>()),
+    };
+    crate::reply(id, Ok(answer));
+  });
+  native.connect_response({
+    let respond = respond.clone();
+    move |native, response| respond(native, response == gtk::ResponseType::Accept)
+  });
+  native.show();
+  if let Some(t) = test {
+    // hide() ends the chooser without a response signal (GtkNativeDialog docs), so the answer goes
+    // to the same handler from here. A choice of files cannot be made this way: it is cancelled.
+    later(t, move || {
+      native.hide();
+      respond(&native, t.panel_ok && kind != Chooser::Files);
+    });
+  }
+}
+
+/// One filter for all of `types`, or None (every file) when one is "*/*" or unknown.
+fn filter(types: &[String]) -> Option<gtk::FileFilter> {
+  if types.is_empty() {
+    return None;
+  }
+  let mut registered: Option<Vec<glib::GString>> = None;
+  let mut known = |mime: &str| {
+    let list = registered.get_or_insert_with(gio::content_types_get_registered);
+    match mime.strip_suffix('*') {
+      Some(prefix) => list.iter().any(|t| t.starts_with(prefix)),
+      None => list.iter().any(|t| t == mime),
+    }
+  };
+  let filter = gtk::FileFilter::new();
+  for ty in types {
+    if ty == "*/*" {
+      return None;
+    }
+    if ty.contains('/') {
+      if !known(ty) {
+        return None;
+      }
+      filter.add_mime_type(ty);
+    } else {
+      filter.add_pattern(&pattern(ty));
+    }
+  }
+  filter.set_name(Some(&types.join(", ")));
+  Some(filter)
+}
+
+/// "pdf" or ".pdf" → "*.[pP][dD][fF]": GTK 3 patterns are case-sensitive (GTK 4 has add_suffix).
+fn pattern(ext: &str) -> String {
+  let mut p = String::from("*.");
+  for c in ext.trim_start_matches('.').chars() {
+    match c {
+      c if c.is_alphabetic() => p.extend(['[', c.to_ascii_lowercase(), c.to_ascii_uppercase(), ']']),
+      '*' | '?' | '[' | ']' | '\\' => p.extend(['[', c, ']']),
+      c => p.push(c),
+    }
+  }
+  p
+}
+
+/// The MIME type of a file extension from shared-mime-info (GIO's content types are MIME types here).
+fn mime_for_ext(ext: &str) -> Option<String> {
+  let (ty, uncertain) = gio::content_type_guess(Some(format!("file.{ext}")), &[]);
+  if uncertain || gio::content_type_is_unknown(&ty) {
+    return None;
+  }
+  gio::content_type_get_mime_type(&ty).map(|m| m.to_string())
+}
+
+// ───────────────────────── D7 ─────────────────────────
+
+/// D7 under tests: WebKitGTK shows its own JavaScript alert/confirm/prompt dialogs, which wait for a
+/// click. With AKAN_NATIVE_TEST_PANELS (dev builds) the WebKitWebView's script-dialog signal answers them
+/// instead: the handler keeps the dialog (webkit_script_dialog_ref, the asynchronous form), sets the
+/// answer and closes it after the delay; the page's script waits meanwhile, as behind a real dialog.
+/// Without the variable WebKit's own dialogs stay.
+pub fn install_js_dialogs(dev: bool, webview: &wry::WebView) {
+  use webkit2gtk::{ScriptDialogType, WebViewExt};
+  use wry::WebViewExtUnix;
+  let Some(t) = TestAnswers::get(dev) else { return };
+  webview.webview().connect_script_dialog(move |_, dialog| {
+    let accept = t.button == 0;
+    match dialog.dialog_type() {
+      ScriptDialogType::Confirm | ScriptDialogType::BeforeUnloadConfirm => dialog.confirm_set_confirmed(accept),
+      // As on macOS, a prompt keeps its default text.
+      ScriptDialogType::Prompt if accept => {
+        let text = t.text.clone().or_else(|| dialog.prompt_get_default_text().map(|s| s.to_string())).unwrap_or_default();
+        dialog.prompt_set_text(&text);
+      }
+      _ => {}
+    }
+    let dialog = dialog.clone();
+    later(t, move || dialog.close());
+    true
+  });
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn patterns_ignore_case() {
+    assert_eq!(pattern("pdf"), "*.[pP][dD][fF]");
+    assert_eq!(pattern(".tar.gz"), "*.[tT][aA][rR].[gG][zZ]");
+    assert_eq!(pattern("mp3"), "*.[mM][pP]3");
+  }
+}