@gjsify/node-gi 0.26.0 → 0.27.0

package/globals.d.ts

@@ -6,38 +6,38 @@ import type { GettextModule } from './gettext.js';
 
 /** The legacy GJS `imports` object (a minimal Node-backed subset). */
 export interface GjsImports {
-  /** `imports.gi.<Ns>` resolves a namespace; `imports.gi.versions.<Ns>` pins a version. */
-  gi: {
-    versions: Record<string, string | undefined>;
-    [namespace: string]: unknown;
-  };
-  /** `imports.system` — the `@gjsify/node-gi/system` module (process identity + lifecycle). */
-  system: SystemModule;
-  /** `imports.gettext` — the `@gjsify/node-gi/gettext` module (no-translation passthrough). */
-  gettext: GettextModule;
-  /** `imports.byteArray` — the legacy GJS byte-array module (GJS semantics: zero-terminated, fatal decode). */
-  byteArray: {
-    ByteArray: new (arg?: number | Uint8Array) => {
-      length: number;
-      toString(encoding?: string): string;
-      toGBytes(): unknown;
+    /** `imports.gi.<Ns>` resolves a namespace; `imports.gi.versions.<Ns>` pins a version. */
+    gi: {
+        versions: Record<string, string | undefined>;
+        [namespace: string]: unknown;
     };
-    fromArray(array: Iterable<number>): unknown;
-    fromGBytes(bytes: unknown): Uint8Array;
-    fromString(string: string, encoding?: string): Uint8Array;
-    toGBytes(array: Uint8Array): unknown;
-    toString(byteArray: Uint8Array, encoding?: string): string;
-  };
-  versions: Record<string, unknown>;
+    /** `imports.system` — the `@gjsify/node-gi/system` module (process identity + lifecycle). */
+    system: SystemModule;
+    /** `imports.gettext` — the `@gjsify/node-gi/gettext` module (no-translation passthrough). */
+    gettext: GettextModule;
+    /** `imports.byteArray` — the legacy GJS byte-array module (GJS semantics: zero-terminated, fatal decode). */
+    byteArray: {
+        ByteArray: new (arg?: number | Uint8Array) => {
+            length: number;
+            toString(encoding?: string): string;
+            toGBytes(): unknown;
+        };
+        fromArray(array: Iterable<number>): unknown;
+        fromGBytes(bytes: unknown): Uint8Array;
+        fromString(string: string, encoding?: string): Uint8Array;
+        toGBytes(array: Uint8Array): unknown;
+        toString(byteArray: Uint8Array, encoding?: string): string;
+    };
+    versions: Record<string, unknown>;
 }
 
 declare global {
-  var print: (...args: unknown[]) => void;
-  var printerr: (...args: unknown[]) => void;
-  var log: (...args: unknown[]) => void;
-  var logError: (error: unknown, prefix?: string) => void;
-  var ARGV: string[];
-  var imports: GjsImports;
+    var print: (...args: unknown[]) => void;
+    var printerr: (...args: unknown[]) => void;
+    var log: (...args: unknown[]) => void;
+    var logError: (error: unknown, prefix?: string) => void;
+    var ARGV: string[];
+    var imports: GjsImports;
 }
 
 /** Install the GJS ambient globals on `globalThis` (idempotent). */

package/globals.js

@@ -29,7 +29,7 @@ import { createPackage } from './overrides/package.js';
 // GJS stringifies each argument with String() and joins with a space (no
 // util.inspect object formatting) — match that for fidelity.
 function gjsFormat(args) {
-  return args.map((a) => String(a)).join(' ');
+    return args.map((a) => String(a)).join(' ');
 }
 
 /**
@@ -37,112 +37,118 @@ function gjsFormat(args) {
  * only defined if absent, so it never clobbers a host that already provides it).
  */
 export function installGjsGlobals() {
-  const g = globalThis;
+    const g = globalThis;
 
-  if (typeof g.print === 'undefined') {
-    g.print = (...args) => console.log(gjsFormat(args));
-  }
-  if (typeof g.printerr === 'undefined') {
-    g.printerr = (...args) => console.error(gjsFormat(args));
-  }
-  if (typeof g.log === 'undefined') {
-    // GJS `log` writes to the GLib structured log (stderr/journal).
-    g.log = (...args) => console.error(gjsFormat(args));
-  }
-  if (typeof g.logError === 'undefined') {
-    g.logError = (error, prefix) => {
-      const head = prefix ? `${prefix}: ` : '';
-      const body = error && error.stack ? error.stack : String(error);
-      console.error(head + body);
-    };
-  }
-  if (typeof g.ARGV === 'undefined') {
-    // GJS ARGV excludes the interpreter + the script path (Node's argv[0]+[1]).
-    g.ARGV = (typeof process !== 'undefined' && Array.isArray(process.argv))
-      ? process.argv.slice(2)
-      : [];
-  }
+    if (typeof g.print === 'undefined') {
+        g.print = (...args) => console.log(gjsFormat(args));
+    }
+    if (typeof g.printerr === 'undefined') {
+        g.printerr = (...args) => console.error(gjsFormat(args));
+    }
+    if (typeof g.log === 'undefined') {
+        // GJS `log` writes to the GLib structured log (stderr/journal).
+        g.log = (...args) => console.error(gjsFormat(args));
+    }
+    if (typeof g.logError === 'undefined') {
+        g.logError = (error, prefix) => {
+            const head = prefix ? `${prefix}: ` : '';
+            const body = error && error.stack ? error.stack : String(error);
+            console.error(head + body);
+        };
+    }
+    if (typeof g.ARGV === 'undefined') {
+        // GJS ARGV excludes the interpreter + the script path (Node's argv[0]+[1]).
+        g.ARGV = typeof process !== 'undefined' && Array.isArray(process.argv) ? process.argv.slice(2) : [];
+    }
 
-  if (typeof g.imports === 'undefined') {
-    g.imports = makeImports();
-  }
+    if (typeof g.imports === 'undefined') {
+        g.imports = makeImports();
+    }
 
-  return g.imports;
+    return g.imports;
 }
 
 // Build the legacy `imports` object. `imports.gi.<Ns>` resolves a namespace via
 // the node-gi backend, honouring a version pinned in `imports.gi.versions.<Ns>`
 // (which GJS code sets before the first access).
 function makeImports() {
-  const giVersions = Object.create(null);
-  const giCache = new Map();
-  const gi = new Proxy(
-    { versions: giVersions },
-    {
-      get(target, name) {
-        if (name === 'versions') return giVersions;
-        if (typeof name !== 'string') return target[name];
-        if (giCache.has(name)) return giCache.get(name);
-        const ns = requireGi(name, giVersions[name]);
-        giCache.set(name, ns);
-        return ns;
-      },
-      has(_target, name) {
-        return name === 'versions' || typeof name === 'string';
-      },
-    },
-  );
+    const giVersions = Object.create(null);
+    const giCache = new Map();
+    const gi = new Proxy(
+        { versions: giVersions },
+        {
+            get(target, name) {
+                if (name === 'versions') return giVersions;
+                if (typeof name !== 'string') return target[name];
+                if (giCache.has(name)) return giCache.get(name);
+                const ns = requireGi(name, giVersions[name]);
+                giCache.set(name, ns);
+                return ns;
+            },
+            has(_target, name) {
+                return name === 'versions' || typeof name === 'string';
+            },
+        },
+    );
 
-  // `imports.system` + `imports.gettext` + `imports.cairo` are the standalone
-  // module objects (`./system.js` / `./gettext.js` / `./cairo.js`) — the single
-  // source of truth for those surfaces, shared with the bare `system` / `gettext` /
-  // `cairo` specifiers on Node.
-  //
-  // `imports.signals` is the pure-JS Signals mixin (`addSignalMethods` + the
-  // `_connect`/`_disconnect`/`_emit`/… primitives), the SAME module the DBus proxy
-  // surface uses. `imports.mainloop` (a lazy getter — it needs GLib, and a source
-  // that never touches the main loop should not pull GLib in) is the thin
-  // GLib.MainLoop convenience layer.
-  const { addSignalMethods, _connect, _connectAfter, _disconnect, _emit, _signalHandlerIsConnected, _disconnectAll } =
-    signalsModule;
-  const imports = {
-    gi,
-    system,
-    gettext,
-    cairo,
-    // `imports.byteArray` — the legacy GJS byte-array module
-    // (fromGBytes/toGBytes/fromString/toString/fromArray/ByteArray), the seam
-    // `@gjsify/utils`' gbytesToUint8Array/cli() read subprocess output through.
-    // GLib is only pulled in lazily (toGBytes), so seeding it here is free.
-    byteArray: createByteArray(requireGi),
-    signals: { addSignalMethods, _connect, _connectAfter, _disconnect, _emit, _signalHandlerIsConnected, _disconnectAll },
-    // GJS's `imports.searchPath` — `imports.package.init` unshifts the app's
-    // moduledir onto it. Inert on node-gi (ESM + gi://), but present + safe so
-    // source that reads/mutates it doesn't throw.
-    searchPath: [],
-    versions: Object.create(null),
-  };
-  let mainloop;
-  Object.defineProperty(imports, 'mainloop', {
-    get() {
-      if (mainloop === undefined) mainloop = createMainloop(requireGi('GLib', '2.0'));
-      return mainloop;
-    },
-    enumerable: true,
-    configurable: true,
-  });
-  // `imports.package` — the GJS application bootstrap (pkg.init/initGettext/
-  // initFormat). Lazy like `mainloop`: a bundle that never calls it pulls no GLib.
-  let pkg;
-  Object.defineProperty(imports, 'package', {
-    get() {
-      if (pkg === undefined) pkg = createPackage({ requireGi, gettext, imports });
-      return pkg;
-    },
-    enumerable: true,
-    configurable: true,
-  });
-  return imports;
+    // `imports.system` + `imports.gettext` + `imports.cairo` are the standalone
+    // module objects (`./system.js` / `./gettext.js` / `./cairo.js`) — the single
+    // source of truth for those surfaces, shared with the bare `system` / `gettext` /
+    // `cairo` specifiers on Node.
+    //
+    // `imports.signals` is the pure-JS Signals mixin (`addSignalMethods` + the
+    // `_connect`/`_disconnect`/`_emit`/… primitives), the SAME module the DBus proxy
+    // surface uses. `imports.mainloop` (a lazy getter — it needs GLib, and a source
+    // that never touches the main loop should not pull GLib in) is the thin
+    // GLib.MainLoop convenience layer.
+    const { addSignalMethods, _connect, _connectAfter, _disconnect, _emit, _signalHandlerIsConnected, _disconnectAll } =
+        signalsModule;
+    const imports = {
+        gi,
+        system,
+        gettext,
+        cairo,
+        // `imports.byteArray` — the legacy GJS byte-array module
+        // (fromGBytes/toGBytes/fromString/toString/fromArray/ByteArray), the seam
+        // `@gjsify/utils`' gbytesToUint8Array/cli() read subprocess output through.
+        // GLib is only pulled in lazily (toGBytes), so seeding it here is free.
+        byteArray: createByteArray(requireGi),
+        signals: {
+            addSignalMethods,
+            _connect,
+            _connectAfter,
+            _disconnect,
+            _emit,
+            _signalHandlerIsConnected,
+            _disconnectAll,
+        },
+        // GJS's `imports.searchPath` — `imports.package.init` unshifts the app's
+        // moduledir onto it. Inert on node-gi (ESM + gi://), but present + safe so
+        // source that reads/mutates it doesn't throw.
+        searchPath: [],
+        versions: Object.create(null),
+    };
+    let mainloop;
+    Object.defineProperty(imports, 'mainloop', {
+        get() {
+            if (mainloop === undefined) mainloop = createMainloop(requireGi('GLib', '2.0'));
+            return mainloop;
+        },
+        enumerable: true,
+        configurable: true,
+    });
+    // `imports.package` — the GJS application bootstrap (pkg.init/initGettext/
+    // initFormat). Lazy like `mainloop`: a bundle that never calls it pulls no GLib.
+    let pkg;
+    Object.defineProperty(imports, 'package', {
+        get() {
+            if (pkg === undefined) pkg = createPackage({ requireGi, gettext, imports });
+            return pkg;
+        },
+        enumerable: true,
+        configurable: true,
+    });
+    return imports;
 }
 
 // Side effect on import: seed the globals.

package/gtk-runtime.js

@@ -1,10 +1,12 @@
 // SPDX-License-Identifier: MIT
 // @gjsify/node-gi/gtk-runtime — locate + activate a batteries-included, relocated
 // GTK/GObject-Introspection runtime bundle so gi:// namespaces load with NO system
-// or Homebrew GTK (Phase 2 of cross-platform node-gi). Today only darwin-arm64
-// ships such a bundle (@gjsify/gtk-runtime-darwin-arm64); this is a no-op on every
-// other platform, and harmless when no bundle is present (the addon then uses the
-// host's GTK exactly as before).
+// or Homebrew GTK (Phase 2 of cross-platform node-gi). Bundles ship for darwin-arm64,
+// darwin-x64 and win32-x64 (@gjsify/gtk-runtime-<platform>-<arch>); NOTHING below
+// keys on a specific target — the tag is derived from the running process, so a new
+// bundle is found by the mechanism that found the first. This is a no-op on every
+// platform without a bundle, and harmless when no bundle is present (the addon then
+// uses the host's GTK exactly as before).
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
@@ -244,7 +246,9 @@ export function activateBundledGtkRuntime(native) {
     } else {
         const existing = process.env.DYLD_FALLBACK_LIBRARY_PATH;
         if (!existing || !existing.split(':').includes(bundle.libDir)) {
-            process.env.DYLD_FALLBACK_LIBRARY_PATH = existing ? `${bundle.libDir}:${existing}` : `${bundle.libDir}:/usr/lib`;
+            process.env.DYLD_FALLBACK_LIBRARY_PATH = existing
+                ? `${bundle.libDir}:${existing}`
+                : `${bundle.libDir}:/usr/lib`;
         }
     }