@smbcheeky/error-object-from-payload 1.1.6 → 1.2.0

package/README.md

@@ -7,9 +7,8 @@
 ## TL;DR
 
 - Install the package `npm install @smbcheeky/error-object @smbcheeky/error-object-from-payload`
-- Write `fromPayload(<pick an api response with an error>).force.verboseLog('LOG')` and use the info provided to
+- Write `new ErrorObjectFromPayload(<pick an api response with an error>).verboseLog('LOG')` and use the info provided to
   map your error
-- Switch the .force with .error, and now you have an error object
 - :tada:
 - oh... and check the [playground](https://github.com/SMBCheeky/error-object-from-payload/blob/main/playground/index.ts)
   file
@@ -22,8 +21,9 @@
 
 ## Description
 
-The ErrorObject class is made to extend `Error` enabling checks like `errorObject instanceof Error` or
-`errorObject instanceof ErrorObject`. The `ErrorObject` class is backwards compatible with `Error`.
+The ErrorObject class is made to extend `Error` enabling type guard checks like `errorObject instanceof Error`,
+`errorObject instanceof ErrorObject`, ErrorObject.is() and isErrorObject(). . The `ErrorObject` class is backwards
+compatible with `Error`.
 
 This functionality was extracted from the [error-object](https://github.com/SMBCheeky/error-object) package (at v1.1.5)
 and renamed to `error-object-from-payload` to simplify the main package and its README. This package is not a
@@ -32,13 +32,7 @@ payload by providing step-by-step debugging logs for the entire process.
 
 ## Usage
 
-Use `fromPayload(<anything>)` to create errors from any input:
-
-- you can pass an object or a caught error to it, and it will try its best to create an error from it
-- `fromPayload(<anything>)` returns an object with two properties: `.error` and `.force`
-- `.error` represents the error, if it can be created, otherwise it is `undefined`
-- `.force` represents the error, if it can be created, otherwise it is going to return a `ErrorObject.fallback()`
-  error
+Use `new ErrorObjectFromPayload(<anything>, ErrorObjectBuildOptions)` to create errors from any input.
 
 The processing of the ErrorObject is done in a few steps, based on the `ErrorObjectBuildOptions`:
 
@@ -46,26 +40,27 @@ The processing of the ErrorObject is done in a few steps, based on the `ErrorObj
   `checkInputObjectForKeys`
 - then the objects checks for an object array at `pathToErrors`, which could be an array of errors
 - if an error array is found, the process will consider all other paths relative to the objects in the error array found
-- if an error array is not found, the process will consider all other paths absolute to the initial objectpassed to
-  `fromPayload()`
+- if an error array is not found, the process will consider all other paths absolute to the initial object passed to
+  `new ErrorObjectFromPayload()`
 - the `pathToCode`, `pathToNumberCode`, `pathToMessage`, `pathToDetails` and `pathToDomain` options are used to map
   values to their associated field, if found
 - for all fields other than `numberCode`, if a value is found and is a string, it is saved as is, but if it is an array
-  or an object it will be JSON.stringify'ed and saved as a string
-- for `numberCode`, if a value is found and it is a number different than `NaN`, it is saved
+  or an object, it will be JSON.stringify and saved as a string
+- for `numberCode`, if a value is found, and it is a number different from `NaN`, it is saved
 - the `transform` function is used to transform the found values by the parsing process into the error object
 - the transform function has access to all pre-transformation values and also the initial object (object inside the
-  errors array or initial object)
+  errors' array or initial object)
 - everything gets processed into a list of `ErrorSummary | ErrorObjectErrorResult` array
-- it contains everything, from error strings custom-made to be as distinct and easy to read as possible, to self
-  documenting summaries of what values are found, at which path, if an errors object was found, etc.
+- it contains everything, from error strings custom-made to be as distinct and easy to read as possible, to 
+  self-documenting summaries of what values are found, at which path, if an error object was found, etc.
 - the count of the list is meant to be an indication of how many input objects were found and processed, as each of them
   should become an error object
 - in the last step of the process, the list is filtered down and a single error object is created, with everything baked
   in
-- think detailed `processingErrors` which includes the summaries and the errors that were triggered during the process,
-  the `raw` object that was used as in input for the fromPayload() call and the `nextErrors` array which allows for
-  all errors to be saved on one single error object for later use
+- the `raw` will contain details about the process and also the initial/input object
+- check `processingErrors` and `summary` fields in `raw` object for the errors and the summaries that were 
+  computed during the process
+- the `nextErrors` array allows for all errors found to be saved on one single error object for later use
 
 ## Usage & Examples
 
@@ -75,17 +70,17 @@ the [playground](https://github.com/SMBCheeky/error-object/blob/main/playground/
 ```typescript
 new ErrorObject({ code: '', message: 'Something went wrong.', domain: 'auth' }).debugLog('LOG');
 
-fromPayload({ code: '', message: 'Something went wrong', domain: 'auth' })?.force?.debugLog('LOG');
+new ErrorObjectFromPayload({ code: '', message: 'Something went wrong', domain: 'auth' })?.force?.debugLog('LOG');
 
 // Example 12 output:
-// 
+//
 // [LOG] Something went wrong. [auth]
 // {
 //   "code": "",
 //   "message": "Something went wrong.",
 //   "domain": "auth"
 // }
-// 
+//
 // [LOG] Something went wrong [auth]
 // {
 //   "code": "",
@@ -103,7 +98,7 @@ const response = {
   body: '{"error":"Invalid input data","code":400}',
 };
 
-fromPayload(JSON.parse(response?.body), {
+new ErrorObjectFromPayload(JSON.parse(response?.body), {
   pathToNumberCode: ['code'],
   pathToMessage: ['error'],
 }).force?.debugLog('LOG');
@@ -119,13 +114,12 @@ fromPayload(JSON.parse(response?.body), {
 ```
 
 ```typescript
-/* 
- * You could have a file called `errors.ts` in each of your modules/folders and 
- * define a function like `createAuthError2()` that returns an error object with 
+/*
+ * You could have a file called `errors.ts` in each of your modules/folders and
+ * define a function like `createAuthError2()` that returns an error object with
  * the correct message and domain.
  */
-const AuthMessageResolver = (
-  beforeTransform: ErrorObjectTransformState): ErrorObjectTransformState => {
+const AuthMessageResolver = (beforeTransform: ErrorObjectTransformState): ErrorObjectTransformState => {
   // Quick tip: Make all messages slightly different, to make it easy
   // to find the right one when debugging, even in production
   let message: string | undefined;
@@ -146,10 +140,9 @@ const AuthMessageResolver = (
 };
 
 const createAuthError2 = (code: string) => {
-  return fromPayload({ code, domain: 'auth', }, { transform: AuthMessageResolver, });
+  return new ErrorObjectFromPayload({ code, domain: 'auth' }, { transform: AuthMessageResolver });
 };
 
-
 createAuthError2('generic')?.error?.log('1');
 createAuthError2('generic-again')?.error?.log('2');
 createAuthError2('generic-network')?.error?.log('3');
@@ -167,12 +160,10 @@ createAuthError2('invalid-code')?.error?.log('4');
 
 ### How do I use paths? Are they absolute?
 
-To support inputs containing arrays of errors as well as single errors, all paths are treated initially as absolute (
-from the
-input root), but if an array of errors is detected, it will consider each element found the new root input object. Devs
-have a
-choice: set the "pathToErrors" option as empty, and then map only the first error (highly not recommended), or adjust
-the paths to be relative to the objects inside the detected errors array.
+To support inputs containing arrays of errors as well as single errors, all paths are treated initially as absolute 
+(from the input root), but if an array of errors is detected, it will consider each element found the new root input 
+object. Devs have a choice: set the "pathToErrors" option as empty, and then map only the first 
+error (not recommended), or adjust the paths to be relative to the objects inside the detected errors array.
 
 ### How do I use paths? I sometimes get the error code in an `error` object, and sometimes in the root object...
 

package/dist/index.d.mts

@@ -0,0 +1,143 @@
+import { ErrorObject } from '@smbcheeky/error-object';
+
+/**
+ * For customizing the paths, please make sure to use the {@link addPrefixPathVariants} function to also add the `error.` prefixed paths to the pathTo... arrays used in the {@link ErrorObjectBuildOptions} type.
+ */
+declare const addPrefixPathVariants: (prefix: string | string[], array: string[]) => string[];
+/**
+ * The {@link DEFAULT_BUILD_OPTIONS} is a set of default options that can be used to customize the behavior of the {@link fromPayload()} method.
+ * It contains common paths and a transform function that automatically converts the error number code, if it exists, to a string and sets it as the error code.
+ */
+declare const DEFAULT_BUILD_OPTIONS: ErrorObjectBuildOptions;
+/**
+ * The {@link ErrorObjectTransformState} type contains the state of the error object before and after the transformation.
+ */
+type ErrorObjectTransformState = {
+    code?: string | undefined;
+    numberCode?: number | undefined;
+    message?: string | undefined;
+    details?: string | undefined;
+    domain?: string | undefined;
+};
+/**
+ * The {@link ErrorObjectBuildOptions} type contains all the options that can be used to customize the behavior of the {@link fromPayload()} method.
+ * Options are self-explanatory and the code behind them is kept similar and very straightforward, by design.
+ */
+type ErrorObjectBuildOptions = {
+    /**
+     * The {@link checkInputObjectForValues} option allows you to check if the input object contains specific values.
+     */
+    checkInputObjectForValues?: {
+        [key: string]: {
+            value: string | number | boolean | null;
+            exists: boolean;
+        };
+    };
+    /**
+     * The {@link checkInputObjectForTypes} option allows you to check if the input object contains specific types.
+     */
+    checkInputObjectForTypes?: {
+        [key: string]: {
+            type: 'string' | 'number' | 'boolean' | 'object';
+            valueIsArray?: boolean;
+            exists: boolean;
+        };
+    };
+    /**
+     * The {@link checkInputObjectForKeys} option allows you to check if the input object contains specific keys.
+     */
+    checkInputObjectForKeys?: {
+        [key: string]: {
+            exists: boolean;
+        };
+    };
+    /**
+     * All paths should be absolute, from the root of the input object, unless an array of errors is found.
+     * When an array of errors is found, the paths are considered relative to the objects found in the errors array.
+     * "[" and "]" chars are not allowed. Use paths like "errors.0.code" instead of "errors[0].code".
+     */
+    pathToErrors: string[];
+    /**
+     * Path to the error code. This is the main error code that is used to identify the error.
+     */
+    pathToCode: string[];
+    /**
+     * Path to the error number code. This is an optional property that can be used to provide a numeric error code.
+     * The default options will automatically convert the number code to a string and set it as the error code + keep the original number code.
+     */
+    pathToNumberCode: string[];
+    /**
+     * Path to the error message. This is the main error message that is used to describe the error.
+     */
+    pathToMessage: string[];
+    /**
+     * Path to the error details. This is an optional property that can be used to provide additional details about the error.
+     * A common pattern is to use this to keep extra information about the error.
+     */
+    pathToDetails: string[];
+    /**
+     * Path to the error domain. This is an optional property that can be used to provide a domain for the error.
+     */
+    pathToDomain: string[];
+    /**
+     * The transform function is used to transform the properties found during the process of building the error object.
+     * This is useful for transforming a the message based on the error code, the domain based on the error code, etc. allowing
+     * the developer to customize the final error object created.
+     */
+    transform?: (beforeTransform: ErrorObjectTransformState, inputObject: any) => ErrorObjectTransformState;
+};
+type PathValueAndTransform<V> = {
+    path: string | undefined;
+    beforeTransform: V | undefined;
+    value: V | undefined;
+};
+/**
+ * The {@link ErrorSummary} helps with debugging and troubleshooting the error object building process.
+ * It contains the input object and the properties found during the process of building the error object.
+ */
+type ErrorSummary = {
+    didDetectErrorsArray?: boolean;
+    input: NonNullable<Record<string, any>>;
+    path?: string;
+    value: {
+        code?: PathValueAndTransform<string>;
+        numberCode?: PathValueAndTransform<number>;
+        message?: PathValueAndTransform<string>;
+        details?: PathValueAndTransform<string>;
+        domain?: PathValueAndTransform<string>;
+    };
+};
+/**
+ * The {@link ErrorObjectErrorResult} type contains all the possible error results that can be returned by the {@link fromPayload()} method.
+ * The error results are used to identify the type of error that occurred during the process of building the error object.
+ */
+type ErrorObjectErrorResult = 'isNullish' | 'isNotAnObject' | 'checkIsNullish' | 'checkIsNotAnObject' | 'isNotAnArray' | 'checkInputObjectForValuesIsNotAnObject' | 'checkInputObjectForValuesFailed' | 'checkInputObjectForTypesIsNotAnObject' | 'checkInputObjectForTypesFailed' | 'checkInputObjectForTypesValueIsArrayFailed' | 'checkInputObjectForKeysIsNotAnObject' | 'checkInputObjectForKeysFailed' | 'pathToErrorsIsNotAnArray' | 'pathToErrorsValuesAreNotStrings' | 'pathToCodeIsInvalid' | 'pathToCodeIsNotAnArray' | 'pathToCodeValuesAreNotStrings' | 'pathToNumberCodeIsInvalid' | 'pathToNumberCodeIsNotAnArray' | 'pathToNumberCodeValuesAreNotStrings' | 'pathToMessageIsInvalid' | 'pathToMessageIsNotAnArray' | 'pathToMessageValuesAreNotStrings' | 'pathToDetailsIsInvalid' | 'pathToDetailsIsNotAnArray' | 'pathToDetailsValuesAreNotStrings' | 'pathToDomainIsInvalid' | 'pathToDomainIsNotAnArray' | 'pathToDomainValuesAreNotStrings' | 'transformIsNotAFunction' | 'transformResultIsNotAValidObject' | 'transformCodeResultIsNotString' | 'transformNumberCodeResultIsNotNumber' | 'transformNumberCodeResultIsNaN' | 'transformMessageResultIsNotString' | 'transformDetailsResultIsNotString' | 'transformDomainResultIsNotString' | 'buildSummaryIsNullish' | 'buildSummaryIsNotAnObject' | 'generalBuildSummariesFromObjectError' | 'generalBuildSummaryFromObjectError' | 'generalCheckInputObjectForValuesError' | 'unknownCodeOrMessage' | 'invalidSummary';
+/**
+ * The {@link ErrorObjectProcessingError} type contains the error result and the error summary.
+ * It provides all the information needed to identify and troubleshoot the error that occurred during the process of building the error object.
+ */
+type ErrorObjectProcessingError = {
+    errorCode: ErrorObjectErrorResult;
+    summary?: ErrorSummary;
+};
+
+/**
+ * The {@link ErrorObjectFromPayload} class is an alternative way to create an {@link ErrorObject} from anything
+ * resembling an error, even request payloads. It also chains errors using the `.setNextErrors()` method.
+ */
+declare class ErrorObjectFromPayload extends ErrorObject {
+    static DEFAULT_FALLBACK_TAG: string;
+    nextErrors?: ErrorObjectFromPayload[];
+    constructor(props: any, withOptions?: Partial<ErrorObjectBuildOptions>);
+    static generic: () => ErrorObjectFromPayload;
+    protected _log(logTag: string, logLevel: 'log' | 'debug' | 'verbose'): this;
+    toVerboseString(): string;
+    /**
+     * This method allows users to check if an error is a fallback error, returned when an error could not be created from payload.
+     */
+    isFallback(): boolean;
+    private static checkInputForInitialObject;
+    private static processErrorObjectResult;
+}
+
+export { DEFAULT_BUILD_OPTIONS, type ErrorObjectBuildOptions, type ErrorObjectErrorResult, ErrorObjectFromPayload, type ErrorObjectProcessingError, type ErrorObjectTransformState, type ErrorSummary, addPrefixPathVariants };

package/dist/index.d.ts

@@ -122,13 +122,22 @@ type ErrorObjectProcessingError = {
 };
 
 /**
- * The {@link fromPayload()} method is an alternative way to create an {@link ErrorObject} from anything resembling an error.
- * It contains options for customizing how the input is processed and how the error is built.
- * Check out the {@link ErrorObjectBuildOptions} type for more details.
+ * The {@link ErrorObjectFromPayload} class is an alternative way to create an {@link ErrorObject} from anything
+ * resembling an error, even request payloads. It also chains errors using the `.setNextErrors()` method.
  */
-declare const fromPayload: (value: any, withOptions?: Partial<ErrorObjectBuildOptions>) => {
-    error?: ErrorObject;
-    force: ErrorObject;
-};
+declare class ErrorObjectFromPayload extends ErrorObject {
+    static DEFAULT_FALLBACK_TAG: string;
+    nextErrors?: ErrorObjectFromPayload[];
+    constructor(props: any, withOptions?: Partial<ErrorObjectBuildOptions>);
+    static generic: () => ErrorObjectFromPayload;
+    protected _log(logTag: string, logLevel: 'log' | 'debug' | 'verbose'): this;
+    toVerboseString(): string;
+    /**
+     * This method allows users to check if an error is a fallback error, returned when an error could not be created from payload.
+     */
+    isFallback(): boolean;
+    private static checkInputForInitialObject;
+    private static processErrorObjectResult;
+}
 
-export { DEFAULT_BUILD_OPTIONS, ErrorObjectBuildOptions, ErrorObjectErrorResult, ErrorObjectProcessingError, ErrorObjectTransformState, ErrorSummary, addPrefixPathVariants, fromPayload };
+export { DEFAULT_BUILD_OPTIONS, type ErrorObjectBuildOptions, type ErrorObjectErrorResult, ErrorObjectFromPayload, type ErrorObjectProcessingError, type ErrorObjectTransformState, type ErrorSummary, addPrefixPathVariants };

package/dist/index.js

@@ -35,13 +35,13 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   DEFAULT_BUILD_OPTIONS: () => DEFAULT_BUILD_OPTIONS,
-  addPrefixPathVariants: () => addPrefixPathVariants,
-  fromPayload: () => fromPayload
+  ErrorObjectFromPayload: () => ErrorObjectFromPayload,
+  addPrefixPathVariants: () => addPrefixPathVariants
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 var import_error_object2 = require("@smbcheeky/error-object");
 
 // src/builder/index.ts
@@ -50,9 +50,7 @@ var import_error_object = require("@smbcheeky/error-object");
 // src/utils.ts
 var addPrefixPathVariants = (prefix, array) => {
   if (typeof prefix === "string") {
-    return array.concat(
-      array.map((s) => typeof s === "string" ? `${prefix}.${s}` : s)
-    );
+    return array.concat(array.map((s) => typeof s === "string" ? `${prefix}.${s}` : s));
   }
   if (Array.isArray(prefix) && prefix.length > 0 && typeof (prefix == null ? void 0 : prefix[0]) === "string") {
     const result = [...array];
@@ -66,37 +64,16 @@ var addPrefixPathVariants = (prefix, array) => {
 };
 var DEFAULT_BUILD_OPTIONS = {
   pathToErrors: ["errors", "errs"],
-  pathToCode: addPrefixPathVariants("error", [
-    "code",
-    "err_code",
-    "errorCode",
-    "error_code"
-  ]),
+  pathToCode: addPrefixPathVariants("error", ["code", "err_code", "errorCode", "error_code"]),
   pathToNumberCode: addPrefixPathVariants("error", [
     "numberCode",
     "err_number_code",
     "errorNumberCode",
     "error_number_code"
   ]),
-  pathToMessage: addPrefixPathVariants("error", [
-    "message",
-    "err_message",
-    "errorMessage",
-    "error_message"
-  ]),
-  pathToDetails: addPrefixPathVariants("error", [
-    "details",
-    "err_details",
-    "errorDetails",
-    "error_details"
-  ]),
-  pathToDomain: addPrefixPathVariants("error", [
-    "domain",
-    "errorDomain",
-    "error_domain",
-    "err_domain",
-    "type"
-  ]),
+  pathToMessage: addPrefixPathVariants("error", ["message", "err_message", "errorMessage", "error_message"]),
+  pathToDetails: addPrefixPathVariants("error", ["details", "err_details", "errorDetails", "error_details"]),
+  pathToDomain: addPrefixPathVariants("error", ["domain", "errorDomain", "error_domain", "err_domain", "type"]),
   transform: (beforeTransform) => {
     let newCode = beforeTransform.code;
     if (beforeTransform.code === void 0 || beforeTransform.code === null) {
@@ -285,21 +262,12 @@ var buildSummariesFromObject = (input, withOptions) => {
     }
     let summaries = [];
     for (const errorMaybeObject of errors) {
-      const summary = buildSummaryFromObject(
-        errorMaybeObject,
-        errorsPath,
-        didDetectErrorsArray,
-        options
-      );
+      const summary = buildSummaryFromObject(errorMaybeObject, errorsPath, didDetectErrorsArray, options);
       summaries.push(summary);
     }
     return summaries;
   } catch (generalError) {
-    import_error_object.ErrorObject.SHOW_ERROR_LOGS && console.log(
-      "[ErrorObject]",
-      "Error during buildSummariesFromObject():",
-      generalError
-    );
+    import_error_object.ErrorObject.SHOW_ERROR_LOGS && console.log("[ErrorObject]", "Error during buildSummariesFromObject():", generalError);
     return ["generalBuildSummariesFromObjectError"];
   }
 };
@@ -409,11 +377,7 @@ var buildSummaryFromObject = (maybeObject, errorsPath, didDetectErrorsArray, wit
       }
     };
   } catch (generalError) {
-    import_error_object.ErrorObject.SHOW_ERROR_LOGS && console.log(
-      "[ErrorObject]",
-      "Error during buildSummaryFromObject():",
-      generalError
-    );
+    import_error_object.ErrorObject.SHOW_ERROR_LOGS && console.log("[ErrorObject]", "Error during buildSummaryFromObject():", generalError);
     return "generalBuildSummaryFromObjectError";
   }
 };
@@ -434,8 +398,116 @@ var findNestedValueForPath = (value, path) => {
 };
 
 // src/index.ts
-var checkInputForInitialObject = (input, withOptions) => {
-  try {
+var _ErrorObjectFromPayload = class _ErrorObjectFromPayload extends import_error_object2.ErrorObject {
+  constructor(props, withOptions) {
+    var _a, _b, _c, _d;
+    if ("code" in props && props.code !== void 0 && props.code !== null && typeof props.code === "string" && "message" in props && props.message !== void 0 && props.message !== null && typeof props.message === "string") {
+      super(props);
+    } else {
+      const options = __spreadValues(__spreadValues({}, DEFAULT_BUILD_OPTIONS), withOptions != null ? withOptions : {});
+      let checksFailed;
+      try {
+        checksFailed = _ErrorObjectFromPayload.checkInputForInitialObject(props, options);
+      } catch (error) {
+        super({
+          code: "INT-1",
+          message: `Error during checkInputForInitialObject(). Details: ${(_b = (_a = error == null ? void 0 : error.toString) == null ? void 0 : _a.call(error)) != null ? _b : import_error_object2.ErrorObject.GENERIC_MESSAGE}}`,
+          tag: _ErrorObjectFromPayload.DEFAULT_FALLBACK_TAG,
+          raw: {
+            error
+          }
+        });
+        return;
+      }
+      if (checksFailed !== void 0) {
+        super({
+          code: import_error_object2.ErrorObject.GENERIC_CODE,
+          message: import_error_object2.ErrorObject.GENERIC_MESSAGE,
+          tag: _ErrorObjectFromPayload.DEFAULT_FALLBACK_TAG,
+          raw: {
+            processingErrors: [{ errorCode: checksFailed, summary: void 0 }]
+          }
+        });
+        return;
+      }
+      try {
+        const { validErrors, summaries, processingErrors } = _ErrorObjectFromPayload.processErrorObjectResult(
+          props,
+          options
+        );
+        if (validErrors.length > 0) {
+          const [firstError, ...rawNextErrors] = validErrors;
+          if (firstError) {
+            super(__spreadProps(__spreadValues({}, firstError), {
+              raw: {
+                processingErrors,
+                summary: summaries,
+                value: props
+              }
+            }));
+            const nextErrors = rawNextErrors && (rawNextErrors == null ? void 0 : rawNextErrors.length) > 0 ? rawNextErrors.map((p) => new _ErrorObjectFromPayload(p)) : void 0;
+            if (nextErrors !== void 0) {
+              this.nextErrors = nextErrors;
+            }
+            return;
+          }
+        }
+        super({
+          code: import_error_object2.ErrorObject.GENERIC_CODE,
+          message: import_error_object2.ErrorObject.GENERIC_MESSAGE,
+          tag: _ErrorObjectFromPayload.DEFAULT_FALLBACK_TAG,
+          raw: {
+            processingErrors: processingErrors.length > 0 ? processingErrors : void 0,
+            summary: summaries
+          }
+        });
+      } catch (error) {
+        super({
+          code: "INT-2",
+          message: `Error during processErrorObjectResult(). Details: ${(_d = (_c = error == null ? void 0 : error.toString) == null ? void 0 : _c.call(error)) != null ? _d : import_error_object2.ErrorObject.GENERIC_MESSAGE}}`,
+          tag: _ErrorObjectFromPayload.DEFAULT_FALLBACK_TAG,
+          raw: {
+            error
+          }
+        });
+      }
+    }
+  }
+  _log(logTag, logLevel) {
+    const logForThis = logLevel === "verbose" ? this.toVerboseString() : logLevel === "debug" ? this.toDebugString() : this.toString();
+    if (Array.isArray(this.nextErrors) && this.nextErrors.length > 0) {
+      let row = 1;
+      import_error_object2.ErrorObject.LOG_METHOD && typeof import_error_object2.ErrorObject.LOG_METHOD === "function" && import_error_object2.ErrorObject.LOG_METHOD(`[${logTag}][${row}]`, logForThis);
+      for (const error of this.nextErrors) {
+        row++;
+        import_error_object2.ErrorObject.LOG_METHOD && typeof import_error_object2.ErrorObject.LOG_METHOD === "function" && import_error_object2.ErrorObject.LOG_METHOD(
+          `[${logTag}][${row}]`,
+          logLevel === "verbose" ? error.toVerboseString() : logLevel === "debug" ? error.toDebugString() : error.toString()
+        );
+      }
+    } else {
+      import_error_object2.ErrorObject.LOG_METHOD && typeof import_error_object2.ErrorObject.LOG_METHOD === "function" && import_error_object2.ErrorObject.LOG_METHOD(`[${logTag}]`, logForThis);
+    }
+    return this;
+  }
+  toVerboseString() {
+    return this.toDebugString() + `
+${JSON.stringify(
+      {
+        raw: this.raw,
+        nextErrors: this.nextErrors
+      },
+      null,
+      2
+    )}`;
+  }
+  /**
+   * This method allows users to check if an error is a fallback error, returned when an error could not be created from payload.
+   */
+  isFallback() {
+    return this.tag === _ErrorObjectFromPayload.DEFAULT_FALLBACK_TAG;
+  }
+  static checkInputForInitialObject(input, withOptions) {
     const options = withOptions != null ? withOptions : __spreadValues({}, DEFAULT_BUILD_OPTIONS);
     if (input === void 0 || input === null) {
       return "checkIsNullish";
@@ -447,9 +519,7 @@ var checkInputForInitialObject = (input, withOptions) => {
       if (typeof options.checkInputObjectForValues !== "object") {
         return "checkInputObjectForValuesIsNotAnObject";
       }
-      const checkInputObjectForValues = Object.entries(
-        options.checkInputObjectForValues
-      );
+      const checkInputObjectForValues = Object.entries(options.checkInputObjectForValues);
       for (const [key, rule] of checkInputObjectForValues) {
         const foundValue = findNestedValueForPath(input, key);
         if (rule.exists ? foundValue !== rule.value : foundValue === rule.value) {
@@ -461,9 +531,7 @@ var checkInputForInitialObject = (input, withOptions) => {
       if (typeof options.checkInputObjectForTypes !== "object") {
         return "checkInputObjectForTypesIsNotAnObject";
       }
-      const checkInputObjectForTypes = Object.entries(
-        options.checkInputObjectForTypes
-      );
+      const checkInputObjectForTypes = Object.entries(options.checkInputObjectForTypes);
       for (const [key, rule] of checkInputObjectForTypes) {
         const foundValue = findNestedValueForPath(input, key);
         if (rule.valueIsArray) {
@@ -480,9 +548,7 @@ var checkInputForInitialObject = (input, withOptions) => {
       if (typeof options.checkInputObjectForKeys !== "object") {
         return "checkInputObjectForKeysIsNotAnObject";
       }
-      const checkInputObjectForKeys = Object.entries(
-        options.checkInputObjectForKeys
-      );
+      const checkInputObjectForKeys = Object.entries(options.checkInputObjectForKeys);
       for (const [key, rule] of checkInputObjectForKeys) {
         const foundValue = findNestedValueForPath(input, key);
         if (rule.exists ? !foundValue : foundValue) {
@@ -490,18 +556,16 @@ var checkInputForInitialObject = (input, withOptions) => {
         }
       }
     }
-  } catch (error) {
-    import_error_object2.ErrorObject.SHOW_ERROR_LOGS && console.log(
-      "[ErrorObject]",
-      "Error during checkInputForInitialObject():",
-      error
-    );
+    return void 0;
   }
-  return void 0;
-};
-var processErrorObjectResult = (summaries, raw, fallbackError) => {
-  const processingErrors = [];
-  try {
+  static processErrorObjectResult(props, options) {
+    let summaries;
+    if ("pathToErrors" in options) {
+      summaries = buildSummariesFromObject(props, options);
+    } else {
+      summaries = [buildSummaryFromObject(props, void 0, false, options)];
+    }
+    const processingErrors = [];
     const validErrors = summaries.filter((summary) => {
       var _a, _b;
       if (typeof summary === "string") {
@@ -528,70 +592,43 @@ var processErrorObjectResult = (summaries, raw, fallbackError) => {
       var _a, _b, _c, _d, _e;
       const summary = s;
       const code = (_a = summary.value.code) == null ? void 0 : _a.value;
-      const numberCode = (_b = summary.value.numberCode) == null ? void 0 : _b.value;
-      const message = (_c = summary.value.message) == null ? void 0 : _c.value;
-      const details = (_d = summary.value.details) == null ? void 0 : _d.value;
-      const domain = (_e = summary.value.domain) == null ? void 0 : _e.value;
+      const message = (_b = summary.value.message) == null ? void 0 : _b.value;
       if (code !== void 0 && code !== null && typeof code === "string") {
         if (message !== void 0 && message !== null && typeof message === "string") {
-          return new import_error_object2.ErrorObject({
+          return {
             code,
             message,
-            numberCode,
-            details,
-            domain,
-            summary,
-            processingErrors
-          });
+            numberCode: (_c = summary.value.numberCode) == null ? void 0 : _c.value,
+            details: (_d = summary.value.details) == null ? void 0 : _d.value,
+            domain: (_e = summary.value.domain) == null ? void 0 : _e.value,
+            raw: {
+              value: props,
+              processingErrors,
+              summary
+            }
+          };
         }
       }
       return null;
-    }).filter(
-      (s) => s !== null && s !== void 0 && s instanceof import_error_object2.ErrorObject
-    );
-    if (validErrors.length > 0) {
-      const [firstError, ...nextErrors] = validErrors;
-      const error = firstError.setNextErrors((nextErrors == null ? void 0 : nextErrors.length) > 0 ? nextErrors : void 0).setRaw(raw);
-      return {
-        error,
-        force: error != null ? error : fallbackError.setProcessingErrors(processingErrors)
-      };
-    }
-  } catch (error) {
-    import_error_object2.ErrorObject.SHOW_ERROR_LOGS && console.log(
-      "[ErrorObject]",
-      "Error during processErrorObjectResult():",
-      error
-    );
-  }
-  return {
-    error: void 0,
-    force: processingErrors.length > 0 ? fallbackError.setProcessingErrors(processingErrors) : fallbackError
-  };
-};
-var fromPayload = (value, withOptions) => {
-  const options = __spreadValues(__spreadValues({}, DEFAULT_BUILD_OPTIONS), withOptions != null ? withOptions : {});
-  const fallbackError = import_error_object2.ErrorObject.fallback().setRaw(value);
-  const checksFailed = checkInputForInitialObject(value, options);
-  if (checksFailed !== void 0) {
+    }).filter((s) => s !== null && s !== void 0);
     return {
-      error: void 0,
-      force: fallbackError.setProcessingErrors([
-        { errorCode: checksFailed, summary: void 0 }
-      ])
+      validErrors,
+      summaries,
+      processingErrors
     };
   }
-  let summaries;
-  if ("pathToErrors" in options) {
-    summaries = buildSummariesFromObject(value, options);
-  } else {
-    summaries = [buildSummaryFromObject(value, void 0, false, options)];
-  }
-  return processErrorObjectResult(summaries, value, fallbackError);
 };
+_ErrorObjectFromPayload.DEFAULT_FALLBACK_TAG = "fallback-error-object";
+// Overrides
+_ErrorObjectFromPayload.generic = () => new _ErrorObjectFromPayload({
+  code: import_error_object2.ErrorObject.GENERIC_CODE,
+  message: import_error_object2.ErrorObject.GENERIC_MESSAGE,
+  tag: import_error_object2.ErrorObject.GENERIC_TAG
+});
+var ErrorObjectFromPayload = _ErrorObjectFromPayload;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_BUILD_OPTIONS,
-  addPrefixPathVariants,
-  fromPayload
+  ErrorObjectFromPayload,
+  addPrefixPathVariants
 });

package/dist/index.mjs

@@ -27,9 +27,7 @@ import { ErrorObject } from "@smbcheeky/error-object";
 // src/utils.ts
 var addPrefixPathVariants = (prefix, array) => {
   if (typeof prefix === "string") {
-    return array.concat(
-      array.map((s) => typeof s === "string" ? `${prefix}.${s}` : s)
-    );
+    return array.concat(array.map((s) => typeof s === "string" ? `${prefix}.${s}` : s));
   }
   if (Array.isArray(prefix) && prefix.length > 0 && typeof (prefix == null ? void 0 : prefix[0]) === "string") {
     const result = [...array];
@@ -43,37 +41,16 @@ var addPrefixPathVariants = (prefix, array) => {
 };
 var DEFAULT_BUILD_OPTIONS = {
   pathToErrors: ["errors", "errs"],
-  pathToCode: addPrefixPathVariants("error", [
-    "code",
-    "err_code",
-    "errorCode",
-    "error_code"
-  ]),
+  pathToCode: addPrefixPathVariants("error", ["code", "err_code", "errorCode", "error_code"]),
   pathToNumberCode: addPrefixPathVariants("error", [
     "numberCode",
     "err_number_code",
     "errorNumberCode",
     "error_number_code"
   ]),
-  pathToMessage: addPrefixPathVariants("error", [
-    "message",
-    "err_message",
-    "errorMessage",
-    "error_message"
-  ]),
-  pathToDetails: addPrefixPathVariants("error", [
-    "details",
-    "err_details",
-    "errorDetails",
-    "error_details"
-  ]),
-  pathToDomain: addPrefixPathVariants("error", [
-    "domain",
-    "errorDomain",
-    "error_domain",
-    "err_domain",
-    "type"
-  ]),
+  pathToMessage: addPrefixPathVariants("error", ["message", "err_message", "errorMessage", "error_message"]),
+  pathToDetails: addPrefixPathVariants("error", ["details", "err_details", "errorDetails", "error_details"]),
+  pathToDomain: addPrefixPathVariants("error", ["domain", "errorDomain", "error_domain", "err_domain", "type"]),
   transform: (beforeTransform) => {
     let newCode = beforeTransform.code;
     if (beforeTransform.code === void 0 || beforeTransform.code === null) {
@@ -262,21 +239,12 @@ var buildSummariesFromObject = (input, withOptions) => {
     }
     let summaries = [];
     for (const errorMaybeObject of errors) {
-      const summary = buildSummaryFromObject(
-        errorMaybeObject,
-        errorsPath,
-        didDetectErrorsArray,
-        options
-      );
+      const summary = buildSummaryFromObject(errorMaybeObject, errorsPath, didDetectErrorsArray, options);
       summaries.push(summary);
     }
     return summaries;
   } catch (generalError) {
-    ErrorObject.SHOW_ERROR_LOGS && console.log(
-      "[ErrorObject]",
-      "Error during buildSummariesFromObject():",
-      generalError
-    );
+    ErrorObject.SHOW_ERROR_LOGS && console.log("[ErrorObject]", "Error during buildSummariesFromObject():", generalError);
     return ["generalBuildSummariesFromObjectError"];
   }
 };
@@ -386,11 +354,7 @@ var buildSummaryFromObject = (maybeObject, errorsPath, didDetectErrorsArray, wit
       }
     };
   } catch (generalError) {
-    ErrorObject.SHOW_ERROR_LOGS && console.log(
-      "[ErrorObject]",
-      "Error during buildSummaryFromObject():",
-      generalError
-    );
+    ErrorObject.SHOW_ERROR_LOGS && console.log("[ErrorObject]", "Error during buildSummaryFromObject():", generalError);
     return "generalBuildSummaryFromObjectError";
   }
 };
@@ -411,8 +375,116 @@ var findNestedValueForPath = (value, path) => {
 };
 
 // src/index.ts
-var checkInputForInitialObject = (input, withOptions) => {
-  try {
+var _ErrorObjectFromPayload = class _ErrorObjectFromPayload extends ErrorObject2 {
+  constructor(props, withOptions) {
+    var _a, _b, _c, _d;
+    if ("code" in props && props.code !== void 0 && props.code !== null && typeof props.code === "string" && "message" in props && props.message !== void 0 && props.message !== null && typeof props.message === "string") {
+      super(props);
+    } else {
+      const options = __spreadValues(__spreadValues({}, DEFAULT_BUILD_OPTIONS), withOptions != null ? withOptions : {});
+      let checksFailed;
+      try {
+        checksFailed = _ErrorObjectFromPayload.checkInputForInitialObject(props, options);
+      } catch (error) {
+        super({
+          code: "INT-1",
+          message: `Error during checkInputForInitialObject(). Details: ${(_b = (_a = error == null ? void 0 : error.toString) == null ? void 0 : _a.call(error)) != null ? _b : ErrorObject2.GENERIC_MESSAGE}}`,
+          tag: _ErrorObjectFromPayload.DEFAULT_FALLBACK_TAG,
+          raw: {
+            error
+          }
+        });
+        return;
+      }
+      if (checksFailed !== void 0) {
+        super({
+          code: ErrorObject2.GENERIC_CODE,
+          message: ErrorObject2.GENERIC_MESSAGE,
+          tag: _ErrorObjectFromPayload.DEFAULT_FALLBACK_TAG,
+          raw: {
+            processingErrors: [{ errorCode: checksFailed, summary: void 0 }]
+          }
+        });
+        return;
+      }
+      try {
+        const { validErrors, summaries, processingErrors } = _ErrorObjectFromPayload.processErrorObjectResult(
+          props,
+          options
+        );
+        if (validErrors.length > 0) {
+          const [firstError, ...rawNextErrors] = validErrors;
+          if (firstError) {
+            super(__spreadProps(__spreadValues({}, firstError), {
+              raw: {
+                processingErrors,
+                summary: summaries,
+                value: props
+              }
+            }));
+            const nextErrors = rawNextErrors && (rawNextErrors == null ? void 0 : rawNextErrors.length) > 0 ? rawNextErrors.map((p) => new _ErrorObjectFromPayload(p)) : void 0;
+            if (nextErrors !== void 0) {
+              this.nextErrors = nextErrors;
+            }
+            return;
+          }
+        }
+        super({
+          code: ErrorObject2.GENERIC_CODE,
+          message: ErrorObject2.GENERIC_MESSAGE,
+          tag: _ErrorObjectFromPayload.DEFAULT_FALLBACK_TAG,
+          raw: {
+            processingErrors: processingErrors.length > 0 ? processingErrors : void 0,
+            summary: summaries
+          }
+        });
+      } catch (error) {
+        super({
+          code: "INT-2",
+          message: `Error during processErrorObjectResult(). Details: ${(_d = (_c = error == null ? void 0 : error.toString) == null ? void 0 : _c.call(error)) != null ? _d : ErrorObject2.GENERIC_MESSAGE}}`,
+          tag: _ErrorObjectFromPayload.DEFAULT_FALLBACK_TAG,
+          raw: {
+            error
+          }
+        });
+      }
+    }
+  }
+  _log(logTag, logLevel) {
+    const logForThis = logLevel === "verbose" ? this.toVerboseString() : logLevel === "debug" ? this.toDebugString() : this.toString();
+    if (Array.isArray(this.nextErrors) && this.nextErrors.length > 0) {
+      let row = 1;
+      ErrorObject2.LOG_METHOD && typeof ErrorObject2.LOG_METHOD === "function" && ErrorObject2.LOG_METHOD(`[${logTag}][${row}]`, logForThis);
+      for (const error of this.nextErrors) {
+        row++;
+        ErrorObject2.LOG_METHOD && typeof ErrorObject2.LOG_METHOD === "function" && ErrorObject2.LOG_METHOD(
+          `[${logTag}][${row}]`,
+          logLevel === "verbose" ? error.toVerboseString() : logLevel === "debug" ? error.toDebugString() : error.toString()
+        );
+      }
+    } else {
+      ErrorObject2.LOG_METHOD && typeof ErrorObject2.LOG_METHOD === "function" && ErrorObject2.LOG_METHOD(`[${logTag}]`, logForThis);
+    }
+    return this;
+  }
+  toVerboseString() {
+    return this.toDebugString() + `
+${JSON.stringify(
+      {
+        raw: this.raw,
+        nextErrors: this.nextErrors
+      },
+      null,
+      2
+    )}`;
+  }
+  /**
+   * This method allows users to check if an error is a fallback error, returned when an error could not be created from payload.
+   */
+  isFallback() {
+    return this.tag === _ErrorObjectFromPayload.DEFAULT_FALLBACK_TAG;
+  }
+  static checkInputForInitialObject(input, withOptions) {
     const options = withOptions != null ? withOptions : __spreadValues({}, DEFAULT_BUILD_OPTIONS);
     if (input === void 0 || input === null) {
       return "checkIsNullish";
@@ -424,9 +496,7 @@ var checkInputForInitialObject = (input, withOptions) => {
       if (typeof options.checkInputObjectForValues !== "object") {
         return "checkInputObjectForValuesIsNotAnObject";
       }
-      const checkInputObjectForValues = Object.entries(
-        options.checkInputObjectForValues
-      );
+      const checkInputObjectForValues = Object.entries(options.checkInputObjectForValues);
       for (const [key, rule] of checkInputObjectForValues) {
         const foundValue = findNestedValueForPath(input, key);
         if (rule.exists ? foundValue !== rule.value : foundValue === rule.value) {
@@ -438,9 +508,7 @@ var checkInputForInitialObject = (input, withOptions) => {
       if (typeof options.checkInputObjectForTypes !== "object") {
         return "checkInputObjectForTypesIsNotAnObject";
       }
-      const checkInputObjectForTypes = Object.entries(
-        options.checkInputObjectForTypes
-      );
+      const checkInputObjectForTypes = Object.entries(options.checkInputObjectForTypes);
       for (const [key, rule] of checkInputObjectForTypes) {
         const foundValue = findNestedValueForPath(input, key);
         if (rule.valueIsArray) {
@@ -457,9 +525,7 @@ var checkInputForInitialObject = (input, withOptions) => {
       if (typeof options.checkInputObjectForKeys !== "object") {
         return "checkInputObjectForKeysIsNotAnObject";
       }
-      const checkInputObjectForKeys = Object.entries(
-        options.checkInputObjectForKeys
-      );
+      const checkInputObjectForKeys = Object.entries(options.checkInputObjectForKeys);
       for (const [key, rule] of checkInputObjectForKeys) {
         const foundValue = findNestedValueForPath(input, key);
         if (rule.exists ? !foundValue : foundValue) {
@@ -467,18 +533,16 @@ var checkInputForInitialObject = (input, withOptions) => {
         }
       }
     }
-  } catch (error) {
-    ErrorObject2.SHOW_ERROR_LOGS && console.log(
-      "[ErrorObject]",
-      "Error during checkInputForInitialObject():",
-      error
-    );
+    return void 0;
   }
-  return void 0;
-};
-var processErrorObjectResult = (summaries, raw, fallbackError) => {
-  const processingErrors = [];
-  try {
+  static processErrorObjectResult(props, options) {
+    let summaries;
+    if ("pathToErrors" in options) {
+      summaries = buildSummariesFromObject(props, options);
+    } else {
+      summaries = [buildSummaryFromObject(props, void 0, false, options)];
+    }
+    const processingErrors = [];
     const validErrors = summaries.filter((summary) => {
       var _a, _b;
       if (typeof summary === "string") {
@@ -505,69 +569,42 @@ var processErrorObjectResult = (summaries, raw, fallbackError) => {
       var _a, _b, _c, _d, _e;
       const summary = s;
       const code = (_a = summary.value.code) == null ? void 0 : _a.value;
-      const numberCode = (_b = summary.value.numberCode) == null ? void 0 : _b.value;
-      const message = (_c = summary.value.message) == null ? void 0 : _c.value;
-      const details = (_d = summary.value.details) == null ? void 0 : _d.value;
-      const domain = (_e = summary.value.domain) == null ? void 0 : _e.value;
+      const message = (_b = summary.value.message) == null ? void 0 : _b.value;
       if (code !== void 0 && code !== null && typeof code === "string") {
         if (message !== void 0 && message !== null && typeof message === "string") {
-          return new ErrorObject2({
+          return {
             code,
             message,
-            numberCode,
-            details,
-            domain,
-            summary,
-            processingErrors
-          });
+            numberCode: (_c = summary.value.numberCode) == null ? void 0 : _c.value,
+            details: (_d = summary.value.details) == null ? void 0 : _d.value,
+            domain: (_e = summary.value.domain) == null ? void 0 : _e.value,
+            raw: {
+              value: props,
+              processingErrors,
+              summary
+            }
+          };
         }
       }
       return null;
-    }).filter(
-      (s) => s !== null && s !== void 0 && s instanceof ErrorObject2
-    );
-    if (validErrors.length > 0) {
-      const [firstError, ...nextErrors] = validErrors;
-      const error = firstError.setNextErrors((nextErrors == null ? void 0 : nextErrors.length) > 0 ? nextErrors : void 0).setRaw(raw);
-      return {
-        error,
-        force: error != null ? error : fallbackError.setProcessingErrors(processingErrors)
-      };
-    }
-  } catch (error) {
-    ErrorObject2.SHOW_ERROR_LOGS && console.log(
-      "[ErrorObject]",
-      "Error during processErrorObjectResult():",
-      error
-    );
-  }
-  return {
-    error: void 0,
-    force: processingErrors.length > 0 ? fallbackError.setProcessingErrors(processingErrors) : fallbackError
-  };
-};
-var fromPayload = (value, withOptions) => {
-  const options = __spreadValues(__spreadValues({}, DEFAULT_BUILD_OPTIONS), withOptions != null ? withOptions : {});
-  const fallbackError = ErrorObject2.fallback().setRaw(value);
-  const checksFailed = checkInputForInitialObject(value, options);
-  if (checksFailed !== void 0) {
+    }).filter((s) => s !== null && s !== void 0);
     return {
-      error: void 0,
-      force: fallbackError.setProcessingErrors([
-        { errorCode: checksFailed, summary: void 0 }
-      ])
+      validErrors,
+      summaries,
+      processingErrors
     };
   }
-  let summaries;
-  if ("pathToErrors" in options) {
-    summaries = buildSummariesFromObject(value, options);
-  } else {
-    summaries = [buildSummaryFromObject(value, void 0, false, options)];
-  }
-  return processErrorObjectResult(summaries, value, fallbackError);
 };
+_ErrorObjectFromPayload.DEFAULT_FALLBACK_TAG = "fallback-error-object";
+// Overrides
+_ErrorObjectFromPayload.generic = () => new _ErrorObjectFromPayload({
+  code: ErrorObject2.GENERIC_CODE,
+  message: ErrorObject2.GENERIC_MESSAGE,
+  tag: ErrorObject2.GENERIC_TAG
+});
+var ErrorObjectFromPayload = _ErrorObjectFromPayload;
 export {
   DEFAULT_BUILD_OPTIONS,
-  addPrefixPathVariants,
-  fromPayload
+  ErrorObjectFromPayload,
+  addPrefixPathVariants
 };

package/package.json

@@ -1,22 +1,23 @@
 {
   "name": "@smbcheeky/error-object-from-payload",
   "description": "Create ErrorObjects from any payload with simple rules and benefit from step-to-step debugging logs for the entire process.",
-  "version": "1.1.6",
+  "version": "1.2.0",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts",
     "pack": "yarn build && npm pack",
-    "release": "yarn build && npm publish --access public",
+    "release": "yarn build && npm login && npm publish --access public",
     "lint": "tsc --noEmit"
   },
   "dependencies": {
-    "@smbcheeky/error-object": "^1.1.5"
+    "@smbcheeky/error-object": "1.2.0"
   },
   "devDependencies": {
-    "tsup": "^6.5.0",
-    "typescript": "^4.9.4"
+    "tsup": "8.3.5",
+    "typescript": "^4.9.4",
+    "prettier": "^3.7.4"
   },
   "license": "MIT",
   "private": false,