@gjsify/utils 0.3.13 → 0.3.15

package/lib/esm/base64.js

@@ -1,72 +1,74 @@
+//#region src/base64.ts
 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. */
 function atobPolyfill(str) {
-  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 & 255);
-    }
-  }
-  return result;
+	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 & 255);
+		}
+	}
+	return result;
 }
+/** Encode a binary string to base64. Uses native btoa when available. */
 function btoaPolyfill(str) {
-  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;
+	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). */
 function base64Decode(str) {
-  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 & 255;
-    }
-  }
-  return bytes.subarray(0, pos);
+	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 & 255;
+		}
+	}
+	return bytes.subarray(0, pos);
 }
+/** Encode a Uint8Array to base64 string. */
 function base64Encode(bytes) {
-  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 & 15) << 2 | b2 >> 6] : "=";
-    result += i + 2 < len ? B64_CHARS[b2 & 63] : "=";
-  }
-  return result;
+	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 & 15) << 2 | b2 >> 6] : "=";
+		result += i + 2 < len ? B64_CHARS[b2 & 63] : "=";
+	}
+	return result;
 }
-export {
-  atobPolyfill,
-  base64Decode,
-  base64Encode,
-  btoaPolyfill
-};
+
+//#endregion
+export { atobPolyfill, base64Decode, base64Encode, btoaPolyfill };

package/lib/esm/byte-array.js

@@ -1,6 +1,12 @@
+//#region src/byte-array.ts
+/**
+* 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.
+*/
 function gbytesToUint8Array(bytes) {
-  return imports.byteArray.fromGBytes(bytes);
+	return imports.byteArray.fromGBytes(bytes);
 }
-export {
-  gbytesToUint8Array
-};
+
+//#endregion
+export { gbytesToUint8Array };

package/lib/esm/callable.js

@@ -1,15 +1,25 @@
+//#region src/callable.ts
+/**
+* Wrap an ES6 class so it supports both the modern `new Cls(...)` pattern and
+* the legacy `Cls.call(thisArg, ...)` pattern.
+*
+* The `apply` trap materialises a temporary instance via `Reflect.construct`
+* (so field initializers and constructor bodies run normally), then transplants
+* its own property descriptors onto `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.
+*/
 function makeCallable(Cls) {
-  return new Proxy(Cls, {
-    apply(target, thisArg, args) {
-      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;
-    }
-  });
+	return new Proxy(Cls, { apply(target, thisArg, args) {
+		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;
+	} });
 }
-export {
-  makeCallable
-};
+
+//#endregion
+export { makeCallable };

package/lib/esm/cli.js

@@ -1,10 +1,12 @@
 import GLib from "@girs/glib-2.0";
+
+//#region src/cli.ts
 const byteArray = imports.byteArray;
 const cli = (commandLine) => {
-  const [res, out, err, status] = GLib.spawn_command_line_sync(commandLine);
-  if (err.byteLength) throw new Error(byteArray.toString(err));
-  return byteArray.toString(out);
-};
-export {
-  cli
+	const [res, out, err, status] = GLib.spawn_command_line_sync(commandLine);
+	if (err.byteLength) throw new Error(byteArray.toString(err));
+	return byteArray.toString(out);
 };
+
+//#endregion
+export { cli };

package/lib/esm/defer.js

@@ -1,6 +1,11 @@
+//#region src/defer.ts
+/**
+* Defer an event emission to the next macrotask, matching Node.js behavior
+* for server 'listening', 'close', and 'error' events.
+*/
 function deferEmit(emitter, event, ...args) {
-  setTimeout(() => emitter.emit(event, ...args), 0);
+	setTimeout(() => emitter.emit(event, ...args), 0);
 }
-export {
-  deferEmit
-};
+
+//#endregion
+export { deferEmit };

package/lib/esm/encoding.js

@@ -1,35 +1,44 @@
-const VALID_ENCODINGS = ["utf8", "ascii", "latin1", "binary", "base64", "base64url", "hex", "ucs2", "utf16le"];
+//#region src/encoding.ts
+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.
+*/
 function normalizeEncoding(enc) {
-  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";
-  }
+	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.
+*/
 function checkEncoding(encoding) {
-  const lower = ("" + encoding).toLowerCase().replace(/-/g, "");
-  if (!VALID_ENCODINGS.includes(lower)) {
-    throw new TypeError(`Unknown encoding: ${encoding}`);
-  }
+	const lower = ("" + encoding).toLowerCase().replace(/-/g, "");
+	if (!VALID_ENCODINGS.includes(lower)) {
+		throw new TypeError(`Unknown encoding: ${encoding}`);
+	}
 }
-export {
-  checkEncoding,
-  normalizeEncoding
-};
+
+//#endregion
+export { checkEncoding, normalizeEncoding };

package/lib/esm/error.js

@@ -1,21 +1,32 @@
+//#region src/error.ts
+/**
+* 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
+*/
 const initErrorV8Methods = (ErrorConstructor) => {
-  if (!Error.captureStackTrace) {
-    Error.captureStackTrace = function(targetObject, constructorOpt) {
-      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;
-        }
-      });
-    };
-  }
-};
-export {
-  initErrorV8Methods
+	if (!Error.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.captureStackTrace = function(targetObject, constructorOpt) {
+			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;
+				}
+			});
+		};
+	}
 };
+
+//#endregion
+export { initErrorV8Methods };

package/lib/esm/file.js

@@ -1,13 +1,15 @@
 import GLib from "@girs/glib-2.0";
+
+//#region src/file.ts
 const byteArray = imports.byteArray;
 const readJSON = (path) => {
-  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}"`);
-};
-export {
-  readJSON
+	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}"`);
 };
+
+//#endregion
+export { readJSON };

package/lib/esm/fs.js

@@ -1,22 +1,24 @@
 import Gio from "@girs/gio-2.0";
 import GioUnix from "@girs/giounix-2.0";
+
+//#region src/fs.ts
+/** Check if a file descriptor exists */
 const existsFD = (fd) => {
-  try {
-    let stream = GioUnix.InputStream.new(fd, false);
-    stream.close(null);
-    return true;
-  } catch (error) {
-    return false;
-  }
+	try {
+		let stream = GioUnix.InputStream.new(fd, false);
+		stream.close(null);
+		return true;
+	} catch (error) {
+		return false;
+	}
 };
 function existsSync(path) {
-  if (typeof path !== "string" || path === "") {
-    return false;
-  }
-  const file = Gio.File.new_for_path(path);
-  return file.query_exists(null);
+	if (typeof path !== "string" || path === "") {
+		return false;
+	}
+	const file = Gio.File.new_for_path(path);
+	return file.query_exists(null);
 }
-export {
-  existsFD,
-  existsSync
-};
+
+//#endregion
+export { existsFD, existsSync };