@gjsify/utils 0.0.2

package/lib/cjs/process.js

@@ -0,0 +1,70 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var process_exports = {};
+__export(process_exports, {
+  getLocale: () => getLocale,
+  getPid: () => getPid,
+  getPpid: () => getPpid,
+  getTitle: () => getTitle
+});
+module.exports = __toCommonJS(process_exports);
+var import_gio_2 = __toESM(require("@girs/gio-2.0"), 1);
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+let PID = 0;
+let PPID = 0;
+let LOCALE = "";
+const getLocale = () => {
+  if (!LOCALE) {
+    LOCALE = import_glib_2.default.getenv("LANG").split(".")[0].replace("_", "-");
+  }
+  return LOCALE;
+};
+const getPid = () => {
+  if (!PID) {
+    PID = new import_gio_2.default.Credentials().get_unix_pid();
+  }
+  return PID;
+};
+const getPpid = () => {
+  if (!PPID) {
+    const path = `/proc/${getPid()}/status`;
+    const file = import_gio_2.default.File.new_for_path(path);
+    const [success, contents] = file.load_contents(null);
+    if (success) {
+      const contentStr = new TextDecoder().decode(contents);
+      const numStr = contentStr.match(/^PPid:.*$/gm)[0]?.match(/(\d+)$/gm)[0];
+      PPID = Number(numStr);
+    } else {
+      console.error(new Error("Failed to read file: " + path));
+    }
+  }
+  return PPID;
+};
+const getTitle = () => {
+  return import_glib_2.default.get_prgname();
+};

package/lib/cjs/system.js

@@ -0,0 +1,77 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var system_exports = {};
+__export(system_exports, {
+  getArgs: () => getArgs,
+  getArgv: () => getArgv,
+  parseArgv: () => parseArgv
+});
+module.exports = __toCommonJS(system_exports);
+var import_glib_2 = __toESM(require("@girs/glib-2.0"), 1);
+var import_gio_2 = __toESM(require("@girs/gio-2.0"), 1);
+var import_fs = require("./fs.js");
+const import_meta = {};
+const File = import_gio_2.default.File;
+const args = [];
+const getArgv = () => {
+  if (args.length) {
+    return args;
+  }
+  const [__filename] = import_glib_2.default.filename_from_uri(import_meta.url);
+  args.push(__filename);
+  ARGV.forEach((arg) => {
+    if (arg[0] !== "-") {
+      args.push(
+        (0, import_fs.existsSync)(arg) ? File.new_for_path(arg).get_path() : arg
+      );
+    } else {
+      args.push(arg);
+    }
+  });
+  return args;
+};
+const getArgs = () => {
+  return getArgv().slice(2);
+};
+const parseArgv = (argv) => {
+  let result = {};
+  let currentKey = null;
+  for (let i = 0; i < argv.length; i++) {
+    let arg = argv[i];
+    if (arg.startsWith("--")) {
+      currentKey = arg.substring(2);
+      result[currentKey] = true;
+    } else if (currentKey !== null) {
+      result[currentKey] = arg;
+      currentKey = null;
+    } else {
+      result[arg] = true;
+    }
+  }
+  return result;
+};

package/lib/cjs/tty.js

@@ -0,0 +1,32 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tty_exports = {};
+__export(tty_exports, {
+  STDERR_FD: () => STDERR_FD,
+  STDIN_FD: () => STDIN_FD,
+  STDOUT_FD: () => STDOUT_FD,
+  existsTty: () => existsTty
+});
+module.exports = __toCommonJS(tty_exports);
+var import_fs = require("./fs.js");
+const STDIN_FD = 0;
+const STDOUT_FD = 1;
+const STDERR_FD = 2;
+const existsTty = () => {
+  return (0, import_fs.existsFD)(STDOUT_FD);
+};

package/lib/cjs/types/cancel-signals.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cancel_signals_exports = {};
+module.exports = __toCommonJS(cancel_signals_exports);

package/lib/cjs/types/error-data.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_data_exports = {};
+module.exports = __toCommonJS(error_data_exports);

package/lib/cjs/types/index.js

@@ -0,0 +1,24 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./cancel-signals.js"), module.exports);
+__reExport(types_exports, require("./error-data.js"), module.exports);
+__reExport(types_exports, require("./signal-methods.js"), module.exports);
+__reExport(types_exports, require("./stack-trace-frame.js"), module.exports);
+__reExport(types_exports, require("./structured-log-data.js"), module.exports);
+__reExport(types_exports, require("./uncaught-exception-data.js"), module.exports);
+__reExport(types_exports, require("./unhandled-rejection-data.js"), module.exports);
+__reExport(types_exports, require("./user-info.js"), module.exports);

package/lib/cjs/types/signal-methods.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var signal_methods_exports = {};
+module.exports = __toCommonJS(signal_methods_exports);

package/lib/cjs/types/stack-trace-frame.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stack_trace_frame_exports = {};
+module.exports = __toCommonJS(stack_trace_frame_exports);

package/lib/cjs/types/structured-log-data.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var structured_log_data_exports = {};
+module.exports = __toCommonJS(structured_log_data_exports);

package/lib/cjs/types/uncaught-exception-data.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var uncaught_exception_data_exports = {};
+module.exports = __toCommonJS(uncaught_exception_data_exports);

package/lib/cjs/types/unhandled-rejection-data.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unhandled_rejection_data_exports = {};
+module.exports = __toCommonJS(unhandled_rejection_data_exports);

package/lib/cjs/types/user-info.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var user_info_exports = {};
+module.exports = __toCommonJS(user_info_exports);

package/lib/cjs/version.js

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var version_exports = {};
+__export(version_exports, {
+  getGjsVersion: () => getGjsVersion
+});
+module.exports = __toCommonJS(version_exports);
+const getGjsVersion = () => {
+  const v = imports.system.version.toString();
+  return `${v[0]}.${+(v[1] + v[2])}.${+(v[3] + v[4])}`;
+};

package/lib/esm/cancel-handler.js

@@ -0,0 +1,22 @@
+let nextRid = 1;
+const resources = {};
+const createCancelHandler = () => {
+  const rid = nextRid++;
+  const cancelHandler = {};
+  imports.signals.addSignalMethods(cancelHandler);
+  resources[rid] = cancelHandler;
+  return rid;
+};
+const closeCancelHandler = (rid) => {
+  const cancelHandler = getCancelHandler(rid);
+  cancelHandler?.emit("close");
+  delete resources[rid];
+};
+const getCancelHandler = (rid) => {
+  return resources[rid];
+};
+export {
+  closeCancelHandler,
+  createCancelHandler,
+  getCancelHandler
+};

package/lib/esm/cli.js

@@ -0,0 +1,11 @@
+import GLib from "@girs/glib-2.0";
+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
+};

package/lib/esm/error.js

@@ -0,0 +1,21 @@
+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
+};

package/lib/esm/file.js

@@ -0,0 +1,13 @@
+import GLib from "@girs/glib-2.0";
+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
+};

package/lib/esm/fs.js

@@ -0,0 +1,21 @@
+import Gio from "@girs/gio-2.0";
+const existsFD = (fd) => {
+  try {
+    let stream = Gio.UnixInputStream.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);
+}
+export {
+  existsFD,
+  existsSync
+};

package/lib/esm/index.js

@@ -0,0 +1,14 @@
+export * from "./types/index.js";
+export * from "./cancel-handler.js";
+export * from "./cli.js";
+export * from "./error.js";
+export * from "./file.js";
+export * from "./fs.js";
+export * from "./log.js";
+export * from "./message.js";
+export * from "./os.js";
+export * from "./path.js";
+export * from "./process.js";
+export * from "./system.js";
+export * from "./tty.js";
+export * from "./version.js";

package/lib/esm/log.js

@@ -0,0 +1,159 @@
+import GLib from "@girs/glib-2.0";
+const logLevelToString = (logLevel) => {
+  switch (logLevel) {
+    case GLib.LogLevelFlags.FLAG_FATAL:
+      return "FLAG_FATAL";
+    case GLib.LogLevelFlags.FLAG_RECURSION:
+      return "FLAG_RECURSION";
+    case GLib.LogLevelFlags.LEVEL_CRITICAL:
+      return "LEVEL_CRITICAL";
+    case GLib.LogLevelFlags.LEVEL_DEBUG:
+      return "LEVEL_DEBUG";
+    case GLib.LogLevelFlags.LEVEL_ERROR:
+      return "LEVEL_ERROR";
+    case GLib.LogLevelFlags.LEVEL_INFO:
+      return "LEVEL_INFO";
+    case GLib.LogLevelFlags.LEVEL_MASK:
+      return "LEVEL_MASK";
+    case GLib.LogLevelFlags.LEVEL_MESSAGE:
+      return "LEVEL_MESSAGE";
+    case GLib.LogLevelFlags.LEVEL_WARNING:
+      return "LEVEL_WARNING";
+    default:
+      return "UNKNOWN";
+  }
+};
+const STACK_TRACE_REGEX = /^.*@(.*):(\d+):(\d+)/;
+const parseStackTrace = (stackTraceLine) => {
+  const match = stackTraceLine.match(STACK_TRACE_REGEX);
+  if (match) {
+    const [, fileName, lineNumber, columnNumber] = match;
+    return { fileName, lineNumber: Number(lineNumber), columnNumber: Number(columnNumber), line: stackTraceLine };
+  }
+  return null;
+};
+const getStackTraceStartLineIndex = (lines) => {
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (STACK_TRACE_REGEX.test(line)) {
+      return i;
+    }
+  }
+  return -1;
+};
+const extractErrorData = (errorMessage) => {
+  const lines = errorMessage.split("\n");
+  for (let line of lines) {
+    line = line.trim();
+  }
+  const endOfErrorType = lines[0].indexOf(": ");
+  let errorType = "Error";
+  if (endOfErrorType > 0) {
+    errorType = lines[0].slice(0, endOfErrorType);
+    if (globalThis[errorType]) {
+      lines[0] = lines[0].slice(endOfErrorType + 2);
+    } else {
+      errorType = "Error";
+    }
+  }
+  let stackTraceLineIndex = getStackTraceStartLineIndex(lines);
+  const message = lines.slice(0, stackTraceLineIndex).join("\n");
+  const stackTraceLines = lines.slice(stackTraceLineIndex);
+  const frames = [];
+  for (const stackTraceLine of stackTraceLines) {
+    const frame = parseStackTrace(stackTraceLine);
+    if (frame) {
+      frames.push(frame);
+    }
+  }
+  return {
+    errorType,
+    message,
+    frames,
+    stackTraceLines
+  };
+};
+const reconstructErrorFromMessage = (errorMessage) => {
+  const { errorType, frames, message, stackTraceLines } = extractErrorData(errorMessage);
+  const ErrorType = globalThis[errorType];
+  const error = new ErrorType();
+  error.message = message;
+  error.stack = stackTraceLines.join("\n");
+  return {
+    error,
+    errorType,
+    frames,
+    message,
+    stackTraceLines
+  };
+};
+class LogSignals {
+  static instance;
+  /** This is a singleton because log_set_writer_func may only be called once */
+  constructor() {
+    this.initHandler();
+  }
+  static getSingleton() {
+    if (LogSignals.instance) {
+      return LogSignals.instance;
+    }
+    LogSignals.instance = new LogSignals();
+    return LogSignals.instance;
+  }
+  initHandler() {
+    GLib.log_set_writer_func((level, fields) => {
+      const decoder = new TextDecoder("utf-8");
+      const message = decoder.decode(fields?.MESSAGE);
+      const priority = Number(decoder.decode(fields?.PRIORITY));
+      const domain = decoder.decode(fields?.GLIB_DOMAIN);
+      const data = {
+        message,
+        priority,
+        domain
+      };
+      if (!this.handler(level, data)) {
+        level |= GLib.LogLevelFlags.FLAG_RECURSION;
+        GLib.log_default_handler(domain, level, message, null);
+      }
+      return GLib.LogWriterOutput.HANDLED;
+    });
+  }
+  /**
+   * A log handler to emit `unhandledRejection` and `uncaughtException` events
+   * @param level The log level
+   * @param data The structured log data
+   * @returns `true` to catch the log or `false` to output the error to the console as usual
+    */
+  handler(level, structuredData) {
+    if (level === GLib.LogLevelFlags.LEVEL_WARNING && structuredData.domain === "Gjs" && structuredData.message.startsWith("Unhandled promise rejection")) {
+      try {
+        const errorData = reconstructErrorFromMessage(structuredData.message);
+        const fakePromise = new Promise(() => {
+        });
+        logSignals.emit("unhandledRejection", structuredData, {
+          reason: errorData.error,
+          promise: fakePromise,
+          errorType: errorData.errorType,
+          frames: errorData.frames,
+          message: errorData.message,
+          stackTraceLines: errorData.stackTraceLines
+        });
+      } catch (error) {
+        printerr(error);
+      }
+    } else if (level === GLib.LogLevelFlags.LEVEL_CRITICAL) {
+      const errorData = reconstructErrorFromMessage(structuredData.message);
+      logSignals.emit("uncaughtException", structuredData, errorData);
+    }
+    return false;
+  }
+}
+imports.signals.addSignalMethods(LogSignals.prototype);
+const logSignals = LogSignals.getSingleton();
+export {
+  LogSignals,
+  extractErrorData,
+  logLevelToString,
+  logSignals,
+  parseStackTrace
+};

package/lib/esm/message.js

@@ -0,0 +1,13 @@
+const notImplemented = (msg) => {
+  const message = msg ? `Not implemented: ${msg}` : "Not implemented";
+  throw new Error(message);
+};
+const warnNotImplemented = (msg) => {
+  const message = msg ? `Not implemented: ${msg}` : "Not implemented";
+  console.warn(message);
+  return message;
+};
+export {
+  notImplemented,
+  warnNotImplemented
+};