@gjsify/utils 0.0.2

package/src/fs.ts

@@ -0,0 +1,24 @@
+import Gio from '@girs/gio-2.0';
+
+/** Check if a file descriptor exists */
+export const existsFD = (fd: number) => {
+    try {
+        let stream = Gio.UnixInputStream.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/index.ts

@@ -0,0 +1,15 @@
+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/src/log.spec.ts

@@ -0,0 +1,32 @@
+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/log.ts

@@ -0,0 +1,218 @@
+import GLib from '@girs/glib-2.0';
+
+import type {
+  StructuredLogData,
+  SignalMethods,
+  StackTraceFrame,
+  ErrorData,
+  UncaughtExceptionData,
+  UnhandledRejectionData,
+} from './types/index.js';
+
+export const logLevelToString = (logLevel: GLib.LogLevelFlags) => {
+  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+)/;
+
+export const parseStackTrace = (stackTraceLine: string): StackTraceFrame | null => {
+  const match = stackTraceLine.match(STACK_TRACE_REGEX);
+  if (match) {
+    const [, fileName, lineNumber, columnNumber] = match;
+    return { fileName, lineNumber: Number(lineNumber), columnNumber: Number(columnNumber), line: stackTraceLine };
+  }
+  // console.warn("Can't parse stack trace line: " + stackTraceLine);
+  return null;
+}
+
+const getStackTraceStartLineIndex = (lines: string[]) => {
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if(STACK_TRACE_REGEX.test(line)) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+export const extractErrorData = (errorMessage: string): ErrorData => {
+  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 error type exists
+    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: StackTraceFrame[] = [];
+
+  for (const stackTraceLine of stackTraceLines) {
+    const frame = parseStackTrace(stackTraceLine);
+    if(frame) {
+      frames.push(frame)
+    }
+  }
+
+  return {
+    errorType,
+    message,
+    frames,
+    stackTraceLines,
+  }
+}
+
+/**
+ * WORKAROUND: Extract the information from the log message until https://gitlab.gnome.org/GNOME/gjs/-/issues/523 is solved
+ * @param errorMessage The original error message
+ * @returns The extracted error type, error message and stack trace
+ */
+const reconstructErrorFromMessage = (errorMessage: string): UncaughtExceptionData => {
+  const { errorType, frames, message, stackTraceLines } = extractErrorData(errorMessage);
+  const ErrorType = globalThis[errorType] as typeof Error;
+  const error = new ErrorType();
+  error.message = message;
+  error.stack = stackTraceLines.join("\n");
+
+  return {
+    error,
+    errorType,
+    frames,
+    message,
+    stackTraceLines,
+  };
+}
+
+export interface LogSignals extends SignalMethods {
+  connect(sigName: "unhandledRejection", callback: (self: LogSignals, structuredData: StructuredLogData, promiseData: UnhandledRejectionData) => void): number;
+  connect(sigName: "uncaughtException", callback: (self: LogSignals, structuredData: StructuredLogData, errorData: UncaughtExceptionData) => void): number;
+
+  emit(sigName: "unhandledRejection", structuredData: StructuredLogData, promiseData: UnhandledRejectionData): void;
+  emit(sigName: "uncaughtException", structuredData: StructuredLogData, errorData: UncaughtExceptionData): void;
+}
+
+export class LogSignals {
+
+  private static instance: LogSignals;
+
+  /** This is a singleton because log_set_writer_func may only be called once */
+  private constructor() {
+    this.initHandler();
+  }
+
+  public static getSingleton() {
+    if(LogSignals.instance) {
+      return LogSignals.instance;
+    }
+    LogSignals.instance = new LogSignals();
+    return LogSignals.instance;
+  }
+
+  private initHandler() {
+
+    // @ts-ignore TODO: override type in ts-for-gir
+    GLib.log_set_writer_func((level: GLib.LogLevelFlags, fields?: { MESSAGE: Uint8Array, PRIORITY: Uint8Array, GLIB_DOMAIN: Uint8Array }) => {
+
+      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: StructuredLogData = {
+        message,
+        priority,
+        domain
+      }
+
+      if (!this.handler(level, data)) {
+        // Output error as usual 
+        level |= GLib.LogLevelFlags.FLAG_RECURSION;
+        GLib.log_default_handler(domain, level, message, null);
+      }
+
+      // @ts-ignore
+      // GLib.log_set_writer_default();
+
+      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: GLib.LogLevelFlags, structuredData: StructuredLogData) {
+    if(level === GLib.LogLevelFlags.LEVEL_WARNING && structuredData.domain === "Gjs" && structuredData.message.startsWith('Unhandled promise rejection')) {
+      try {
+        const errorData = reconstructErrorFromMessage(structuredData.message);
+        // TODO we need a way to get the promise of the unhandled rejection, see https://gitlab.gnome.org/GNOME/gjs/-/issues/523
+        const fakePromise = new Promise<any>(() => {});
+        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);
+    }
+
+    // Debug
+    // print("\n\n[log_set_writer_func] \nmessage:", structuredData.message, "\nlogDomain:", structuredData.domain, `\nlevel: ${level} (${logLevelToString(level)})`, );
+
+    return false;
+  }
+}
+
+imports.signals.addSignalMethods(LogSignals.prototype);
+
+/**
+ * Emits log signals like `unhandledRejection` and `unhandledRejection`
+ */
+export const logSignals = LogSignals.getSingleton();
+
+

package/src/message.ts

@@ -0,0 +1,11 @@
+// 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/os.ts

@@ -0,0 +1,94 @@
+import { cli } from './cli.js';
+import GLib from '@girs/glib-2.0';
+import Gio from '@girs/gio-2.0';
+
+import type { UserInfo } from './types/index.js';
+
+/** Cache the arch detection */
+let _arch: string = "";
+
+/** Cache the os detection */
+let _os: string = "";
+
+/** Cache the target detection */
+let _target: string = "";
+
+/** Cache the userInfo */
+const userInfo: {[username: string]: UserInfo} = {};
+
+export const getArch = () => {
+    if(_arch) {
+        return _arch;
+    }
+    _arch = cli('uname -m').trim();
+    return _arch;
+}
+  
+export const getOs = () => {
+    if(_os) {
+        return _os;
+    }
+    const os = cli('uname -o').trim();
+    if(/\bDarwin\b/i.test(os)) {
+        _os = 'darwin';
+        return _os;
+    }
+    if(/\bLinux\b/i.test(os)) {
+        _os = 'linux';
+        return _os;
+    }
+    _os = 'win32';
+    return _os;
+};
+
+export const getVendor = () => 'gjsify';
+
+export const getEnv = () => 'gnu';
+
+export const getTarget = () => {
+    if(_target) {
+        return _target;
+    }
+    _target = `${getArch()}-${getVendor()}-${getOs()}-${getEnv()}`;
+    return _target;
+}
+
+/** Extract user info from passwd by username */
+const extractUserInfo = (passwd: string, username: string) => {
+    const lines = passwd.split('\n');
+    for (const line of lines) {
+      const parts = line.split(':');
+      if (parts[0] === username) {
+        return {
+          username: parts[0],
+          // password: parts[1],
+          userId: parseInt(parts[2], 10),
+          groupId: parseInt(parts[3], 10),
+          userInfo: parts[4],
+          homeDirectory: parts[5],
+          shell: parts[6]
+        };
+      }
+    }
+    return null;
+}
+
+export const getUserInfo = (username?: string) => {
+    const file = Gio.File.new_for_path('/etc/passwd');
+    if(!username) {
+        username = GLib.get_user_name();
+    }
+
+    if(userInfo[username]) {
+        return userInfo[username];
+    }
+    const [success, contents] = file.load_contents(null);
+    if(!success) {
+        throw new Error(`Failed to load ${file.get_path()}`);
+    }
+
+    const contentStr = new TextDecoder().decode(contents);
+
+    userInfo[username] = extractUserInfo(contentStr, username);
+    return userInfo[username];
+}

package/src/path.ts

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

package/src/process.spec.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from '@gjsify/unit';
+import { getPid, getPpid } from './process.js';
+
+export default async () => {
+	await describe('getPid', async () => {
+		const pid = getPid();
+		await it('should be a number', async () => {
+			expect(typeof pid).toBe("number");
+		});
+		await it('should be greater than 0', async () => {
+			expect(pid).toBeGreaterThan(0);
+		});
+	});
+
+	await describe('getPpid', async () => {
+		const ppid = getPpid();
+		await it('should be a number', async () => {
+			expect(typeof ppid).toBe("number");
+		});
+		await it('should be greater than 0', async () => {
+			expect(ppid).toBeGreaterThan(0);
+		});
+	});
+}

package/src/process.ts

@@ -0,0 +1,46 @@
+import Gio from '@girs/gio-2.0';
+import GLib from '@girs/glib-2.0';
+
+/** Cached process id */
+let PID = 0;
+/** Cached parent process id */
+let PPID = 0;
+/** Cached locale */
+let LOCALE = ""
+
+export const getLocale = () => {
+    if(!LOCALE) {
+        LOCALE = GLib.getenv("LANG").split('.')[0].replace('_', '-');
+    }
+    return LOCALE
+}
+
+/** Get process id */
+export const getPid = () => {
+    if(!PID) {
+        PID = new Gio.Credentials().get_unix_pid();
+    }
+    return PID;
+}
+
+/** Get parent process id */
+export const getPpid = () => {
+    if(!PPID) {
+        const path = `/proc/${getPid()}/status`;
+        const file = Gio.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;
+}
+
+export const getTitle = () => {
+    return GLib.get_prgname();
+}

package/src/system.ts

@@ -0,0 +1,56 @@
+import GLib from '@girs/glib-2.0';
+import Gio from '@girs/gio-2.0';
+import { existsSync } from './fs.js';
+
+const File = Gio.File;
+
+/** Cache the getArgs result */
+const args: string[] = [];
+
+export const getArgv = () => {
+
+  if(args.length) {
+    return args;
+  }
+
+  const [__filename] = GLib.filename_from_uri((import.meta as any).url);
+  args.push(__filename);
+  ARGV.forEach(arg => {
+      if (arg[0] !== '-') {
+        args.push(
+              existsSync(arg) ?
+                  File.new_for_path(arg).get_path() :
+                  arg
+          );
+      } else {
+        args.push(arg);
+      }
+  });
+
+  return args;
+}
+
+export const getArgs = () => {
+  return getArgv().slice(2);
+}
+
+export const parseArgv = (argv: string[]): { [key: string]: string | boolean } => {
+  let result: { [key: string]: string | boolean } = {};
+  let currentKey: string | null = 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/src/test.ts

@@ -0,0 +1,6 @@
+import { run } from '@gjsify/unit';
+import processSuite from './process.spec.js';
+import ttdSuite from './tty.spec.js';
+import logSuite from './log.spec.js';
+
+run({ttdSuite, processSuite, logSuite});

package/src/tty.spec.ts

@@ -0,0 +1,10 @@
+import { describe, it, expect } from '@gjsify/unit';
+import { existsTty } from './tty.js';
+
+export default async () => {
+	await describe('existsTty', async () => {
+		await it('should return true', async () => {
+			expect(existsTty()).toBeTruthy();
+		});
+	});
+}

package/src/tty.ts

@@ -0,0 +1,10 @@
+import { existsFD } from './fs.js';
+
+export const STDIN_FD = 0;
+export const STDOUT_FD = 1;
+export const STDERR_FD = 2;
+
+/** Check if the stdout file descriptor exists, if this is the case a tty (terminal) should exists (untested) */
+export const existsTty = () => {
+    return existsFD(STDOUT_FD);
+}

package/src/types/cancel-signals.ts

@@ -0,0 +1,6 @@
+import type { SignalMethods } from './signal-methods.js';
+
+export interface CancelSignals extends SignalMethods {
+  connect(sigName: "close", callback: (self: SignalMethods) => void): number;
+  emit(sigName: "close"): void;
+}

package/src/types/error-data.ts

@@ -0,0 +1,8 @@
+import { StackTraceFrame } from './stack-trace-frame.js';
+
+export interface ErrorData {
+    errorType: string;
+    message: string;
+    frames: StackTraceFrame[],
+    stackTraceLines: string[];
+}

package/src/types/index.ts

@@ -0,0 +1,8 @@
+export * from './cancel-signals.js';
+export * from './error-data.js';
+export * from './signal-methods.js';
+export * from './stack-trace-frame.js';
+export * from './structured-log-data.js';
+export * from './uncaught-exception-data.js';
+export * from './unhandled-rejection-data.js';
+export * from './user-info.js';