@gjsify/utils 0.0.2

package/lib/esm/os.js

@@ -0,0 +1,81 @@
+import { cli } from "./cli.js";
+import GLib from "@girs/glib-2.0";
+import Gio from "@girs/gio-2.0";
+let _arch = "";
+let _os = "";
+let _target = "";
+const userInfo = {};
+const getArch = () => {
+  if (_arch) {
+    return _arch;
+  }
+  _arch = cli("uname -m").trim();
+  return _arch;
+};
+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;
+};
+const getVendor = () => "gjsify";
+const getEnv = () => "gnu";
+const getTarget = () => {
+  if (_target) {
+    return _target;
+  }
+  _target = `${getArch()}-${getVendor()}-${getOs()}-${getEnv()}`;
+  return _target;
+};
+const extractUserInfo = (passwd, username) => {
+  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;
+};
+const getUserInfo = (username) => {
+  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];
+};
+export {
+  getArch,
+  getEnv,
+  getOs,
+  getTarget,
+  getUserInfo,
+  getVendor
+};

package/lib/esm/path.js

@@ -0,0 +1,50 @@
+import Gio from "@girs/gio-2.0";
+import GLib from "@girs/glib-2.0";
+const { File } = Gio;
+const _getProgramDir = (programFile) => {
+  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();
+  }
+};
+const resolve = (dir, ...filenames) => {
+  let file = File.new_for_path(dir);
+  for (const filename of filenames) {
+    file = file.resolve_relative_path(filename);
+  }
+  return file;
+};
+const getProgramExe = () => {
+  const currentDir = GLib.get_current_dir();
+  return File.new_for_path(currentDir).resolve_relative_path(imports.system.programInvocationName);
+};
+const getProgramDir = () => {
+  return _getProgramDir(getProgramExe()).get_path();
+};
+const getPathSeparator = () => {
+  const currentDir = GLib.get_current_dir();
+  return /^\//.test(currentDir) ? "/" : "\\";
+};
+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;
+};
+export {
+  getNodeModulesPath,
+  getPathSeparator,
+  getProgramDir,
+  getProgramExe,
+  resolve
+};

package/lib/esm/process.js

@@ -0,0 +1,41 @@
+import Gio from "@girs/gio-2.0";
+import GLib from "@girs/glib-2.0";
+let PID = 0;
+let PPID = 0;
+let LOCALE = "";
+const getLocale = () => {
+  if (!LOCALE) {
+    LOCALE = GLib.getenv("LANG").split(".")[0].replace("_", "-");
+  }
+  return LOCALE;
+};
+const getPid = () => {
+  if (!PID) {
+    PID = new Gio.Credentials().get_unix_pid();
+  }
+  return PID;
+};
+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;
+};
+const getTitle = () => {
+  return GLib.get_prgname();
+};
+export {
+  getLocale,
+  getPid,
+  getPpid,
+  getTitle
+};

package/lib/esm/system.js

@@ -0,0 +1,47 @@
+import GLib from "@girs/glib-2.0";
+import Gio from "@girs/gio-2.0";
+import { existsSync } from "./fs.js";
+const File = Gio.File;
+const args = [];
+const getArgv = () => {
+  if (args.length) {
+    return args;
+  }
+  const [__filename] = GLib.filename_from_uri(import.meta.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;
+};
+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;
+};
+export {
+  getArgs,
+  getArgv,
+  parseArgv
+};

package/lib/esm/tty.js

@@ -0,0 +1,13 @@
+import { existsFD } from "./fs.js";
+const STDIN_FD = 0;
+const STDOUT_FD = 1;
+const STDERR_FD = 2;
+const existsTty = () => {
+  return existsFD(STDOUT_FD);
+};
+export {
+  STDERR_FD,
+  STDIN_FD,
+  STDOUT_FD,
+  existsTty
+};

package/lib/esm/types/index.js

@@ -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";

package/lib/esm/version.js

@@ -0,0 +1,7 @@
+const getGjsVersion = () => {
+  const v = imports.system.version.toString();
+  return `${v[0]}.${+(v[1] + v[2])}.${+(v[3] + v[4])}`;
+};
+export {
+  getGjsVersion
+};

package/lib/types/cancel-handler.d.ts

@@ -0,0 +1,4 @@
+import type { CancelSignals } from './types/index.js';
+export declare const createCancelHandler: () => number;
+export declare const closeCancelHandler: (rid: number) => void;
+export declare const getCancelHandler: (rid: number) => CancelSignals | undefined;

package/lib/types/cli.d.ts

@@ -0,0 +1 @@
+export declare const cli: (commandLine: string) => string;

package/lib/types/error.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 declare const initErrorV8Methods: (ErrorConstructor: typeof Error) => void;

package/lib/types/file.d.ts

@@ -0,0 +1 @@
+export declare const readJSON: (path: string) => any;

package/lib/types/fs.d.ts

@@ -0,0 +1,3 @@
+/** Check if a file descriptor exists */
+export declare const existsFD: (fd: number) => boolean;
+export declare function existsSync(path: string): boolean;

package/lib/types/index.d.ts

@@ -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/types/log.d.ts

@@ -0,0 +1,29 @@
+import GLib from '@girs/glib-2.0';
+import type { StructuredLogData, SignalMethods, StackTraceFrame, ErrorData, UncaughtExceptionData, UnhandledRejectionData } from './types/index.js';
+export declare const logLevelToString: (logLevel: GLib.LogLevelFlags) => "FLAG_FATAL" | "FLAG_RECURSION" | "LEVEL_CRITICAL" | "LEVEL_DEBUG" | "LEVEL_ERROR" | "LEVEL_INFO" | "LEVEL_MASK" | "LEVEL_MESSAGE" | "LEVEL_WARNING" | "UNKNOWN";
+export declare const parseStackTrace: (stackTraceLine: string) => StackTraceFrame | null;
+export declare const extractErrorData: (errorMessage: string) => ErrorData;
+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 declare class LogSignals {
+    private static instance;
+    /** This is a singleton because log_set_writer_func may only be called once */
+    private constructor();
+    static getSingleton(): LogSignals;
+    private initHandler;
+    /**
+     * 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): boolean;
+}
+/**
+ * Emits log signals like `unhandledRejection` and `unhandledRejection`
+ */
+export declare const logSignals: LogSignals;

package/lib/types/message.d.ts

@@ -0,0 +1,2 @@
+export declare const notImplemented: (msg: string) => never;
+export declare const warnNotImplemented: (msg: any) => string;

package/lib/types/os.d.ts

@@ -0,0 +1,7 @@
+import type { UserInfo } from './types/index.js';
+export declare const getArch: () => string;
+export declare const getOs: () => string;
+export declare const getVendor: () => string;
+export declare const getEnv: () => string;
+export declare const getTarget: () => string;
+export declare const getUserInfo: (username?: string) => UserInfo;

package/lib/types/path.d.ts

@@ -0,0 +1,6 @@
+import Gio from '@girs/gio-2.0';
+export declare const resolve: (dir: string, ...filenames: string[]) => Gio.File;
+export declare const getProgramExe: () => Gio.File;
+export declare const getProgramDir: () => string;
+export declare const getPathSeparator: () => "/" | "\\";
+export declare const getNodeModulesPath: () => Gio.File;

package/lib/types/process.d.ts

@@ -0,0 +1,6 @@
+export declare const getLocale: () => string;
+/** Get process id */
+export declare const getPid: () => number;
+/** Get parent process id */
+export declare const getPpid: () => number;
+export declare const getTitle: () => string;

package/lib/types/system.d.ts

@@ -0,0 +1,5 @@
+export declare const getArgv: () => string[];
+export declare const getArgs: () => string[];
+export declare const parseArgv: (argv: string[]) => {
+    [key: string]: string | boolean;
+};

package/lib/types/tty.d.ts

@@ -0,0 +1,5 @@
+export declare const STDIN_FD = 0;
+export declare const STDOUT_FD = 1;
+export declare const STDERR_FD = 2;
+/** Check if the stdout file descriptor exists, if this is the case a tty (terminal) should exists (untested) */
+export declare const existsTty: () => boolean;

package/lib/types/types/cancel-signals.d.ts

@@ -0,0 +1,5 @@
+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/lib/types/types/error-data.d.ts

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

package/lib/types/types/index.d.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';

package/lib/types/types/signal-methods.d.ts

@@ -0,0 +1,62 @@
+/**
+ * You can use the `Signals.addSignalMethods` method to apply the `Signals` convenience methods to an `Object`.
+ * Generally, this is called on an object prototype, but may also be called on an object instance.
+ * You can use this Interface for this object or prototype to make the methods in typescript known
+ * @example
+ * ```ts
+ * const Signals = imports.signals;
+ *
+ * // Define an interface with the same name of your class to make the methods known
+ * interface Events extends SignalMethods {}
+ *
+ * class Events {}
+ * Signals.addSignalMethods(Events.prototype);
+ *
+ * const events = new Events();
+ *
+ * // Typescript will not complain here
+ * events.emit("test-signal", "test argument");
+ * ```
+ */
+export interface SignalMethods {
+    /**
+     * Connects a callback to a signal for an object. Pass the returned ID to
+     * `disconect()` to remove the handler.
+     *
+     * If `callback` returns `true`, emission will stop and no other handlers will be
+     * invoked.
+     *
+     * > Warning: Unlike GObject signals, `this` within a signal callback will always
+     * > refer to the global object (ie. `globalThis`).
+     *
+     * @param sigName A signal name
+     * @param callback A callback function
+     * @returns A handler ID
+     */
+    connect(sigName: string, callback: (self: any, ...args: any[]) => void): number;
+    /**
+     * Emits a signal for an object. Emission stops if a signal handler returns `true`.
+     *
+     * Unlike GObject signals, it is not necessary to declare signals or define their
+     * signature. Simply call `emit()` with whatever signal name you wish, with
+     * whatever arguments you wish.
+     * @param sigName A signal name
+     * @param args Any number of arguments, of any type
+     */
+    emit(sigName: string, ...args: any[]): void;
+    /**
+     * Disconnects a handler for a signal.
+     * @param id The ID of the handler to be disconnected
+     */
+    disconnect(id: number): void;
+    /**
+     * Disconnects all signal handlers for an object.
+     */
+    disconnectAll(): void;
+    /**
+     * Checks if a handler ID is connected.
+     * @param id The ID of the handler to be disconnected
+     * @returns `true` if connected, or `false` if not
+     */
+    signalHandlerIsConnected(id: number): boolean;
+}

package/lib/types/types/stack-trace-frame.d.ts

@@ -0,0 +1,6 @@
+export interface StackTraceFrame {
+    fileName: string;
+    lineNumber: number;
+    columnNumber: number;
+    line: string;
+}

package/lib/types/types/structured-log-data.d.ts

@@ -0,0 +1,5 @@
+export interface StructuredLogData {
+    message: string;
+    priority: number;
+    domain: string;
+}

package/lib/types/types/uncaught-exception-data.d.ts

@@ -0,0 +1,4 @@
+import { ErrorData } from './error-data.js';
+export interface UncaughtExceptionData extends ErrorData {
+    error: Error;
+}

package/lib/types/types/unhandled-rejection-data.d.ts

@@ -0,0 +1,5 @@
+import { ErrorData } from './error-data.js';
+export interface UnhandledRejectionData extends ErrorData {
+    reason: any;
+    promise: Promise<any>;
+}

package/lib/types/types/user-info.d.ts

@@ -0,0 +1,8 @@
+export interface UserInfo {
+    username: string;
+    userId: number;
+    groupId: number;
+    userInfo: string;
+    homeDirectory: string;
+    shell: string;
+}

package/lib/types/version.d.ts

@@ -0,0 +1 @@
+export declare const getGjsVersion: () => string;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@gjsify/utils",
+  "version": "0.0.2",
+  "description": "Utils module for gjsify",
+  "main": "lib/cjs/index.js",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./lib/types/index.d.ts",
+        "default": "./lib/esm/index.js"
+      },
+      "require": {
+        "types": "./lib/types/index.d.ts",
+        "default": "./lib/cjs/index.js"
+      }
+    }
+  },
+  "scripts": {
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
+    "print:name": "echo '@gjsify/utils'",
+    "build": "yarn print:name && 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 --project tsconfig.types.json",
+    "build:test": "yarn build:test:gjs",
+    "build:test:gjs": "gjsify build src/test.ts --app gjs --outfile test.gjs.js",
+    "test": "yarn print:name && yarn build:gjsify && yarn build:test && yarn test:gjs",
+    "test:gjs": "gjs -m test.gjs.js"
+  },
+  "keywords": [
+    "gjs",
+    "node",
+    "fs"
+  ],
+  "devDependencies": {
+    "@gjsify/cli": "^0.0.2",
+    "typescript": "^5.1.3"
+  },
+  "dependencies": {
+    "@girs/gio-2.0": "2.76.1-3.1.0",
+    "@girs/gjs": "^3.1.0",
+    "@girs/glib-2.0": "2.76.1-3.1.0"
+  }
+}

package/src/cancel-handler.ts

@@ -0,0 +1,24 @@
+import type { CancelSignals } from './types/index.js';
+
+let nextRid = 1;
+const resources: {[rid: number]: CancelSignals} = {};
+
+export const createCancelHandler = () => {
+    const rid = nextRid++;
+    const cancelHandler = {} as CancelSignals;
+    imports.signals.addSignalMethods(cancelHandler);
+
+    resources[rid] = cancelHandler;
+
+    return rid;
+}
+
+export const closeCancelHandler = (rid: number) => {
+    const cancelHandler = getCancelHandler(rid);
+    cancelHandler?.emit('close');
+    delete resources[rid];
+}
+  
+export const getCancelHandler = (rid: number): CancelSignals | undefined => {
+    return resources[rid];
+}

package/src/cli.ts

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

@@ -0,0 +1,38 @@
+/**
+ * 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

@@ -0,0 +1,12 @@
+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}"`);
+}