@gjsify/utils 0.4.0 → 0.4.3

package/package.json

@@ -1,44 +1,47 @@
 {
-  "name": "@gjsify/utils",
-  "version": "0.4.0",
-  "description": "Utils module for gjsify",
-  "module": "lib/esm/index.js",
-  "types": "lib/types/index.d.ts",
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./lib/types/index.d.ts",
-      "default": "./lib/esm/index.js"
+    "name": "@gjsify/utils",
+    "version": "0.4.3",
+    "description": "Utils module for gjsify",
+    "module": "lib/esm/index.js",
+    "types": "lib/types/index.d.ts",
+    "files": [
+        "lib"
+    ],
+    "type": "module",
+    "exports": {
+        ".": {
+            "types": "./lib/types/index.d.ts",
+            "default": "./lib/esm/index.js"
+        },
+        "./main-loop": {
+            "types": "./lib/types/main-loop.d.ts",
+            "default": "./lib/esm/main-loop.js"
+        }
     },
-    "./main-loop": {
-      "types": "./lib/types/main-loop.d.ts",
-      "default": "./lib/esm/main-loop.js"
+    "scripts": {
+        "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+        "check": "tsc --noEmit",
+        "build": "gjsify run build:gjsify && gjsify run build:types",
+        "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+        "build:types": "tsc",
+        "build:test": "gjsify run build:test:gjs",
+        "build:test:gjs": "gjsify build src/test.ts --app gjs --outfile test.gjs.js",
+        "test": "gjsify run build:gjsify && gjsify run build:test && gjsify run test:gjs",
+        "test:gjs": "gjsify run test.gjs.js"
+    },
+    "keywords": [
+        "gjs",
+        "node",
+        "fs"
+    ],
+    "devDependencies": {
+        "@gjsify/cli": "workspace:^",
+        "typescript": "^6.0.3"
+    },
+    "dependencies": {
+        "@girs/gio-2.0": "2.88.0-4.0.0-rc.15",
+        "@girs/giounix-2.0": "2.0.0-4.0.0-rc.15",
+        "@girs/gjs": "4.0.0-rc.15",
+        "@girs/glib-2.0": "2.88.0-4.0.0-rc.15"
     }
-  },
-  "scripts": {
-    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
-    "check": "tsc --noEmit",
-    "build": "yarn build:gjsify && yarn build:types",
-    "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
-    "build:types": "tsc",
-    "build:test": "yarn build:test:gjs",
-    "build:test:gjs": "gjsify build src/test.ts --app gjs --outfile test.gjs.js",
-    "test": "yarn build:gjsify && yarn build:test && yarn test:gjs",
-    "test:gjs": "gjsify run test.gjs.js"
-  },
-  "keywords": [
-    "gjs",
-    "node",
-    "fs"
-  ],
-  "devDependencies": {
-    "@gjsify/cli": "^0.4.0",
-    "typescript": "^6.0.3"
-  },
-  "dependencies": {
-    "@girs/gio-2.0": "2.88.0-4.0.0-rc.15",
-    "@girs/giounix-2.0": "2.0.0-4.0.0-rc.15",
-    "@girs/gjs": "4.0.0-rc.15",
-    "@girs/glib-2.0": "2.88.0-4.0.0-rc.15"
-  }
-}
+}

package/src/base64.ts

@@ -1,78 +0,0 @@
-// Base64 encoding/decoding utilities for GJS
-// Shared by @gjsify/buffer and @gjsify/string_decoder
-// Reference: RFC 4648
-
-const B64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const B64_LOOKUP = new Uint8Array(256);
-for (let i = 0; i < B64_CHARS.length; i++) B64_LOOKUP[B64_CHARS.charCodeAt(i)] = i;
-
-/** Decode a base64 string to a binary string. Uses native atob when available. */
-export function atobPolyfill(str: string): string {
-  if (typeof globalThis.atob === 'function') return globalThis.atob(str);
-  const cleaned = str.replace(/[=\s]/g, '');
-  let result = '';
-  let bits = 0;
-  let collected = 0;
-  for (let i = 0; i < cleaned.length; i++) {
-    bits = (bits << 6) | B64_LOOKUP[cleaned.charCodeAt(i)];
-    collected += 6;
-    if (collected >= 8) {
-      collected -= 8;
-      result += String.fromCharCode((bits >> collected) & 0xff);
-    }
-  }
-  return result;
-}
-
-/** Encode a binary string to base64. Uses native btoa when available. */
-export function btoaPolyfill(str: string): string {
-  if (typeof globalThis.btoa === 'function') return globalThis.btoa(str);
-  let result = '';
-  let i = 0;
-  for (; i + 2 < str.length; i += 3) {
-    const n = (str.charCodeAt(i) << 16) | (str.charCodeAt(i + 1) << 8) | str.charCodeAt(i + 2);
-    result += B64_CHARS[(n >> 18) & 63] + B64_CHARS[(n >> 12) & 63] + B64_CHARS[(n >> 6) & 63] + B64_CHARS[n & 63];
-  }
-  if (i + 1 === str.length) {
-    const n = str.charCodeAt(i) << 16;
-    result += B64_CHARS[(n >> 18) & 63] + B64_CHARS[(n >> 12) & 63] + '==';
-  } else if (i + 2 === str.length) {
-    const n = (str.charCodeAt(i) << 16) | (str.charCodeAt(i + 1) << 8);
-    result += B64_CHARS[(n >> 18) & 63] + B64_CHARS[(n >> 12) & 63] + B64_CHARS[(n >> 6) & 63] + '=';
-  }
-  return result;
-}
-
-/** Decode a base64 string directly to Uint8Array (avoids lossy atob string round-trip). */
-export function base64Decode(str: string): Uint8Array {
-  const cleaned = str.replace(/[=\s]/g, '');
-  const bytes = new Uint8Array((cleaned.length * 3) >> 2);
-  let bits = 0;
-  let collected = 0;
-  let pos = 0;
-  for (let i = 0; i < cleaned.length; i++) {
-    bits = (bits << 6) | B64_LOOKUP[cleaned.charCodeAt(i)];
-    collected += 6;
-    if (collected >= 8) {
-      collected -= 8;
-      bytes[pos++] = (bits >> collected) & 0xff;
-    }
-  }
-  return bytes.subarray(0, pos);
-}
-
-/** Encode a Uint8Array to base64 string. */
-export function base64Encode(bytes: Uint8Array): string {
-  let result = '';
-  const len = bytes.length;
-  for (let i = 0; i < len; i += 3) {
-    const b0 = bytes[i];
-    const b1 = i + 1 < len ? bytes[i + 1] : 0;
-    const b2 = i + 2 < len ? bytes[i + 2] : 0;
-    result += B64_CHARS[b0 >> 2];
-    result += B64_CHARS[((b0 & 3) << 4) | (b1 >> 4)];
-    result += i + 1 < len ? B64_CHARS[((b1 & 0xf) << 2) | (b2 >> 6)] : '=';
-    result += i + 2 < len ? B64_CHARS[b2 & 0x3f] : '=';
-  }
-  return result;
-}

package/src/byte-array.ts

@@ -1,12 +0,0 @@
-import type GLib from '@girs/glib-2.0';
-
-declare const imports: { byteArray: { fromGBytes(input: GLib.Bytes): Uint8Array } };
-
-/**
- * Convert GLib.Bytes to Uint8Array using GJS's byteArray module.
- * This wraps the GJS-specific `imports.byteArray.fromGBytes()` API
- * with proper typing to eliminate `as any` casts throughout the codebase.
- */
-export function gbytesToUint8Array(bytes: GLib.Bytes): Uint8Array {
-  return imports.byteArray.fromGBytes(bytes);
-}

package/src/callable.ts

@@ -1,63 +0,0 @@
-// Legacy `.call(this)` compatibility shim for ES6 classes.
-//
-// Reference: refs/node/lib/internal/streams/legacy.js (Node core Stream() as a
-//            regular function, deliberately callable via .call()).
-// Reference: refs/readable-stream/lib/internal/streams/legacy.js (same pattern).
-// Implements the legacy callable pattern for our class-based hierarchy so
-// pre-ES2015 CJS consumers can do `Cls.call(this)` + `util.inherits(Sub, Cls)`.
-// Without this shim, packages that do `EventEmitter.call(this)` or
-// `Stream.call(this)` crash with:
-//   TypeError: Class constructor Foo cannot be invoked without 'new'
-//
-// Copyright (c) Node.js contributors. MIT license.
-// Modifications: implemented as a Proxy wrapper for GJSify's ES6 classes.
-
-/**
- * Wrap an ES6 class so it supports both the modern `new Cls(...)` pattern and
- * the legacy `Cls.call(thisArg, ...)` / `Cls(...)` (no-`new`) patterns.
- *
- * The `apply` trap has two modes:
- *
- *  1. **`Cls.call(thisArg, ...)`** — a real consumer instance is provided.
- *     We materialise a temporary instance via `Reflect.construct` (so field
- *     initializers and constructor bodies run normally) and transplant its
- *     own property descriptors onto `thisArg`. This is how Node-era CJS
- *     consumers + `util.inherits(Sub, Cls)` chains expect to subclass our
- *     ES6 classes.
- *
- *  2. **`Cls(...)`** (called as a plain function — `thisArg` is `undefined`
- *     in strict mode or `globalThis` in sloppy mode) — we treat the call as
- *     a constructor call and return a fresh `new Cls(...)`. Node's stream
- *     constructors implement this guard explicitly:
- *       `if (!(this instanceof PassThrough)) return new PassThrough(...)`
- *     so consumers like `merge2` invoke `Stream.PassThrough(opts)` without
- *     `new` and rely on the result being a real instance. Without this
- *     branch the apply trap would crash with "undefined is not a non-null
- *     object" when it tried to `Object.defineProperty(thisArg, …)`.
- *
- * The default Proxy traps pass `construct`, `get` and `getPrototypeOf`
- * straight through, so `new Wrapped()`, `Wrapped.prototype` (consulted by
- * `util.inherits`) and `instance instanceof Wrapped` all behave identically
- * to the underlying class.
- */
-export function makeCallable<T extends new (...args: any[]) => any>(Cls: T): T {
-    return new Proxy(Cls, {
-        apply(target, thisArg: object | undefined | null, args: any[]) {
-            // No-`new` invocation (`Cls(...)`): no usable receiver to mutate
-            // — return a freshly constructed instance instead. globalThis is
-            // also treated as "no receiver" because that is what a sloppy-
-            // mode plain function call surfaces.
-            if (thisArg == null || thisArg === globalThis) {
-                return Reflect.construct(target, args, target);
-            }
-            // `Cls.call(thisArg, ...)`: transplant a fresh instance's own
-            // properties onto the caller-supplied receiver.
-            const tmp = Reflect.construct(target, args, target);
-            for (const key of Reflect.ownKeys(tmp)) {
-                const desc = Object.getOwnPropertyDescriptor(tmp, key);
-                if (desc) Object.defineProperty(thisArg, key, desc);
-            }
-            return thisArg;
-        },
-    });
-}

package/src/cli.ts

@@ -1,10 +0,0 @@
-import GLib from '@girs/glib-2.0';
-const byteArray = imports.byteArray;
-
-export const cli = (commandLine: string): string => {
-    const [res, out, err, status] = GLib.spawn_command_line_sync(commandLine);
-  
-    if(err.byteLength) throw new Error(byteArray.toString(err));
-  
-    return byteArray.toString(out);
-};

package/src/defer.ts

@@ -1,11 +0,0 @@
-/**
- * Defer an event emission to the next macrotask, matching Node.js behavior
- * for server 'listening', 'close', and 'error' events.
- */
-export function deferEmit(
-  emitter: { emit(event: string | symbol, ...args: unknown[]): boolean },
-  event: string,
-  ...args: unknown[]
-): void {
-  setTimeout(() => emitter.emit(event, ...args), 0);
-}

package/src/encoding.ts

@@ -1,36 +0,0 @@
-// Shared encoding normalization utilities.
-// Used by buffer, string_decoder, crypto, and other packages that deal with encodings.
-
-/** Canonical encoding names (matches BufferEncoding from @types/node). */
-export type Encoding = 'utf8' | 'ascii' | 'latin1' | 'base64' | 'base64url' | 'hex' | 'utf16le' | 'binary' | 'ucs2' | 'ucs-2' | 'utf-8';
-
-const VALID_ENCODINGS = ['utf8', 'ascii', 'latin1', 'binary', 'base64', 'base64url', 'hex', 'ucs2', 'utf16le'];
-
-/**
- * Normalize an encoding string to a canonical encoding value.
- * Returns 'utf8' as default for undefined/null/empty input.
- */
-export function normalizeEncoding(enc?: string): Encoding {
-  if (!enc || enc === 'utf8' || enc === 'utf-8') return 'utf8';
-  const lower = ('' + enc).toLowerCase().replace(/-/g, '');
-  switch (lower) {
-    case 'utf8': return 'utf8';
-    case 'ascii': return 'ascii';
-    case 'latin1': case 'binary': return 'latin1';
-    case 'base64': return 'base64';
-    case 'base64url': return 'base64url';
-    case 'hex': return 'hex';
-    case 'ucs2': case 'utf16le': return 'utf16le';
-    default: return 'utf8';
-  }
-}
-
-/**
- * Check that an encoding string is valid. Throws TypeError if not.
- */
-export function checkEncoding(encoding: string): void {
-  const lower = ('' + encoding).toLowerCase().replace(/-/g, '');
-  if (!VALID_ENCODINGS.includes(lower)) {
-    throw new TypeError(`Unknown encoding: ${encoding}`);
-  }
-}

package/src/error.ts

@@ -1,38 +0,0 @@
-/**
- * Defines the static Error.captureStackTrace method,
- * this is not present in SpiderMonkey because it comes from V8
- * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#static_methods
- * @see https://nodejs.org/dist/latest-v18.x/docs/api/errors.html#errorcapturestacktracetargetobject-constructoropt
- */
-export const initErrorV8Methods = (ErrorConstructor: typeof Error) => {
-    // See https://nodejs.org/dist/latest-v18.x/docs/api/errors.html#errorcapturestacktracetargetobject-constructoropt
-    if (!(Error as any).captureStackTrace) {
-        /**
-         * A non-standard V8 function.
-         * Creates a .stack property on targetObject, which when accessed returns a string representing the location in the code at which Error.captureStackTrace() was called.
-         * @param targetObject 
-         * @param constructorOpt 
-         */
-        (Error as any).captureStackTrace = function(targetObject: object, constructorOpt?: Function) {
-            const container = new Error();
-
-            const target = constructorOpt || targetObject;
-
-            Object.defineProperty(target, 'stack', {
-                configurable: true,
-                get: function getStack() {
-                    var stack = container.stack;
-        
-                    Object.defineProperty(this, 'stack', {
-                        value: stack
-                    });
-        
-                    return stack;
-                }
-            });
-        }
-    }
-
-    // TODO Error.stackTraceLimit()
-    // TODO Error.prepareStackTrace()
-}

package/src/file.ts

@@ -1,12 +0,0 @@
-import GLib from '@girs/glib-2.0';
-
-const byteArray = imports.byteArray;
-
-export const readJSON = (path: string) => {
-  const [ok, contents] = GLib.file_get_contents(path);
-  if (ok) {
-    const map = JSON.parse(byteArray.toString(contents));
-    return map;
-  }
-  throw new Error(`Error on require "${path}"`);
-}

package/src/fs.ts

@@ -1,24 +0,0 @@
-import Gio from '@girs/gio-2.0';
-import GioUnix from '@girs/giounix-2.0';
-/** Check if a file descriptor exists */
-export const existsFD = (fd: number) => {
-    try {
-        let stream = GioUnix.InputStream.new(fd, false);
-        stream.close(null);
-        // File descriptor 12345 exists
-        return true
-    } catch (error) {
-        // File descriptor 12345 does not exist
-        return false
-    }
-}
-
-export function existsSync(path: string) {
-    // TODO: accept buffer and URL too
-    if (typeof path !== 'string' || path === '') {
-        return false;
-    }
-
-    const file = Gio.File.new_for_path(path);
-    return file.query_exists(null);
-}

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)
-        // })
-	});
-}