kerium 1.2.1 → 1.3.1

package/dist/error.d.ts

@@ -402,39 +402,60 @@ declare const errnoMessages: {
 };
 type ErrnoMessage<T extends Errno | keyof typeof Errno> = (typeof errnoMessages)[T extends Errno ? T : T extends keyof typeof Errno ? (typeof Errno)[T] : ''];
 export declare function strerror<const T extends Errno | keyof typeof Errno>(errno: T): ErrnoMessage<T>;
+export interface ExceptionExtra {
+    path?: string;
+    dest?: string;
+    syscall?: string;
+    [k: string]: any;
+}
 /**
  * JSON representation of an error.
  */
-export interface ErrnoExceptionJSON {
+export interface ExceptionJSON {
     errno: Errno;
     message: string;
-    path?: string;
     code: keyof typeof Errno;
     stack: string;
-    syscall: string;
+    path?: string;
+    dest?: string;
+    syscall?: string;
 }
+/**
+ * Set the message of an exception to the UV-style message.
+ */
+export declare function setUVMessage<T extends ExceptionJSON>(ex: T): T;
 /**
  * An error with additional information about what happened.
  *
- * @remarks
+ * @privateRemarks
+ *
+ * This is modeled after Node.js's `ErrnoException` and `UVException`.
  *
  * `Error.captureStackTrace` is used when available to hide irrelevant stack frames.
  * This is being standardized, however it is not available in Deno and behind a flag in Firefox.
  * See https://github.com/tc39/proposal-error-capturestacktrace for more details.
  */
-export declare class ErrnoException extends Error implements NodeJS.ErrnoException {
+export declare class Exception extends Error implements NodeJS.ErrnoException, ExceptionJSON {
     errno: Errno;
-    message: string;
-    syscall: string;
     stack: string;
     code: keyof typeof Errno;
-    constructor(errno: Errno, message?: string, syscall?: string);
+    path?: string;
+    dest?: string;
+    syscall?: string;
+    constructor(errno: Errno, message: false, context: ExceptionExtra);
+    constructor(errno: Errno, message?: string);
     toString(): string;
-    toJSON(): ErrnoExceptionJSON;
-    static fromJSON(this: void, json: ErrnoExceptionJSON): ErrnoException;
+    toJSON(): ExceptionJSON;
+    static fromJSON(this: void, json: ExceptionJSON): Exception;
 }
+/**
+ * Shortcut for UV-style exceptions.
+ */
+export declare function UV(this: void, code: keyof typeof Errno, syscall: string, path?: string, dest?: string): Exception;
+export declare function UV(this: void, code: keyof typeof Errno, context?: ExceptionExtra): Exception;
 /**
  * Shortcut to easily create an `ErrnoException` with a specific error code.
  */
-export declare function withErrno(this: void, code: keyof typeof Errno, message?: string, syscall?: string): ErrnoException;
+export declare function withErrno(this: void, code: keyof typeof Errno, message?: string): Exception;
+export declare function rethrow(extra: ExceptionExtra): (e: Exception) => never;
 export {};

package/dist/error.js

@@ -1,3 +1,4 @@
+import { omit } from 'utilium';
 /**
  * Standard POSIX error codes.
  * @see https://en.wikipedia.org/wiki/Errno.h
@@ -405,52 +406,95 @@ export function strerror(errno) {
     const _errno = typeof errno == 'string' ? Errno[errno] : errno;
     return (_errno in errnoMessages ? errnoMessages[_errno] : '');
 }
+/**
+ * Set the message of an exception to the UV-style message.
+ */
+export function setUVMessage(ex) {
+    let message = `${ex.code}: ${errnoMessages[ex.errno]}, ${ex.syscall}`;
+    if (ex.path)
+        message += ` '${ex.path}'`;
+    if (ex.dest)
+        message += ` -> '${ex.dest}'`;
+    if (ex.message)
+        message += ` (${ex.message})`;
+    ex.message = message;
+    return ex;
+}
 /**
  * An error with additional information about what happened.
  *
- * @remarks
+ * @privateRemarks
+ *
+ * This is modeled after Node.js's `ErrnoException` and `UVException`.
  *
  * `Error.captureStackTrace` is used when available to hide irrelevant stack frames.
  * This is being standardized, however it is not available in Deno and behind a flag in Firefox.
  * See https://github.com/tc39/proposal-error-capturestacktrace for more details.
  */
-export class ErrnoException extends Error {
+export class Exception extends Error {
     errno;
-    message;
-    syscall;
     code;
-    constructor(errno, message = errnoMessages[errno], syscall = '') {
+    path;
+    dest;
+    syscall;
+    constructor(errno, message, ctx = {}) {
+        const code = Errno[errno];
+        if (message === false) {
+            message = `${code}: ${errnoMessages[errno]}, ${ctx.syscall}`;
+            if (ctx.path)
+                message += ` '${ctx.path}'`;
+            if (ctx.dest)
+                message += ` -> '${ctx.dest}'`;
+        }
         super(message);
         this.errno = errno;
-        this.message = message;
-        this.syscall = syscall;
-        this.code = Errno[errno];
+        this.code = code;
+        Object.assign(this, omit(ctx, 'message', 'path', 'dest'));
         Error.captureStackTrace?.(this, this.constructor);
     }
     toString() {
-        return this.code + ': ' + this.message;
+        return this.message;
     }
     toJSON() {
-        return {
+        const json = {
             errno: this.errno,
             code: this.code,
             stack: this.stack,
             message: this.message,
-            syscall: this.syscall,
         };
+        if (this.path)
+            json.path = this.path;
+        if (this.dest)
+            json.dest = this.dest;
+        if (this.syscall)
+            json.syscall = this.syscall;
+        return json;
     }
     static fromJSON(json) {
-        const err = new ErrnoException(json.errno, json.message, json.syscall);
-        err.code = json.code;
+        const err = json.syscall ? new Exception(json.errno, false, json) : new Exception(json.errno, json.message);
         err.stack = json.stack;
         return err;
     }
 }
+export function UV(code, context, path, dest) {
+    if (typeof context === 'string')
+        context = { syscall: context, path, dest };
+    const err = new Exception(Errno[code], false, context ?? {});
+    Error.captureStackTrace?.(err, UV);
+    return err;
+}
 /**
  * Shortcut to easily create an `ErrnoException` with a specific error code.
  */
-export function withErrno(code, message, syscall) {
-    const err = new ErrnoException(Errno[code], message ?? errnoMessages[Errno[code]], syscall);
+export function withErrno(code, message) {
+    const err = new Exception(Errno[code], message ?? errnoMessages[Errno[code]]);
     Error.captureStackTrace?.(err, withErrno);
     return err;
 }
+export function rethrow(extra) {
+    return function (e) {
+        Object.assign(e, extra);
+        setUVMessage(e);
+        throw e;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "kerium",
-	"version": "1.2.1",
+	"version": "1.3.1",
 	"description": "POSIX-style errors, logging, and more",
 	"author": "James Prevett <jp@jamespre.dev> (https://jamespre.dev)",
 	"repository": {