Exposed a static Ono.extend() method that allows Ono to extend Errors that weren't created with Ono

Author: JamesMessinger

src/constructor.ts

@@ -1,19 +1,11 @@
 import { extendError } from "./extend-error";
 import { normalizeArgs, normalizeOptions } from "./normalize";
 import { toJSON as errorToJSON } from "./to-json";
-import { ErrorLike, ErrorLikeConstructor, ErrorLikeConstructorClass, ErrorPOJO, OnoConstructor, OnoError, OnoOptions } from "./types";
+import { ErrorLike, ErrorLikeConstructor, ErrorLikeConstructorClass, OnoConstructor, OnoOptions } from "./types";
 
 const constructor = Ono as OnoConstructor;
 export { constructor as Ono };
 
-/**
- * Returns an object containing all properties of the given Error object,
- * which can be used with `JSON.stringify()`.
- */
-Ono.toJSON = function toJSON<E extends ErrorLike>(error: E) {
-  return errorToJSON.call(error) as ErrorPOJO & E;
-};
-
 /**
  * Creates an `Ono` instance for a specifc error type.
  */
@@ -25,14 +17,36 @@ function Ono<T extends ErrorLike>(ErrorConstructor: ErrorLikeConstructor<T>, opt
     let { originalError, props, message } = normalizeArgs<E, P>(args, options!);
 
     // Create a new error of the specified type
-    let newError = new (ErrorConstructor as ErrorLikeConstructorClass<T>)(message) as T & E & P & OnoError<T & E & P>;
+    let newError = new (ErrorConstructor as ErrorLikeConstructorClass<T>)(message);
 
     // Extend the error with the properties of the original error and the `props` object
-    extendError(newError, originalError, props);
-
-    return newError;
+    return extendError(newError, originalError, props);
   }
 
   ono[Symbol.species] = ErrorConstructor;
   return ono;
 }
+
+/**
+ * Returns an object containing all properties of the given Error object,
+ * which can be used with `JSON.stringify()`.
+ */
+Ono.toJSON = function toJSON(error: ErrorLike) {
+  return errorToJSON.call(error);
+};
+
+/**
+ * Extends the given Error object with enhanced Ono functionality, such as nested stack traces,
+ * additional properties, and improved support for `JSON.stringify()`.
+ */
+Ono.extend = function extend(error: ErrorLike, originalError?: ErrorLike, props?: object) {
+  if (props || originalError instanceof Error) {
+    return extendError(error, originalError, props);
+  }
+  else if (originalError) {
+    return extendError(error, undefined, originalError);
+  }
+  else {
+    return extendError(error);
+  }
+};

src/extend-error.ts

@@ -12,28 +12,32 @@ const protectedProps: Array<string | symbol> = ["name", "message", "stack"];
  * @param originalError - The original error object, if any
  * @param props - Additional properties to add, if any
  */
-export function extendError<T>(newError: OnoError<T>, originalError?: ErrorPOJO, props?: object) {
-  extendStack(newError, originalError);
+export function extendError<T extends ErrorLike, E extends ErrorLike, P extends object>(error: T, originalError?: E, props?: P) {
+  let onoError = error as unknown as T & E & P & OnoError<T & E & P>;
+
+  extendStack(onoError, originalError);
 
   // Copy properties from the original error
   if (originalError && typeof originalError === "object") {
-    mergeErrors(newError, originalError);
+    mergeErrors(onoError, originalError);
   }
 
   // The default `toJSON` method doesn't output props like `name`, `message`, `stack`, etc.
   // So replace it with one that outputs every property of the error.
-  newError.toJSON = toJSON;
+  onoError.toJSON = toJSON;
 
   // On Node.js, add support for the `util.inspect()` method
   if (addInspectMethod) {
-    addInspectMethod(newError);
+    addInspectMethod(onoError);
   }
 
   // Finally, copy custom properties that were specified by the user.
   // These props OVERWRITE any previous props
   if (props && typeof props === "object") {
-    Object.assign(newError, props);
+    Object.assign(onoError, props);
   }
+
+  return onoError;
 }
 
 /**

src/types.ts

@@ -25,6 +25,43 @@ export interface OnoConstructor {
    * which can be used with `JSON.stringify()`.
    */
   toJSON<E extends ErrorLike>(error: E): ErrorPOJO & E;
+
+  /**
+   * Extends the given Error object with enhanced Ono functionality, such as improved support for
+   * `JSON.stringify()`.
+   *
+   * @param error - The error object to extend. This object instance will be modified and returned.
+   */
+  extend<T extends ErrorLike>(error: T): T & OnoError<T>;
+
+  /**
+   * Extends the given Error object with enhanced Ono functionality, such as additional properties
+   * and improved support for `JSON.stringify()`.
+   *
+   * @param error - The error object to extend. This object instance will be modified and returned.
+   * @param props - An object whose properties will be added to the error
+   */
+  extend<T extends ErrorLike, P extends object>(error: T, props?: P): T & P & OnoError<T & P>;
+
+  /**
+   * Extends the given Error object with enhanced Ono functionality, such as nested stack traces
+   * and improved support for `JSON.stringify()`.
+   *
+   * @param error - The error object to extend. This object instance will be modified and returned.
+   * @param originalError - The original error. This error's stack trace will be added to the error's stack trace.
+   */
+  extend<T extends ErrorLike, E extends ErrorLike>(error: T, originalError?: E): T & E & OnoError<T & E>;
+
+  /**
+   * Extends the given Error object with enhanced Ono functionality, such as nested stack traces,
+   * additional properties, and improved support for `JSON.stringify()`.
+   *
+   * @param error - The error object to extend. This object instance will be modified and returned.
+   * @param originalError - The original error. This error's stack trace will be added to the error's stack trace.
+   * @param props - An object whose properties will be added to the error
+   */
+  extend<T extends ErrorLike, E extends ErrorLike, P extends object>(error: T, originalError?: E, props?: P)
+  : T & E & P & OnoError<T & E & P>;
 }
 
 /**