janela 0.17.1 → 0.18.0

package/bin/lib.mjs

@@ -231,11 +231,20 @@ export function ffiManifest(shimLib, { platform = process.platform, macSdkPath =
       name: "wvOnMenu", symbol: "wv_on_menu",
       params: [
         "i32",
-        { callback: { id: "menu", params: ["string", { context: "menu" }], returns: "i32", lifetime: "retained" } },
+        // The tag is the host's own registry index, so the click comes back as
+        // a number and TypeScript looks up the item's handler. Nothing is
+        // matched by string.
+        { callback: { id: "menu", params: ["i32", { context: "menu" }], returns: "i32", lifetime: "retained" } },
         { context: "menu" },
       ],
       returns: "i32",
     },
+    { name: "wvMenuSetEnabled", symbol: "wv_menu_set_enabled", params: ["i32", "i32", "i32"], returns: "i32" },
+    { name: "wvMenuSetChecked", symbol: "wv_menu_set_checked", params: ["i32", "i32", "i32"], returns: "i32" },
+    {
+      name: "wvMenuSetLabel", symbol: "wv_menu_set_label",
+      params: ["i32", "i32", "string"], returns: "i32",
+    },
   ];
 
   if (platform === "win32") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "janela",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "description": "Desktop, iOS and Android apps in pure TypeScript, compiled to native. No Rust, no Node, no Electron.",
   "type": "module",
   "bin": {

package/runtime/janela.ts

@@ -43,7 +43,10 @@ declare function wvDialog(
 ): number;
 declare function wvSetFullscreen(h: number, on: number): number;
 declare function wvSetMenu(h: number, spec: string): number;
-declare function wvOnMenu(h: number, cb: (id: string) => number): number;
+declare function wvOnMenu(h: number, cb: (tag: number) => number): number;
+declare function wvMenuSetEnabled(h: number, tag: number, on: number): number;
+declare function wvMenuSetChecked(h: number, tag: number, on: number): number;
+declare function wvMenuSetLabel(h: number, tag: number, label: string): number;
 
 const JOB_PENDING = 0;
 const JOB_OK = 1;
@@ -92,7 +95,6 @@ export type {
   DialogFilter,
   Events,
   FsCallback,
-  MenuEntry,
   OpenDialogOptions,
   SaveDialogOptions,
   WindowConfig,
@@ -102,7 +104,6 @@ export type {
 // A project's `import { defineCommands } from "janela/host"` is rewritten to
 // this module by the CLI before scriptc sees it.
 export { defineCommands, defineEvents } from "./types";
-export { menuItem, menuSeparator, submenu } from "./types";
 
 import type {
   AsyncCommandHandler,
@@ -114,7 +115,6 @@ import type {
   DialogFilter,
   Events,
   FsCallback,
-  MenuEntry,
   OpenDialogOptions,
   SaveDialogOptions,
   WindowConfig,
@@ -161,12 +161,18 @@ const TIMER_JOBS = -1;
  * interface (being signature-only) never is. A class receiver works even as a
  * plain function parameter, which is what `setup(app)` is.
  */
-// ---- menu flattening ---------------------------------------------------
+// ---- menus -------------------------------------------------------------
 //
-// The shim renders menus but parses nothing structural: the tree is flattened
-// here into one row per line with 0x1f between fields, which needs only a
-// split on the native side. Keeping the parsing in TypeScript is the whole
-// point — the native side stays a renderer.
+// A menu item is an OBJECT that carries its own click handler, not a row with
+// an id that something matches on later. muda — Tauri's menu crate — uses ids
+// because Rust cannot attach a closure to an item across its global event
+// channel, so it hands you `MenuId(String)` and you match on it; a typo there
+// is silent. TypeScript has no such problem: the handler lives on the item, so
+// there is no name to declare, to keep in sync, or to get wrong.
+//
+// The tag is an implementation detail the caller never sees: it indexes the
+// handler registry here, is written into the wire format, comes back on a
+// click, and is what setEnabled/setChecked/setLabel address.
 
 // NSEventModifierFlags.
 const MENU_SHIFT = 131072;
@@ -205,24 +211,116 @@ function menuSafe(v: string): string {
   return v.split("\x1f").join(" ").split("\n").join(" ");
 }
 
-function flattenMenu(entries: MenuEntry[], rows: string[]): void {
-  for (let i = 0; i < entries.length; i++) {
-    const e = entries[i];
-    if (e.separator) {
-      rows.push("-");
-      continue;
+/** Submenus and separators have nothing to run. */
+function noop(): void {}
+
+/**
+ * An entry in the application menu.
+ *
+ * Build one with `menuItem`, `menuSeparator` or `submenu` and keep the
+ * reference if you want to change it later — there is no lookup by name,
+ * because there are no names.
+ */
+export class MenuItem {
+  label: string;
+  accel: string;
+  separator: boolean;
+  items: MenuItem[];
+  onClick: () => void;
+  enabled = true;
+  // Data on the base so the flattener can read it without a type test; only
+  // CheckMenuItem exposes a way to change it.
+  checkable = false;
+  checked = false;
+
+  // Assigned when the item is mounted by setMenu; -1 while detached. The
+  // window handle is enough to reach the FFI — holding the app itself would
+  // drag its two type parameters in here for no benefit.
+  tag = -1;
+  ownerHandle = -1;
+
+  constructor(
+    label: string,
+    accel: string,
+    separator: boolean,
+    items: MenuItem[],
+    onClick: () => void,
+  ) {
+    this.label = label;
+    this.accel = accel;
+    this.separator = separator;
+    this.items = items;
+    this.onClick = onClick;
+  }
+
+  /**
+   * Grey the item out, or bring it back.
+   *
+   * Applied immediately when the item is already in a menu, and remembered
+   * for the next `setMenu` when it is not — so state set before mounting is
+   * not lost.
+   */
+  setEnabled(on: boolean): void {
+    this.enabled = on;
+    if (this.ownerHandle >= 0 && this.tag >= 0) {
+      wvMenuSetEnabled(this.ownerHandle, this.tag, on ? 1 : 0);
+    }
+  }
+
+  /** Change the text without rebuilding the menu. */
+  setLabel(label: string): void {
+    this.label = label;
+    if (this.ownerHandle >= 0 && this.tag >= 0) {
+      wvMenuSetLabel(this.ownerHandle, this.tag, label);
     }
-    const label = menuSafe(e.label);
-    if (e.items.length > 0) {
-      rows.push("S\x1f" + label);
-      flattenMenu(e.items, rows);
-      rows.push("E");
-      continue;
+  }
+}
+
+/**
+ * An item that can carry a tick.
+ *
+ * Separate from `MenuItem` because GTK decides this at construction: a tick
+ * needs `GtkCheckMenuItem`, a different widget, and an item cannot become one
+ * later. macOS and Windows would let any item show a check, but a method that
+ * works on two platforms and silently does nothing on the third is worse than
+ * one that is simply absent — so `setChecked` lives here, and calling it on a
+ * plain item is a compile error rather than a surprise on Linux.
+ */
+export class CheckMenuItem extends MenuItem {
+  constructor(label: string, accel: string, onClick: () => void) {
+    super(label, accel, false, [], onClick);
+    this.checkable = true;
+  }
+
+  /** Tick or untick the item. */
+  setChecked(on: boolean): void {
+    this.checked = on;
+    if (this.ownerHandle >= 0 && this.tag >= 0) {
+      wvMenuSetChecked(this.ownerHandle, this.tag, on ? 1 : 0);
     }
-    rows.push("I\x1f" + menuSafe(e.id) + "\x1f" + label + "\x1f" + parseAccel(e.accel));
   }
 }
 
+/** A clickable entry. `accel` is "" for no shortcut. */
+export function menuItem(label: string, accel: string, onClick: () => void): MenuItem {
+  return new MenuItem(label, accel, false, [], onClick);
+}
+
+/** A clickable entry that carries a tick. `accel` is "" for no shortcut. */
+export function menuCheckItem(label: string, accel: string, onClick: () => void): CheckMenuItem {
+  return new CheckMenuItem(label, accel, onClick);
+}
+
+/** A divider. */
+export function menuSeparator(): MenuItem {
+  return new MenuItem("", "", true, [], noop);
+}
+
+/** A submenu holding other entries. Nestable. */
+export function submenu(label: string, items: MenuItem[]): MenuItem {
+  return new MenuItem(label, "", false, items, noop);
+}
+
 export class JanelaAppImpl<
   C extends CommandShapes = CommandShapes,
   E = Record<string, unknown>,
@@ -231,6 +329,14 @@ export class JanelaAppImpl<
   names: string[] = [];
   handlers: CommandHandler[] = [];
 
+  // Menu items in tag order; the tag IS the index. Rebuilt by setMenu.
+  menuItems: MenuItem[] = [];
+  // The handlers, separately: scriptc does not support calling a closure held
+  // on an object property (SC1090), only one reached through an array — the
+  // same reason command handlers live in `handlers`.
+  menuHandlers: (() => void)[] = [];
+  menuBound = false;
+
   // ---- scheduling ----------------------------------------------------------
   // scriptc's event loop is parked for as long as the program sits inside the
   // wvRun() FFI call, so setTimeout/await never fire while the window is open.
@@ -584,34 +690,75 @@ export class JanelaAppImpl<
    * wholesale is what would. Calling it again replaces only what a previous
    * call added, so the menu can shrink as well as grow.
    *
-   * Clicks arrive on `onMenu` with the entry's `id`.
+   * Each item carries its own handler; there are no ids to declare or match.
+   * Keep a reference to change an item later.
    *
    * ```ts
-   * app.setMenu([
-   *   { label: "File", items: [
-   *     { label: "Open…", id: "open", accel: "CmdOrCtrl+O" },
-   *     { separator: true },
-   *     { label: "Close", id: "close" },
-   *   ]},
-   * ]);
-   * app.onMenu((id) => { if (id === "open") … });
+   * const save = menuItem("Save", "CmdOrCtrl+S", () => write());
+   * app.setMenu([submenu("File", [
+   *   menuItem("Open…", "CmdOrCtrl+O", () => open()),
+   *   menuSeparator(),
+   *   save,
+   * ])]);
+   *
+   * save.setEnabled(false);   // later, without rebuilding
    * ```
    *
    * Returns false where custom menus are not supported yet — everything but
    * macOS. The standard menu is unaffected either way.
    */
-  setMenu(entries: MenuEntry[]): boolean {
+  setMenu(entries: MenuItem[]): boolean {
+    // A rebuild invalidates every tag from the previous call, so the registry
+    // is rebuilt with it. Items carried over keep working because they are
+    // re-tagged here; items dropped from the tree go inert, which is what
+    // "removed from the menu" should mean.
+    for (let i = 0; i < this.menuItems.length; i++) {
+      this.menuItems[i].tag = -1;
+      this.menuItems[i].ownerHandle = -1;
+    }
+    this.menuItems = [];
+    this.menuHandlers = [];
+
     const rows: string[] = [];
-    flattenMenu(entries, rows);
+    this.flattenMenu(entries, rows);
+
+    if (!this.menuBound) {
+      // Registered once: the tag comes back and the item's own closure runs.
+      wvOnMenu(this.handle, (tag) => {
+        if (tag >= 0 && tag < this.menuHandlers.length) this.menuHandlers[tag]();
+        return 0;
+      });
+      this.menuBound = true;
+    }
     return wvSetMenu(this.handle, rows.join("\n")) === 0;
   }
 
-  /** Called with the `id` of the clicked menu entry. */
-  onMenu(cb: (id: string) => void): void {
-    wvOnMenu(this.handle, (id) => {
-      cb(id);
-      return 0;
-    });
+  /** Walks the tree, assigns each clickable item its registry tag. */
+  flattenMenu(entries: MenuItem[], rows: string[]): void {
+    for (let i = 0; i < entries.length; i++) {
+      const e = entries[i];
+      if (e.separator) {
+        rows.push("-");
+        continue;
+      }
+      const label = menuSafe(e.label);
+      if (e.items.length > 0) {
+        rows.push("S\x1f" + label);
+        this.flattenMenu(e.items, rows);
+        rows.push("E");
+        continue;
+      }
+      const tag = this.menuItems.length;
+      this.menuItems.push(e);
+      this.menuHandlers.push(e.onClick);
+      e.tag = tag;
+      e.ownerHandle = this.handle;
+      rows.push(
+        "I\x1f" + tag + "\x1f" + label + "\x1f" + parseAccel(e.accel) +
+          "\x1f" + (e.enabled ? "1" : "0") + "\x1f" + (e.checked ? "1" : "0") +
+          "\x1f" + (e.checkable ? "1" : "0"),
+      );
+    }
   }
 
   /**

package/runtime/types.ts

@@ -41,56 +41,6 @@ export type AsyncCommandHandler = (
  */
 export type FsCallback = (err: string | null, text: string) => void;
 
-/**
- * One entry in the application menu.
- *
- * Every field is required rather than optional, and the entries are built with
- * `submenu`, `menuItem` and `menuSeparator` rather than written as literals.
- * That is a scriptc constraint made into a nicer API: a record whose fields are
- * all optional infers as `{ label: string | undefined, … }`, and an array
- * mixing a submenu, an item and a separator is a union that will not re-tag
- * into it ("union types must match exactly", SC2003). The helpers each return
- * the same total shape, so the array is homogeneous and the call site reads as
- * a tree.
- *
- * ```ts
- * app.setMenu([
- *   submenu("File", [
- *     menuItem("Open…", "open", "CmdOrCtrl+O"),
- *     menuSeparator(),
- *   ]),
- * ]);
- * ```
- */
-export type MenuEntry = {
-  label: string;
-  /** Sent to `onMenu` when clicked. Empty for submenus and separators. */
-  id: string;
-  /**
-   * A shortcut like "CmdOrCtrl+O" or "CmdOrCtrl+Shift+S". Modifiers: Cmd,
-   * Ctrl, CmdOrCtrl, Alt/Option, Shift. Empty for none.
-   */
-  accel: string;
-  separator: boolean;
-  /** Children. Empty for a leaf. */
-  items: MenuEntry[];
-};
-
-/** A clickable entry. `accel` is "" for no shortcut. */
-export function menuItem(label: string, id: string, accel: string): MenuEntry {
-  return { label: label, id: id, accel: accel, separator: false, items: [] };
-}
-
-/** A divider. */
-export function menuSeparator(): MenuEntry {
-  return { label: "", id: "", accel: "", separator: true, items: [] };
-}
-
-/** A submenu holding other entries. Nestable. */
-export function submenu(label: string, items: MenuEntry[]): MenuEntry {
-  return { label: label, id: "", accel: "", separator: false, items: items };
-}
-/** A named group of extensions offered in a dialog's file-type popup. */
 export interface DialogFilter {
   name: string;
   /** Bare extensions, no dot and no glob: ["png", "jpg"]. */

package/shim/wvshim.cc

@@ -75,12 +75,20 @@ struct App {
   void *on_invoke_ctx = nullptr;
   void (*on_timer)(int32_t, void *) = nullptr;
   void *on_timer_ctx = nullptr;
-  int32_t (*on_menu)(const uint8_t *, size_t, void *) = nullptr;
+  // The tag identifies the item; the host owns the numbering and hands it
+  // down, because the click handler lives in TypeScript now.
+  int32_t (*on_menu)(int32_t, void *) = nullptr;
   void *on_menu_ctx = nullptr;
 
-  // Custom menu item ids, indexed by the NSMenuItem's tag. The menu bar is
-  // process-global on macOS, so only one app can own it — see g_menu_owner.
-  std::vector<std::string> menu_ids;
+  // Live NSMenuItems, indexed by tag, so setEnabled/setChecked/setLabel can
+  // reach one without rebuilding the bar. Retained; released on the next
+  // setMenu. The menu bar is process-global on macOS, so only one app can own
+  // it — see g_menu_owner.
+  //
+  // `void *` rather than `id`: this struct is compiled on every platform and
+  // `id` is Objective-C, so naming it here breaks the Linux and Windows
+  // builds. The Apple code casts on the way in and out.
+  std::vector<void *> menu_items;
   // How many submenus the standard bar installed, so setMenu appends after
   // them and can remove only its own on a later call.
   size_t std_menu_count = 0;
@@ -531,10 +539,7 @@ static int32_t g_menu_owner = -1;
 static void menu_clicked(long tag) {
   App *a = g_menu_owner >= 0 ? app_at(g_menu_owner) : nullptr;
   if (!a || !a->on_menu) return;
-  if (tag < 0 || static_cast<size_t>(tag) >= a->menu_ids.size()) return;
-  const std::string &id = a->menu_ids[static_cast<size_t>(tag)];
-  a->on_menu(reinterpret_cast<const uint8_t *>(id.data()), id.size(),
-             a->on_menu_ctx);
+  a->on_menu(static_cast<int32_t>(tag), a->on_menu_ctx);
 }
 
 // One shared target for every custom item; the tag says which one fired.
@@ -563,6 +568,21 @@ static id menu_target() {
   return instance;
 }
 
+// Retains the item under its tag so a later setEnabled/setChecked/setLabel can
+// find it. The vector is sized to fit rather than pushed, because the host's
+// tags are registry indices and need not arrive in order.
+static void remember_item(App *a, long tag, id item) {
+  if (tag < 0) return;
+  size_t at = static_cast<size_t>(tag);
+  if (a->menu_items.size() <= at) a->menu_items.resize(at + 1, nullptr);
+  a->menu_items[at] = webview::detail::objc::retain(item);
+}
+
+static id item_at(App *a, int32_t tag) {
+  if (tag < 0 || static_cast<size_t>(tag) >= a->menu_items.size()) return nullptr;
+  return static_cast<id>(a->menu_items[static_cast<size_t>(tag)]);
+}
+
 // Appends the host's submenus to the standard menu bar rather than replacing
 // it: a custom menu must not be able to cost the app Cmd+Q and Cmd+V, which is
 // what replacing the bar wholesale would do.
@@ -583,7 +603,10 @@ static int32_t apply_custom_menu(App *a, const std::string &spec) {
     objc::msg_send<void>(menubar, objc::selector("removeItemAtIndex:"),
                          static_cast<NSInteger>(n - 1));
   }
-  a->menu_ids.clear();
+  for (void *old_item : a->menu_items) {
+    if (old_item) objc::release(static_cast<id>(old_item));
+  }
+  a->menu_items.clear();
 
   std::vector<id> stack;
   stack.push_back(menubar);
@@ -605,6 +628,10 @@ static int32_t apply_custom_menu(App *a, const std::string &spec) {
           cocoa::NSString_stringWithUTF8String(f[1]));
       objc::msg_send<void>(holder, objc::selector("setTitle:"),
                            cocoa::NSString_stringWithUTF8String(f[1]));
+      // Without this AppKit decides each item's enabled state from the
+      // responder chain and setEnabled: is silently ignored — the item stays
+      // live however many times the host disables it.
+      objc::msg_send<void>(menu, objc::selector("setAutoenablesItems:"), false);
       objc::msg_send<void>(holder, objc::selector("setSubmenu:"), menu);
       objc::msg_send<void>(stack.back(), objc::selector("addItem:"), holder);
       stack.push_back(menu);
@@ -617,9 +644,11 @@ static int32_t apply_custom_menu(App *a, const std::string &spec) {
             objc::msg_send<id>(objc::get_class("NSMenuItem"),
                                objc::selector("separatorItem")));
       }
-    } else if (kind == "I" && f.size() >= 5 && stack.size() > 1) {
-      a->menu_ids.push_back(f[1]);
-      long tag = static_cast<long>(a->menu_ids.size()) - 1;
+    } else if (kind == "I" && f.size() >= 8 && stack.size() > 1) {
+      // The host owns the tag: it indexes the handler registry in TypeScript,
+      // so the numbering has to come from there rather than from insertion
+      // order here.
+      long tag = strtol(f[1].c_str(), nullptr, 10);
       id it = objc::msg_send<id>(
           objc::msg_send<id>(objc::get_class("NSMenuItem"),
                              objc::selector("alloc")),
@@ -635,9 +664,17 @@ static int32_t apply_custom_menu(App *a, const std::string &spec) {
       NSUInteger mods = static_cast<NSUInteger>(strtoul(f[4].c_str(), nullptr, 10));
       objc::msg_send<void>(it, objc::selector("setKeyEquivalentModifierMask:"),
                            mods);
+      objc::msg_send<void>(it, objc::selector("setEnabled:"), f[5] == "1");
+      // f[7] says the item is checkable. AppKit lets any item carry a state,
+      // so it is unused here — it is on the wire for the GTK renderer, which
+      // has to choose GtkCheckMenuItem at construction.
+      objc::msg_send<void>(it, objc::selector("setState:"),
+                           static_cast<NSInteger>(f[6] == "1" ? 1 : 0));
       objc::msg_send<void>(stack.back(), objc::selector("addItem:"), it);
+      remember_item(a, tag, it);
     }
   }
+
   g_menu_owner = -1;
   for (int32_t i = 0; i < 8; i++) {
     if (app_at(i) == a) { g_menu_owner = i; break; }
@@ -1044,7 +1081,7 @@ int32_t wv_create(int32_t debug) {
     g_apps[i].on_timer_ctx = nullptr;
     g_apps[i].on_menu = nullptr;
     g_apps[i].on_menu_ctx = nullptr;
-    g_apps[i].menu_ids.clear();
+    g_apps[i].menu_items.clear();
     g_apps[i].req.clear();
     g_apps[i].cur_id.clear();
     g_apps[i].reply.clear();
@@ -1358,9 +1395,7 @@ int32_t wv_set_menu(int32_t h, const uint8_t *p, size_t n) {
 }
 
 // Retained, like wv_on_invoke: registered once and valid until the app exits.
-int32_t wv_on_menu(int32_t h,
-                   int32_t (*cb)(const uint8_t *, size_t, void *),
-                   void *ctx) {
+int32_t wv_on_menu(int32_t h, int32_t (*cb)(int32_t, void *), void *ctx) {
   App *a = app_at(h);
   if (!a) return -1;
   a->on_menu = cb;
@@ -1368,6 +1403,60 @@ int32_t wv_on_menu(int32_t h,
   return 0;
 }
 
+// Change one live item without rebuilding the bar. The tag is the host's
+// registry index, handed down by wv_set_menu. -1 for an unknown tag rather
+// than silence, so a stale handle is visible instead of a no-op.
+int32_t wv_menu_set_enabled(int32_t h, int32_t tag, int32_t on) {
+  App *a = app_at(h);
+  if (!a) return -1;
+#if defined(__APPLE__)
+  using namespace webview::detail;
+  objc::autoreleasepool arp;
+  id it = item_at(a, tag);
+  if (!it) return -1;
+  objc::msg_send<void>(it, objc::selector("setEnabled:"), on != 0);
+  return 0;
+#else
+  (void)tag; (void)on;
+  return -1;
+#endif
+}
+
+int32_t wv_menu_set_checked(int32_t h, int32_t tag, int32_t on) {
+  App *a = app_at(h);
+  if (!a) return -1;
+#if defined(__APPLE__)
+  using namespace webview::detail;
+  objc::autoreleasepool arp;
+  id it = item_at(a, tag);
+  if (!it) return -1;
+  // NSControlStateValueOn / Off.
+  objc::msg_send<void>(it, objc::selector("setState:"),
+                       static_cast<NSInteger>(on != 0 ? 1 : 0));
+  return 0;
+#else
+  (void)tag; (void)on;
+  return -1;
+#endif
+}
+
+int32_t wv_menu_set_label(int32_t h, int32_t tag, const uint8_t *p, size_t n) {
+  App *a = app_at(h);
+  if (!a) return -1;
+#if defined(__APPLE__)
+  using namespace webview::detail;
+  objc::autoreleasepool arp;
+  id it = item_at(a, tag);
+  if (!it) return -1;
+  objc::msg_send<void>(it, objc::selector("setTitle:"),
+                       cocoa::NSString_stringWithUTF8String(to_str(p, n)));
+  return 0;
+#else
+  (void)tag; (void)p; (void)n;
+  return -1;
+#endif
+}
+
 int32_t wv_set_fullscreen(int32_t h, int32_t on) {
   App *a = app_at(h);
   if (!a) return -1;