@gjsify/utils 0.3.21 → 0.4.3

package/src/gio-errors.ts

@@ -1,156 +0,0 @@
-// Shared Gio.IOErrorEnum → Node.js error code mapping.
-// Used by fs, net, http, dns, child-process, and other packages that wrap Gio operations.
-//
-// The enum values are numeric constants from GLib — we use numbers directly
-// to avoid importing Gio just for error handling (keeps this usable in Node.js tests too).
-
-/** Map from Gio.IOErrorEnum numeric values to Node.js error code strings. */
-export const GIO_ERROR_TO_NODE: Record<number, string> = {
-  0:  'EIO',          // FAILED
-  1:  'ENOENT',       // NOT_FOUND
-  2:  'EEXIST',       // EXISTS
-  3:  'EISDIR',       // IS_DIRECTORY
-  4:  'ENOTDIR',      // NOT_DIRECTORY
-  5:  'ENOTEMPTY',    // NOT_EMPTY
-  6:  'ENOENT',       // NOT_REGULAR_FILE
-  7:  'ENFILE',       // TOO_MANY_OPEN_FILES
-  9:  'EACCES',       // NOT_MOUNTABLE_FILE
-  10: 'ENFILE',       // FILENAME_TOO_LONG
-  11: 'EINVAL',       // INVALID_FILENAME
-  12: 'ELOOP',        // TOO_MANY_LINKS
-  13: 'ENOSPC',       // NO_SPACE
-  14: 'EACCES',       // PERMISSION_DENIED
-  17: 'ELOOP',        // TOO_MANY_LINKS (duplicate guard)
-  19: 'ENOSPC',       // NO_SPACE (duplicate guard)
-  20: 'ENOTSUP',      // NOT_SUPPORTED
-  22: 'EMFILE',       // TOO_MANY_OPEN_FILES
-  24: 'EROFS',        // READ_ONLY
-  25: 'ECANCELED',    // CANCELLED
-  26: 'EBUSY',        // BUSY
-  27: 'ETIMEDOUT',    // TIMED_OUT
-  28: 'EHOSTUNREACH', // HOST_NOT_FOUND (was WOULD_BLOCK)
-  30: 'EHOSTUNREACH', // HOST_NOT_FOUND
-  31: 'ENETUNREACH',  // NETWORK_UNREACHABLE
-  32: 'ECONNREFUSED', // CONNECTION_REFUSED (legacy value)
-  33: 'EADDRINUSE',   // ADDRESS_IN_USE
-  34: 'ECONNRESET',   // CONNECTION_CLOSED (mapped to reset)
-  36: 'EPIPE',        // BROKEN_PIPE
-  38: 'ENETUNREACH',  // NETWORK_UNREACHABLE (actual GJS value)
-  39: 'ECONNREFUSED', // CONNECTION_REFUSED (actual GJS value)
-  40: 'ECONNREFUSED', // PROXY_FAILED
-  41: 'EACCES',       // PROXY_AUTH_FAILED
-  44: 'ECONNRESET',   // CONNECTION_CLOSED (actual GJS value)
-  46: 'EMSGSIZE',     // MESSAGE_TOO_LARGE
-};
-
-export interface NodeErrorDetails {
-  path?: string;
-  dest?: string;
-  address?: string;
-  port?: number;
-  hostname?: string;
-}
-
-/** Node.js-style ErrnoException (defined locally to avoid @types/node dependency). */
-export interface ErrnoException extends Error {
-  errno?: number;
-  code?: string;
-  path?: string;
-  syscall?: string;
-  address?: string;
-  port?: number;
-  hostname?: string;
-}
-
-/**
- * Create a Node.js-style ErrnoException from a Gio error.
- * Works for fs, net, dns, child-process, and other modules.
- */
-export function createNodeError(
-  err: unknown,
-  syscall: string,
-  details?: NodeErrorDetails
-): ErrnoException {
-  const errObj = err as { code?: number; message?: string } | null | undefined;
-  const code = GIO_ERROR_TO_NODE[errObj?.code ?? -1] || 'EIO';
-
-  let msg = `${code}: ${errObj?.message || 'unknown error'}, ${syscall}`;
-  if (details?.path) msg += ` '${details.path}'`;
-  if (details?.dest) msg += ` -> '${details.dest}'`;
-  if (details?.address) msg += ` ${details.address}`;
-  if (details?.port != null) msg += `:${details.port}`;
-
-  const error = new Error(msg) as ErrnoException;
-  error.code = code;
-  error.syscall = syscall;
-  error.errno = -(errObj?.code || 0);
-
-  if (details?.path) error.path = details.path;
-  if (details?.address) error.address = details.address;
-  if (details?.port != null) error.port = details.port;
-
-  return error;
-}
-
-/**
- * Check if a Gio error is a "not found" error.
- */
-export function isNotFoundError(err: unknown): boolean {
-  const errObj = err as { code?: number | string } | null | undefined;
-  return errObj?.code === 1 || errObj?.code === 'ENOENT';
-}
-
-/**
- * Map from GLib.FileError numeric values to Node.js error code strings.
- * Distinct from Gio.IOErrorEnum — GLib.IOChannel.new_file() and some other
- * low-level GLib APIs throw GLib.FileError (domain "g-file-error"), which
- * has different numeric values than Gio.IOErrorEnum (domain "g-io-error-quark").
- */
-export const GLIB_FILE_ERROR_TO_NODE: Record<number, string> = {
-  0:  'EEXIST',
-  1:  'EISDIR',
-  2:  'EACCES',
-  3:  'ENAMETOOLONG',
-  4:  'ENOENT',
-  5:  'ENOTDIR',
-  6:  'ENXIO',
-  7:  'ENODEV',
-  8:  'EROFS',
-  11: 'ELOOP',
-  12: 'ENOSPC',
-  13: 'ENOMEM',
-  14: 'EMFILE',
-  15: 'ENFILE',
-  16: 'EBADF',
-  17: 'EINVAL',
-  18: 'EPIPE',
-  21: 'EIO',
-  22: 'EPERM',
-  24: 'EIO',
-};
-
-/**
- * Map a GLib.FileError to a Node.js-style ErrnoException. Counterpart to
- * `createNodeError` for the Gio.IOErrorEnum case; kept separate because the
- * enum domains differ.
- */
-export function createGLibFileError(
-  err: unknown,
-  syscall: string,
-  details?: NodeErrorDetails,
-): ErrnoException {
-  const errObj = err as { code?: number; message?: string } | null | undefined;
-  const code = GLIB_FILE_ERROR_TO_NODE[errObj?.code ?? -1] ?? 'EIO';
-
-  let msg = `${code}: ${errObj?.message || 'unknown error'}, ${syscall}`;
-  if (details?.path) msg += ` '${details.path}'`;
-  if (details?.dest) msg += ` -> '${details.dest}'`;
-
-  const error = new Error(msg) as ErrnoException;
-  error.code = code;
-  error.syscall = syscall;
-  error.errno = -(errObj?.code || 0);
-  if (details?.path) error.path = details.path;
-
-  return error;
-}

package/src/gio.ts

@@ -1,67 +0,0 @@
-import Gio from '@girs/gio-2.0';
-import GLib from '@girs/glib-2.0';
-
-const byteArray = imports.byteArray;
-
-/**
- * Generic promise wrapper for Gio async/finish method pairs.
- *
- * Example:
- *   const stream = await gioAsync<Gio.InputStream>(session, 'send_async', 'send_finish', msg, priority, null);
- */
-export function gioAsync<T>(
-    obj: any,
-    asyncMethod: string,
-    finishMethod: string,
-    ...args: any[]
-): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-        obj[asyncMethod](...args, (_self: any, asyncRes: Gio.AsyncResult) => {
-            try {
-                resolve(obj[finishMethod](asyncRes));
-            } catch (error) {
-                reject(error);
-            }
-        });
-    });
-}
-
-/**
- * Promise wrapper around `Gio.InputStream.read_bytes_async` / `read_bytes_finish`.
- * Returns a `Uint8Array` or `null` if the end of the stream is reached.
- */
-export async function readBytesAsync(
-    inputStream: Gio.InputStream,
-    count = 4096,
-    ioPriority = GLib.PRIORITY_DEFAULT,
-    cancellable: Gio.Cancellable | null = null
-): Promise<Uint8Array | null> {
-    return new Promise<Uint8Array | null>((resolve, reject) => {
-        inputStream.read_bytes_async(count, ioPriority, cancellable, (_self, asyncRes) => {
-            try {
-                const res = inputStream.read_bytes_finish(asyncRes);
-                if (res.get_size() === 0) {
-                    return resolve(null);
-                }
-                return resolve(byteArray.fromGBytes(res));
-            } catch (error) {
-                reject(error);
-            }
-        });
-    });
-}
-
-/**
- * Async generator that yields `Uint8Array` chunks from a `Gio.InputStream`.
- */
-export async function* inputStreamAsyncIterator(
-    inputStream: Gio.InputStream,
-    count = 4096,
-    ioPriority = GLib.PRIORITY_DEFAULT,
-    cancellable: Gio.Cancellable | null = null
-): AsyncGenerator<Uint8Array> {
-    let chunk: Uint8Array | null;
-    while ((chunk = await readBytesAsync(inputStream, count, ioPriority, cancellable)) !== null) {
-        yield chunk;
-    }
-}

package/src/globals.ts

@@ -1,13 +0,0 @@
-// Shared utility for registering global polyfills.
-// Used by web packages (abort-controller, dom-exception, streams, webcrypto, etc.)
-// to consistently register globals only when they're missing.
-
-/**
- * Register a value as a global property if it doesn't already exist.
- * This is a no-op in environments where the global is already defined (e.g. Node.js).
- */
-export function registerGlobal(name: string, value: unknown): void {
-  if (typeof (globalThis as any)[name] === 'undefined') {
-    (globalThis as any)[name] = value;
-  }
-}

package/src/index.ts

@@ -1,18 +0,0 @@
-export * from './callable.js';
-export * from './base64.js';
-export * from './byte-array.js';
-export * from './cli.js';
-export * from './defer.js';
-export * from './encoding.js';
-export * from './globals.js';
-export * from './error.js';
-export * from './file.js';
-export * from './fs.js';
-export * from './gio.js';
-export * from './gio-errors.js';
-export * from './message.js';
-export * from './microtask.js';
-export * from './next-tick.js';
-export * from './path.js';
-export * from './structured-clone.js';
-export * from './main-loop.js';

package/src/log.spec.ts

@@ -1,32 +0,0 @@
-import { describe, it, assert, spy } from '@gjsify/unit';
-// import { logSignals } from '@gjsify/utils';
-// import type { StructuredLogData } from '@gjsify/utils';
-
-const createUncaughtException = async () => {
-	throw new Error("top level error");
-}
-
-const sleep = (ms: number) => {
-	return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-export default async () => {
-	await describe('logSignals', async () => {
-        // TODO: Fix this test
-
-        // await it("should emit an uncaughtException event on a top level throw", async () => {
-        //     const onUnhandledRejection = spy((_self, _data: StructuredLogData, _promiseData) => {});
-
-        //     const signalHandlerId = logSignals.connect("unhandledRejection", onUnhandledRejection);
-
-		// 	createUncaughtException();
-
-		// 	await sleep(10);
-
-        //     logSignals.disconnect(signalHandlerId)
-
-        //     assert.strictEqual(onUnhandledRejection.calls.length, 1, "onUnhandledRejection should be called.")
-        //     // assert.strictEqual(onUnhandledRejection.calls[0].arguments[0], error)
-        // })
-	});
-}

package/src/main-loop.ts

@@ -1,62 +0,0 @@
-// GLib MainLoop management for GJS — original implementation
-// Provides an implicit event loop analogous to Node.js's built-in event loop.
-
-import type GLib from '@girs/glib-2.0';
-
-/** Sentinel to prevent double-start (setMainLoopHook throws if called twice). */
-let _started = false;
-
-/** The singleton MainLoop instance, if created. */
-let _loop: GLib.MainLoop | null = null;
-
-/**
- * Ensure a GLib MainLoop is running for async I/O dispatch (Soup.Server,
- * Gio.SocketService, etc.). No-op on Node.js. Idempotent.
- *
- * - Called automatically by `http.Server.listen()`, `net.Server.listen()`,
- *   `dgram.Socket.bind()` etc.
- * - GTK apps should NOT call this — they use `Gtk.Application.runAsync()` instead.
- *
- * @returns The MainLoop instance on GJS, or `undefined` on Node.js.
- */
-export function ensureMainLoop(): GLib.MainLoop | undefined {
-  const gjsImports = (globalThis as any).imports;
-  if (!gjsImports) return undefined; // Not GJS
-  if (_started) return _loop!;
-
-  const GLibModule = gjsImports.gi.GLib;
-  _loop = new GLibModule.MainLoop(null, false);
-  _started = true;
-
-  // Only call runAsync() if no mainloop is currently running on the default
-  // context. If one is already running (e.g., test runner's mainloop.run()
-  // or Gtk.Application.runAsync()), async I/O already works through the
-  // shared default context — calling runAsync() would register a
-  // setMainLoopHook whose loop.run() blocks forever after tests quit it
-  // (g_main_loop_run resets the quit flag on entry).
-  if (GLibModule.main_depth() === 0) {
-    try {
-      (_loop as any).runAsync();
-    } catch {
-      // setMainLoopHook throws if already called (e.g., Gtk.Application.runAsync()).
-      // In that case, a main loop hook is already registered — no action needed.
-    }
-  }
-
-  return _loop;
-}
-
-/**
- * Quit the MainLoop created by `ensureMainLoop()`. Idempotent, no-op on Node.js.
- *
- * Calling `quit()` on a loop that hasn't started yet pre-quits it — when the
- * `setMainLoopHook` later fires and calls `run()`, it returns immediately.
- * This is used by `@gjsify/unit` to prevent the loop from blocking after tests.
- */
-export function quitMainLoop(): void {
-  if (_loop) {
-    _loop.quit();
-    _started = false;
-    _loop = null;
-  }
-}

package/src/message.ts

@@ -1,11 +0,0 @@
-// See https://github.com/denoland/deno_std/blob/44d05e7a8d445888d989d49eb3e59eee3055f2c5/node/_utils.ts#L21
-export const notImplemented = (msg: string) => {
-    const message = msg ? `Not implemented: ${msg}` : "Not implemented";
-    throw new Error(message);
-}
-
-export const warnNotImplemented = (msg) => {
-    const message = msg ? `Not implemented: ${msg}` : "Not implemented";
-    console.warn(message);
-    return message;
-}

package/src/microtask.ts

@@ -1,4 +0,0 @@
-// Unlike nextTick (GLib.idle_add, lets GTK events interleave), queueMicrotask fires before any GLib source.
-export const queueMicrotask = (fn: () => void): void => {
-  Promise.resolve().then(fn);
-};

package/src/next-tick.spec.ts

@@ -1,116 +0,0 @@
-// Tests for packages/gjs/utils/src/next-tick.ts
-// Regression: nextTick on GJS must route through GLib.idle_add(PRIORITY_HIGH_IDLE)
-// instead of queueMicrotask, so GTK events (PRIORITY_DEFAULT = 0) can interleave
-// between stream operations and prevent window freezes under heavy I/O.
-
-import { describe, it, expect, on } from '@gjsify/unit';
-import { nextTick, __resetBurstStateForTests } from './next-tick.js';
-
-export default async () => {
-  await describe('nextTick', async () => {
-    await it('should execute the callback', async () => {
-      let called = false;
-      await new Promise<void>(resolve => {
-        nextTick(() => { called = true; resolve(); });
-      });
-      expect(called).toBeTruthy();
-    });
-
-    await it('should be deferred — not synchronous', async () => {
-      let ranBeforeReturn = false;
-      let scheduled = false;
-      nextTick(() => { scheduled = true; });
-      // nextTick callback must not have run before this line
-      ranBeforeReturn = scheduled;
-      // Wait for callback
-      await new Promise<void>(resolve => nextTick(resolve));
-      expect(ranBeforeReturn).toBeFalsy();
-      expect(scheduled).toBeTruthy();
-    });
-
-    await it('should pass arguments to the callback', async () => {
-      const result = await new Promise<string>(resolve => {
-        nextTick((a: string, b: string) => resolve(a + b), 'hello', ' world');
-      });
-      expect(result).toBe('hello world');
-    });
-
-    await it('should run callbacks in scheduling order', async () => {
-      const order: number[] = [];
-      await new Promise<void>(resolve => {
-        nextTick(() => order.push(1));
-        nextTick(() => order.push(2));
-        nextTick(() => { order.push(3); resolve(); });
-      });
-      // Additional tick so all three have fired
-      await new Promise<void>(resolve => nextTick(resolve));
-      expect(order[0]).toBe(1);
-      expect(order[1]).toBe(2);
-      expect(order[2]).toBe(3);
-    });
-
-    // GJS-specific: nextTick must use GLib.idle_add so that GLib I/O callbacks
-    // (PRIORITY_DEFAULT = 0) can fire between nextTick callbacks (PRIORITY_HIGH_IDLE = 100).
-    // We verify that a resolved Promise (microtask, highest priority) fires before
-    // a nextTick, whereas a GLib.idle_add at PRIORITY_DEFAULT fires before one at PRIORITY_HIGH_IDLE.
-    await on('Gjs', async () => {
-      await it('GJS: nextTick does not block GLib I/O callbacks (priority ordering)', async () => {
-        // A Promise.resolve microtask fires before any GLib idle (same GLib dispatch).
-        // A nextTick (GLib idle 100) must not block a higher-priority GLib source (priority 0).
-        // We test indirectly: schedule two nextTick callbacks and one via Promise.resolve().
-        // The Promise.resolve microtask runs within the current GLib dispatch (before the idle).
-        const order: string[] = [];
-        await new Promise<void>(resolve => {
-          // Schedule nextTick (GLib idle priority 100 on GJS)
-          nextTick(() => { order.push('tick'); resolve(); });
-          // Schedule a microtask (Promise.resolve runs in current dispatch, before idle)
-          Promise.resolve().then(() => order.push('microtask'));
-        });
-        // On GJS: microtask fires before GLib idle, so 'microtask' comes first
-        // On Node.js: nextTick fires before Promise.resolve microtasks by spec
-        expect(order).toContain('tick');
-        expect(order).toContain('microtask');
-      });
-
-      // Burst-yield behavior. When hundreds of nextTicks fire in a tight
-      // loop (webtorrent DHT bootstrap, streamx pipe bursts, …) GLib
-      // dispatches the whole batch at PRIORITY_DEFAULT before coming back
-      // to collect GTK input events — the window appears frozen. After
-      // BURST_YIELD_THRESHOLD consecutive calls within BURST_IDLE_MS, the
-      // scheduler switches to delay=1ms timeouts, forcing a main-loop
-      // iteration between bursts so GTK events can drain. Normal,
-      // non-bursty code pays zero latency because the counter resets on
-      // any gap > BURST_IDLE_MS.
-      await it('GJS: a tight burst of 256 nextTicks still completes', async () => {
-        __resetBurstStateForTests();
-        let fired = 0;
-        const target = 256;
-        await new Promise<void>(resolve => {
-          for (let i = 0; i < target; i++) {
-            nextTick(() => {
-              fired++;
-              if (fired === target) resolve();
-            });
-          }
-        });
-        expect(fired).toBe(target);
-      });
-
-      await it('GJS: order is preserved inside and across bursts', async () => {
-        __resetBurstStateForTests();
-        const order: number[] = [];
-        const target = 128;
-        await new Promise<void>(resolve => {
-          for (let i = 0; i < target; i++) {
-            nextTick(() => {
-              order.push(i);
-              if (order.length === target) resolve();
-            });
-          }
-        });
-        // FIFO across the whole burst, including the yield points.
-        for (let i = 0; i < target; i++) expect(order[i]).toBe(i);
-      });
-    });
-  });
-};

package/src/next-tick.ts

@@ -1,112 +0,0 @@
-// Microtask scheduling utility for GJS
-// Shared by @gjsify/stream, @gjsify/web-streams, and other packages
-// Matches Node.js process.nextTick semantics with cross-platform fallbacks
-
-declare const queueMicrotask: ((cb: () => void) => void) | undefined;
-
-// Burst-yield scheduler. GTK input events (move, click, scroll) are dispatched
-// from GLib's main context at PRIORITY_DEFAULT (0). Historically every nextTick
-// became its own GLib.timeout_add(PRIORITY_DEFAULT, 0) source — ready
-// immediately. When user code (webtorrent DHT bootstrap, streamx pipe bursts)
-// scheduled hundreds of nextTicks in a tight loop, GLib dispatched the whole
-// batch before cycling back to collect GTK input events, freezing the window.
-//
-// Instead, we maintain a FIFO queue owned by this module:
-//   • nextTick(cb) pushes onto _queue
-//   • A single GLib.timeout_add(PRIORITY_DEFAULT, 0) drains up to CHUNK_SIZE
-//     callbacks per iteration
-//   • If more remain, the drainer re-arms with delay=1ms — forcing at least
-//     one main-loop iteration before continuing, so GTK events that arrived
-//     during the chunk get dispatched
-//   • When _queue empties, the drainer goes idle (zero ambient cost)
-//
-// Guarantees:
-//   • FIFO: single shared queue + single drainer preserves call order
-//   • Throughput: short bursts under CHUNK_SIZE drain with zero added latency
-//   • Responsiveness: longer bursts cost at most 1ms per CHUNK_SIZE callbacks
-//     of added latency, in exchange for GTK input dispatch
-//   • GC safety: one timeout source lives while _queue is non-empty; no
-//     per-call BoxedInstance retention
-const CHUNK_SIZE = 64;
-const YIELD_DELAY_MS = 1;
-const _queue: Array<() => void> = [];
-let _drainerArmed = false;
-
-function drainOnce(GLib: any): void {
-  // Process up to CHUNK_SIZE callbacks. Errors don't abort the queue —
-  // Node's process.nextTick guarantees later ticks still run even if an
-  // earlier one throws (the throw is delivered asynchronously via
-  // 'uncaughtException'). We keep the same contract by catching per-cb.
-  const end = Math.min(CHUNK_SIZE, _queue.length);
-  for (let i = 0; i < end; i++) {
-    const cb = _queue.shift()!;
-    try { cb(); }
-    catch (err) {
-      // Surface as an emitted error rather than swallow. In GJS there is no
-      // 'uncaughtException'; fall back to logging on stderr via GLib.
-      try { GLib.log_default_handler('gjsify-nextTick', GLib.LogLevelFlags.LEVEL_WARNING, String((err as any)?.stack || err), null); }
-      catch { /* best-effort */ }
-    }
-  }
-  if (_queue.length > 0) {
-    // More work remains — re-arm with a 1 ms yield so GTK events dispatch.
-    GLib.timeout_add(GLib.PRIORITY_DEFAULT, YIELD_DELAY_MS, () => {
-      drainOnce(GLib);
-      return false;
-    });
-  } else {
-    _drainerArmed = false;
-  }
-}
-
-// On GJS, nextTick goes through the GLib main loop instead of the JS
-// microtask queue, so I/O events are interleaved between stream/pipe steps.
-//
-// PRIORITY_DEFAULT (0) is required: GJS 1.86 maintains an internal
-// Promise/microtask-drain source at priority 0 that returns SOURCE_CONTINUE,
-// permanently blocking any source at priority > 0 (including PRIORITY_HIGH_IDLE
-// = 100) from ever dispatching. Using PRIORITY_DEFAULT ensures nextTick
-// callbacks fire within the same GLib dispatch band as I/O events.
-//
-// We use GLib.timeout_add rather than GLib.idle_add: timeout_add returns a
-// numeric source ID (no BoxedInstance, no GC race). GLib.idle_add has the same
-// GC-race hazard as the old GLib.Source BoxedInstance approach fixed in
-// @gjsify/node-globals timers.
-function tryGLibTimeout(cb: () => void): boolean {
-  const GLib = (globalThis as any).imports?.gi?.GLib;
-  if (!GLib?.timeout_add) return false;
-  _queue.push(cb);
-  if (!_drainerArmed) {
-    _drainerArmed = true;
-    GLib.timeout_add(GLib.PRIORITY_DEFAULT, 0, () => {
-      drainOnce(GLib);
-      return false;
-    });
-  }
-  return true;
-}
-
-/** @internal Test helper: reset burst state. */
-export function __resetBurstStateForTests(): void {
-  _queue.length = 0;
-  _drainerArmed = false;
-}
-
-/**
- * Schedule a function on the next turn of the event loop.
- * On GJS: uses GLib.timeout_add(PRIORITY_DEFAULT, delay=0).
- * On Node.js: uses process.nextTick → queueMicrotask → Promise.resolve().then().
- */
-export const nextTick = (fn: (...args: unknown[]) => void, ...args: unknown[]): void => {
-  const cb = args.length > 0 ? () => fn(...args) : fn as () => void;
-  if (tryGLibTimeout(cb)) return;
-  if (typeof globalThis.process?.nextTick === 'function') {
-    globalThis.process.nextTick(fn, ...args);
-    return;
-  }
-  if (typeof queueMicrotask === 'function') {
-    queueMicrotask(cb);
-    return;
-  }
-  Promise.resolve().then(cb);
-};

package/src/path.ts

@@ -1,52 +0,0 @@
-import Gio from '@girs/gio-2.0';
-import GLib from '@girs/glib-2.0';
-const { File } = Gio;
-
-const _getProgramDir = (programFile: Gio.File) => {
-    const info = programFile.query_info('standard::', Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS, null);
-
-    if (info.get_is_symlink()) {
-        const symlinkFile = programFile.get_parent().resolve_relative_path(info.get_symlink_target());
-        return symlinkFile.get_parent();
-    } else {
-        return programFile.get_parent();
-    }
-}
-
-export const resolve = (dir: string, ...filenames: string[]) => {
-    let file = File.new_for_path(dir);
-    for (const filename of filenames) {
-      file = file.resolve_relative_path(filename);
-    }
-    return file;
-}
-
-export const getProgramExe = () => {
-    const currentDir = GLib.get_current_dir();
-    return File.new_for_path(currentDir).resolve_relative_path(imports.system.programInvocationName);
-}
-
-export const getProgramDir = () => {
-    return _getProgramDir(getProgramExe()).get_path();
-}
-
-export const getPathSeparator = () => {
-    const currentDir = GLib.get_current_dir();
-    return /^\//.test(currentDir) ? '/' : '\\';
-}
-
-export const getNodeModulesPath = () => {
-    let dir = File.new_for_path(getProgramDir());
-    let found = false;
-
-    do {
-        dir = dir.resolve_relative_path("..");
-        const nodeModulesDir = dir.resolve_relative_path("node_modules");
-        found = nodeModulesDir.query_exists(null);
-        if (found) {
-            dir = nodeModulesDir;
-        }
-    } while (dir.has_parent(null) && !found)
-
-    return dir;
-}