mirinjs 0.0.1-alpha.0 → 0.0.1-alpha.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mirinjs",
-  "version": "0.0.1-alpha.0",
+  "version": "0.0.1-alpha.10",
   "description": "Build desktop apps with Bun, TypeScript, and Chromium (CEF). The Bun-native Electron alternative.",
   "type": "module",
   "license": "MIT",

package/src/app.ts

@@ -32,6 +32,14 @@ export type AppEvents = {
   "window-all-closed": void;
 };
 
+/** A window's frame in screen points (bottom-left origin, like AppKit). */
+export interface WindowFrame {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
 type Listener<P> = (payload: P) => void;
 
 class Emitter<Events extends Record<string, unknown>> {
@@ -127,6 +135,31 @@ export class WindowHandle extends Emitter<WindowEvents> {
     runtime().core.windowSetMaterial(this.id, JSON.stringify(normalizeMaterial(material)));
   }
 
+  /** Move the window's bottom-left origin to screen point (x, y), in points. */
+  setPosition(x: number, y: number): void {
+    runtime().core.windowSetPosition(this.id, x, y);
+  }
+
+  /** The latest known window frame (screen points, bottom-left origin). Tracked
+   *  from `moved`/`resized` events, so it's current without a round-trip. */
+  getFrame(): WindowFrame {
+    return this.#frame ?? { x: 0, y: 0, width: 0, height: 0 };
+  }
+
+  /** Whether the window is currently zoomed (maximized). */
+  isMaximized(): boolean {
+    return this.#maximized;
+  }
+
+  #frame: WindowFrame | null = null;
+  #maximized = false;
+
+  /** @internal — fed from native window frame events. */
+  _setFrame(frame: WindowFrame, maximized: boolean): void {
+    this.#frame = frame;
+    this.#maximized = maximized;
+  }
+
   #control(verb: string): void {
     runtime().core.windowControl(this.id, verb);
   }
@@ -235,9 +268,37 @@ function normalizeMaterial(
   return typeof material === "string" ? { type: material } : material;
 }
 
+/** macOS Dock-icon controls (no-ops off macOS). */
+export interface Dock {
+  /** Hide the Dock icon and menu-bar presence (agent/accessory app). */
+  hide(): void;
+  /** Restore the Dock icon and menu bar. */
+  show(): void;
+}
+
 class MirinApp extends Emitter<AppEvents> {
   readonly windows = new Windows();
 
+  /** macOS Dock-icon controls. Hiding suits resident, hotkey-summoned apps. */
+  readonly dock: Dock = {
+    hide: () => this.#setDock(false),
+    show: () => this.#setDock(true),
+  };
+
+  /** Apply the Dock policy now if the core is up, else once it's ready. The
+   *  native command needs the CEF UI thread, which only runs after `ready`. */
+  #setDock(visible: boolean): void {
+    const apply = () => runtime().core.appSetDockVisible(visible);
+    if (runtime().core.isReady()) {
+      apply();
+    } else {
+      const off = this.on("ready", () => {
+        off();
+        apply();
+      });
+    }
+  }
+
   serve<R extends Router<any>>(router: R): ServeHandle<R> {
     runtime().rpc.setRouter(router);
     return { rpc: this.rpc as BroadcastEmitters<R> };
@@ -294,7 +355,15 @@ export function wireAppEvents(): void {
   for (const kind of WINDOW_EVENTS) {
     onNativeEvent(`window.${kind}`, (event: NativeEvent) => {
       const id = event.id as number | undefined;
-      if (id != null) app.windows._byId(id)?._emit(kind, undefined);
+      if (id == null) return;
+      const handle = app.windows._byId(id);
+      if (!handle) return;
+      // moved/resized carry the current frame + maximized state; track them so
+      // getFrame()/isMaximized() are answerable without a round-trip.
+      if (event.frame) {
+        handle._setFrame(event.frame as WindowFrame, Boolean(event.maximized));
+      }
+      handle._emit(kind, undefined);
     });
   }
 }

package/src/config.ts

@@ -42,12 +42,22 @@ export interface WindowConfig {
   title?: string;
   width?: number;
   height?: number;
+  /** Screen position (bottom-left origin, points). Centered when absent. */
+  x?: number;
+  y?: number;
   /** "ready" (default) shows on first paint to avoid a white flash. */
   show?: "ready" | "immediately";
   /** "auto" (default) opens at launch; "manual" windows are templates for app.windows.open(name). */
   open?: "auto" | "manual";
   /** Custom title bar: hide it (content fills) or inset the traffic lights. */
   titleBarStyle?: "hidden" | "hiddenInset";
+  /**
+   * Reposition the macOS traffic-light buttons for a custom title bar.
+   * `x` insets the leftmost button from the left edge; `y` sets the effective
+   * title-bar height the buttons are vertically centered in (so `y` ≈ your CSS
+   * title-bar height minus the button height). Re-applied automatically on resize.
+   */
+  trafficLightPosition?: { x: number; y: number };
   /** Non-opaque window (for transparent/blurred UIs). */
   transparent?: boolean;
   /**
@@ -70,6 +80,12 @@ export interface MirinConfig {
   name: string;
   /** Main-process entry, relative to the project root (runs in the Bun Worker). */
   main: string;
+  /**
+   * App icon, relative to the project root (macOS). Accepts a `.icns`, a
+   * `.iconset` directory, or a single square `.png` (≥512px) that mirin renders
+   * into an `.icns`. Embedded in the bundle for the Dock and Finder.
+   */
+  icon?: string;
   windows: Record<string, WindowConfig>;
 }
 

package/src/host.ts

@@ -36,16 +36,23 @@ const manifest = JSON.parse(
 
 const coreConfig = JSON.parse(
   process.env.MIRIN_CONFIG_JSON ??
-    JSON.stringify(process.env.MIRIN_DEV_URL ? {} : { resources_path: resourcesDir }),
+    JSON.stringify(
+      process.env.MIRIN_DEV_URL ? { dev: true } : { resources_path: resourcesDir },
+    ),
 );
 
+// Load the native core on the main thread FIRST. The Worker also dlopens the
+// same dylib in its boot; doing the main-thread dlopen before spawning the
+// Worker serializes the first-time load instead of racing two concurrent
+// dlopens across threads.
+const core = new Core(corePath);
+
 const worker = new Worker(workerPath, {
   workerData: { corePath, manifest, devUrl: process.env.MIRIN_DEV_URL },
 });
 worker.on("error", (err) => console.error("[mirin worker]", err));
 
 // Hand the main thread to CEF. Blocks in the message loop until the app quits.
-const core = new Core(corePath);
 const exitCode = core.run(JSON.stringify(coreConfig));
 
 void worker.terminate();

package/src/index.ts

@@ -3,8 +3,8 @@
  *
  * Importing this module boots the runtime (loads libmirin_core, starts the RPC
  * server, begins draining native events) and exposes the developer-facing API:
- * the `app` singleton plus the `menu`, `Tray`, `dialog`, `clipboard`, and
- * `globalShortcut` features (docs/api-design.md).
+ * the `app` singleton plus the `menu`, `Tray`, `dialog`, `clipboard`,
+ * `globalShortcut`, and `logger` features (docs/api-design.md).
  */
 
 import { app, wireAppEvents } from "./app.ts";
@@ -22,18 +22,22 @@ export { Tray } from "./tray.ts";
 export { dialog } from "./dialog.ts";
 export { clipboard } from "./clipboard.ts";
 export { globalShortcut } from "./shortcut.ts";
+export { logger, setLogLevel, getLogLevel, Logger } from "./logger.ts";
 export { NotAttachedError } from "./runtime.ts";
 
 export type {
   WindowEvents,
   WindowMaterialInfo,
+  WindowFrame,
   AppEvents,
   WindowHandle,
   WindowOpenOptions,
   ServeHandle,
   BroadcastEmitters,
+  Dock,
 } from "./app.ts";
 export type { MenuItemTemplate, MenuRole } from "./menu.ts";
+export type { LogLevel } from "./logger.ts";
 export type { TrayOptions } from "./tray.ts";
 export type { OpenDialogOptions, SaveDialogOptions, MessageDialogOptions } from "./dialog.ts";
 export type {

package/src/logger.ts

@@ -0,0 +1,97 @@
+/**
+ * mirin/logger — a small leveled logger for the Bun main process.
+ *
+ * Exported from `mirinjs` so app code and mirin itself log consistently. The
+ * level defaults from the `MIRIN_LOG` env var (`debug` | `info` | `warn` |
+ * `error` | `silent`), falling back to `info`; change it at runtime with
+ * `logger.setLevel(...)`. `warn`/`error` go to stderr, `debug`/`info` to stdout.
+ *
+ *   import { logger } from "mirinjs";
+ *   logger.info("server listening", port);
+ *   const db = logger.child("db");
+ *   db.debug("query", sql);            // → [mirin:db] debug query …
+ */
+
+export type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+
+const ORDER: Record<LogLevel, number> = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  silent: 100,
+};
+
+const COLOR = {
+  debug: "\x1b[2m", // dim
+  info: "\x1b[36m", // cyan
+  warn: "\x1b[33m", // yellow
+  error: "\x1b[31m", // red
+  dim: "\x1b[2m",
+  reset: "\x1b[0m",
+} as const;
+
+const LEVELS: LogLevel[] = ["debug", "info", "warn", "error", "silent"];
+
+function envLevel(): LogLevel {
+  const v = (process.env.MIRIN_LOG ?? "").toLowerCase() as LogLevel;
+  return LEVELS.includes(v) ? v : "info";
+}
+
+// Shared across every logger instance so `setLevel` is global.
+let currentLevel: LogLevel = envLevel();
+const useColor = Boolean(process.stderr.isTTY) && process.env.NO_COLOR == null;
+
+/** Set the global minimum level. Messages below it are dropped. */
+export function setLogLevel(level: LogLevel): void {
+  currentLevel = level;
+}
+
+/** The current global log level. */
+export function getLogLevel(): LogLevel {
+  return currentLevel;
+}
+
+export class Logger {
+  /** @param scope optional dotted scope shown as `[mirin:scope]`. */
+  constructor(private readonly scope?: string) {}
+
+  /** Derive a scoped child logger (e.g. `logger.child("db")`). */
+  child(scope: string): Logger {
+    return new Logger(this.scope ? `${this.scope}:${scope}` : scope);
+  }
+
+  /** Set the global level (same as the exported `setLogLevel`). */
+  setLevel(level: LogLevel): void {
+    setLogLevel(level);
+  }
+
+  get level(): LogLevel {
+    return currentLevel;
+  }
+
+  debug(...args: unknown[]): void {
+    this.#emit("debug", args);
+  }
+  info(...args: unknown[]): void {
+    this.#emit("info", args);
+  }
+  warn(...args: unknown[]): void {
+    this.#emit("warn", args);
+  }
+  error(...args: unknown[]): void {
+    this.#emit("error", args);
+  }
+
+  #emit(level: Exclude<LogLevel, "silent">, args: unknown[]): void {
+    if (ORDER[level] < ORDER[currentLevel]) return;
+    const name = this.scope ? `[mirin:${this.scope}]` : "[mirin]";
+    const prefix = useColor ? `${COLOR.dim}${name}${COLOR.reset}` : name;
+    const tag = useColor ? `${COLOR[level]}${level}${COLOR.reset}` : level;
+    const sink = level === "warn" || level === "error" ? console.error : console.log;
+    sink(`${prefix} ${tag}`, ...args);
+  }
+}
+
+/** The default mirin logger. Import and use directly, or derive children. */
+export const logger = new Logger();

package/src/native.ts

@@ -23,7 +23,9 @@ const symbols = {
   mirin_window_set_title: { args: [FFIType.u32, FFIType.ptr], returns: FFIType.void },
   mirin_window_control: { args: [FFIType.u32, FFIType.ptr], returns: FFIType.void },
   mirin_window_set_material: { args: [FFIType.u32, FFIType.ptr], returns: FFIType.void },
+  mirin_window_set_position: { args: [FFIType.u32, FFIType.f64, FFIType.f64], returns: FFIType.void },
   mirin_app_quit: { args: [], returns: FFIType.void },
+  mirin_app_set_dock_visible: { args: [FFIType.i32], returns: FFIType.void },
   mirin_set_app_menu: { args: [FFIType.ptr], returns: FFIType.void },
   mirin_popup_menu: { args: [FFIType.ptr], returns: FFIType.void },
   mirin_tray_create: { args: [FFIType.ptr], returns: FFIType.void },
@@ -107,10 +109,18 @@ export class Core {
     this.#lib.symbols.mirin_window_set_material(id, ptr(buf));
   }
 
+  windowSetPosition(id: number, x: number, y: number): void {
+    this.#lib.symbols.mirin_window_set_position(id, x, y);
+  }
+
   quit(): void {
     this.#lib.symbols.mirin_app_quit();
   }
 
+  appSetDockVisible(visible: boolean): void {
+    this.#lib.symbols.mirin_app_set_dock_visible(visible ? 1 : 0);
+  }
+
   setAppMenu(templateJson: string): void {
     const buf = nullTerminated(templateJson);
     this.#lib.symbols.mirin_set_app_menu(ptr(buf));

package/src/runtime.ts

@@ -35,9 +35,14 @@ export function runtime(): Runtime {
   return current;
 }
 
-/** Dev: every window loads the Vite server. Production: its manifest app:// URL. */
+/** Dev: every window loads the Vite server. Production: its manifest app:// URL.
+ *  Any query/hash on the requested URL (e.g. "#devtools") is preserved so
+ *  hash-routed sub-windows reach the right view through the dev server too. */
 export function resolveUrl(url: string): string {
-  return current?.devUrl ?? url;
+  const devUrl = current?.devUrl;
+  if (!devUrl) return url;
+  const suffix = url.match(/[?#].*$/)?.[0] ?? "";
+  return devUrl + suffix;
 }
 
 // ---- native event dispatch ----