generic-result-type 2.0.0 → 2.2.1

package/README.md

@@ -17,7 +17,7 @@ This package supports **both ESM and CommonJS** out of the box.
 ESM:
 
 ```ts
-import { success, fail } from 'generic-result-type';
+import { success, fail, type Result } from 'generic-result-type';
 ```
 
 CommonJS:
@@ -68,6 +68,21 @@ console.log('Value:', result.value);
 
 TypeScript will correctly narrow the type inside each branch without casting.
 
+### Mapping
+
+You can map the value or the error of a Result with these methods:
+
+* map
+* mapErr
+* mapAsync
+* mapErrAsync
+
+```ts
+const numberResult = getSomeNumberResult().map(x => x * 2);
+
+const responseResult = await getSomeStringResult().mapAsync(async x => fetch(x));
+```
+
 ## License
 
 ISC

package/dist/index.cjs

@@ -22,6 +22,7 @@ var index_exports = {};
 __export(index_exports, {
   combine: () => combine,
   fail: () => fail,
+  flatten: () => flatten,
   isErrorResult: () => isErrorResult,
   isSuccessResult: () => isSuccessResult,
   success: () => success
@@ -34,20 +35,42 @@ var ErrorResult = class _ErrorResult {
     this.error = error;
     this.success = false;
   }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters
   map(mapFunction) {
+    return new _ErrorResult(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async
+  mapAsync(mapFunction) {
+    return Promise.resolve(new _ErrorResult(this.error));
+  }
+  mapErr(mapFunction) {
     return new _ErrorResult(mapFunction(this.error));
   }
+  async mapErrAsync(mapFunction) {
+    return new _ErrorResult(await mapFunction(this.error));
+  }
 };
 
 // src/successResult.mts
 var SuccessResult = class _SuccessResult {
   constructor(value) {
-    this.value = value;
     this.success = true;
+    this.value = value;
   }
   map(mapFunction) {
     return new _SuccessResult(mapFunction(this.value));
   }
+  async mapAsync(mapFunction) {
+    return new _SuccessResult(await mapFunction(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters
+  mapErr(mapFunction) {
+    return new _SuccessResult(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async
+  mapErrAsync(mapFunction) {
+    return Promise.resolve(new _SuccessResult(this.value));
+  }
 };
 
 // src/index.mts
@@ -63,18 +86,54 @@ var isSuccessResult = (result) => {
 var isErrorResult = (result) => {
   return !result.success;
 };
-function combine(...results) {
+function combine(results) {
+  const values = [];
+  const errors = [];
   for (const r of results) {
-    if (!r.success) {
-      return r;
+    if (r.success) {
+      values.push(r.value);
+    } else {
+      errors.push(r.error);
     }
   }
-  return new SuccessResult(void 0);
+  if (errors.length) {
+    return new ErrorResult(errors);
+  }
+  return new SuccessResult(values);
 }
+var flatten = (result) => {
+  if (isSuccessResult(result)) {
+    return getValue(result);
+  }
+  return getError(result);
+};
+var getValue = (result) => {
+  if (result.value instanceof SuccessResult) {
+    return getValue(result.value);
+  }
+  if (result.value instanceof ErrorResult) {
+    return getError(result.value);
+  }
+  return result;
+};
+var getError = (result) => {
+  if (result.error instanceof SuccessResult) {
+    const value = getValue(result.error);
+    if (isSuccessResult(value)) {
+      return fail(value);
+    }
+    return value;
+  }
+  if (result.error instanceof ErrorResult) {
+    return getError(result.error);
+  }
+  return result;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   combine,
   fail,
+  flatten,
   isErrorResult,
   isSuccessResult,
   success

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.mts","../src/errorResult.mts","../src/successResult.mts"],"sourcesContent":["import type { IErrorResult } from './errorResult.mjs';\nimport { ErrorResult } from './errorResult.mjs';\nimport type { ISuccessResult } from './successResult.mjs';\nimport { SuccessResult } from './successResult.mjs';\n\nexport type { ISuccessResult };\nexport type { IErrorResult };\n\nexport type ResultType<T = void, E = Error> = ISuccessResult<T> | IErrorResult<E>;\n\nexport function success(): ISuccessResult;\nexport function success<T>(value: T): ISuccessResult<T>;\nexport function success<T>(value?: T): ISuccessResult<T> {\n  return new SuccessResult(value as T);\n};\n\nexport function fail<E>(error: E): IErrorResult<E> {\n  return new ErrorResult(error);\n}\n\nexport const isSuccessResult = <T, E = Error>(result: ResultType<T, E>): result is ISuccessResult<T> => {\n  return result.success;\n};\n\nexport const isErrorResult = <T, E = Error>(result: ResultType<T, E>): result is IErrorResult<E> => {\n  return !result.success;\n};\n\nexport function combine(...results: ResultType[]): ResultType {\n  for (const r of results) {\n    if (!r.success) {\n      return r;\n    }\n  }\n  return new SuccessResult(undefined);\n}\n","export interface IErrorResult<E = Error> {\n  readonly success: false;\n  readonly error: E;\n  readonly map: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;\n}\n\nexport class ErrorResult<E> implements IErrorResult<E> {\n  public readonly success = false as const;\n\n  public constructor(public readonly error: E) { /* empty */ }\n\n  public map<M>(mapFunction: (error: E) => M): ErrorResult<M> {\n    return new ErrorResult(mapFunction(this.error));\n  }\n}\n","export interface ISuccessResult<T = void> {\n  readonly success: true;\n  readonly value: T;\n  readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;\n}\n\nexport class SuccessResult<T = void> implements ISuccessResult<T> {\n  public readonly success = true as const;\n\n  public constructor(public readonly value: T) { /* empty */ }\n\n  public map<M>(mapFunction: (value: T) => M): SuccessResult<M> {\n    return new SuccessResult(mapFunction(this.value));\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACMO,IAAM,cAAN,MAAM,aAA0C;AAAA,EAG9C,YAA4B,OAAU;AAAV;AAFnC,SAAgB,UAAU;AAAA,EAEiC;AAAA,EAEpD,IAAO,aAA8C;AAC1D,WAAO,IAAI,aAAY,YAAY,KAAK,KAAK,CAAC;AAAA,EAChD;AACF;;;ACRO,IAAM,gBAAN,MAAM,eAAqD;AAAA,EAGzD,YAA4B,OAAU;AAAV;AAFnC,SAAgB,UAAU;AAAA,EAEiC;AAAA,EAEpD,IAAO,aAAgD;AAC5D,WAAO,IAAI,eAAc,YAAY,KAAK,KAAK,CAAC;AAAA,EAClD;AACF;;;AFFO,SAAS,QAAW,OAA8B;AACvD,SAAO,IAAI,cAAc,KAAU;AACrC;AAEO,SAAS,KAAQ,OAA2B;AACjD,SAAO,IAAI,YAAY,KAAK;AAC9B;AAEO,IAAM,kBAAkB,CAAe,WAA0D;AACtG,SAAO,OAAO;AAChB;AAEO,IAAM,gBAAgB,CAAe,WAAwD;AAClG,SAAO,CAAC,OAAO;AACjB;AAEO,SAAS,WAAW,SAAmC;AAC5D,aAAW,KAAK,SAAS;AACvB,QAAI,CAAC,EAAE,SAAS;AACd,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO,IAAI,cAAc,MAAS;AACpC;","names":[]}
+{"version":3,"sources":["../src/index.mts","../src/errorResult.mts","../src/successResult.mts"],"sourcesContent":["import type { IErrorResult } from './errorResult.mjs';\nimport { ErrorResult } from './errorResult.mjs';\nimport type { Result } from './result.mjs';\nimport type { ISuccessResult } from './successResult.mjs';\nimport { SuccessResult } from './successResult.mjs';\n\nexport type { Result, ISuccessResult, IErrorResult };\n\nexport function success(): ISuccessResult;\nexport function success<T>(value: T): ISuccessResult<T>;\nexport function success<T>(value?: T): ISuccessResult<T> {\n  return new SuccessResult(value as T);\n};\n\nexport function fail<E>(error: E): IErrorResult<E> {\n  return new ErrorResult(error);\n}\n\nexport const isSuccessResult = <T, E = Error>(result: Result<T, E>): result is ISuccessResult<T> => {\n  return result.success;\n};\n\nexport const isErrorResult = <T, E = Error>(result: Result<T, E>): result is IErrorResult<E> => {\n  return !result.success;\n};\n\nexport function combine(results: Result<unknown, unknown>[]): Result<unknown[], unknown[]> {\n  const values: unknown[] = [];\n  const errors: unknown[] = [];\n\n  for (const r of results) {\n    if (r.success) {\n      values.push(r.value);\n    } else {\n      errors.push(r.error);\n    }\n  }\n\n  if (errors.length) {\n    return new ErrorResult(errors);\n  }\n  return new SuccessResult(values);\n}\n\nexport const flatten = (result: Result<unknown, unknown>): Result<unknown, unknown> => {\n  if (isSuccessResult(result)) {\n    return getValue(result);\n  }\n  return getError(result);\n};\n\nconst getValue = (result: SuccessResult<unknown>): Result<unknown, unknown> => {\n  // value is a SuccessResult, drill down\n  if (result.value instanceof SuccessResult) {\n    return getValue(result.value);\n  }\n\n  // value is an ErrorResult, drill down\n  if (result.value instanceof ErrorResult) {\n    return getError(result.value);\n  }\n\n  // value is not a Result, return current SuccessResult\n  return result;\n};\n\nconst getError = (result: ErrorResult<unknown>): ErrorResult<unknown> => {\n  // error is a SuccessResult, consider this SuccessResult's value\n  if (result.error instanceof SuccessResult) {\n    const value = getValue(result.error);\n\n    // if the value is a SuccessResult, swallow it into an error\n    if (isSuccessResult(value)) {\n      return fail(value);\n    }\n\n    // otherwise the value is an ErrorResult, return it\n    return value;\n  }\n\n  // error is an ErrorResult, swallow it\n  if (result.error instanceof ErrorResult) {\n    return getError(result.error);\n  }\n\n  // error is not a Result, the current ErrorResult\n  return result;\n};\n","import type { IResult } from './result.mjs';\n\nexport interface IErrorResult<E = Error> extends IResult<never, E> {\n  readonly success: false;\n  readonly error: E;\n\n  /**\n   * Returns a new `ErrorResult` with the same `error` property as this one.\n   *\n   * @param mapFunction the mapping function\n   * @returns a new `ErrorResult`\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n  readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;\n\n  /**\n   * Asynchronously returns a new `ErrorResult` with the same `error` property as this one.\n   * @param mapFunction the mapping function\n   * @returns a new `ErrorResult`\n   */\n  readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;\n\n  /**\n   * Calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.\n   *\n   * @param mapFunction the mapping function\n   * @returns a new `ErrorResult`\n   */\n  readonly mapErr: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;\n\n  /**\n   * Asynchronously calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.\n   *\n   * @param mapFunction the mapping function\n   * @returns a new `ErrorResult`\n   */\n  readonly mapErrAsync: <M>(mapFunction: (value: E) => Promise<M>) => Promise<IErrorResult<M>>;\n}\n\nexport class ErrorResult<E> implements IResult<never, E>, IErrorResult<E> {\n  public readonly success = false as const;\n\n  public constructor(public readonly error: E) { /* empty */ }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters\n  public map<M>(mapFunction: (error: never) => M): ErrorResult<E> {\n    return new ErrorResult(this.error);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async\n  public mapAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<ErrorResult<E>> {\n    return Promise.resolve(new ErrorResult(this.error));\n  }\n\n  public mapErr<M>(mapFunction: (error: E) => M): ErrorResult<M> {\n    return new ErrorResult(mapFunction(this.error));\n  }\n\n  public async mapErrAsync<M>(mapFunction: (value: E) => Promise<M>): Promise<ErrorResult<M>> {\n    return new ErrorResult(await mapFunction(this.error));\n  }\n}\n","import type { IResult } from './result.mjs';\n\nexport interface ISuccessResult<T = void> {\n  readonly success: true;\n  readonly value: T;\n\n  /**\n   * Calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.\n   *\n   * @param mapFunction the mapping function\n   * @returns a new `SuccessResult`\n   */\n  readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;\n\n  /**\n   * Asynchronously calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.\n   * @param mapFunction the mapping function\n   * @returns a new `SuccessResult`\n   */\n  readonly mapAsync: <M>(mapFunction: (value: T) => Promise<M>) => Promise<ISuccessResult<M>>;\n\n  /**\n   * Returns a new `SuccessResult` with the same `value` property as this one.\n   *\n   * @param mapFunction the mapping function\n   * @returns a new `SuccessResult`\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n  readonly mapErr: <M>(mapFunction: (value: never) => M) => ISuccessResult<T>;\n\n  /**\n   * Asynchronously returns a new `SuccessResult` with the same `value` property as this one.\n   *\n   * @param mapFunction the mapping function\n   * @returns a new `SuccessResult`\n   */\n  readonly mapErrAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<ISuccessResult<T>>;\n}\n\nexport class SuccessResult<T = void> implements IResult<T, never>, ISuccessResult<T> {\n  public readonly success = true as const;\n  public readonly value: T;\n\n  public constructor(value?: T) {\n    this.value = value as T;\n  }\n\n  public map<M>(mapFunction: (value: T) => M): SuccessResult<M> {\n    return new SuccessResult(mapFunction(this.value));\n  }\n\n  public async mapAsync<M>(mapFunction: (value: T) => Promise<M>): Promise<SuccessResult<M>> {\n    return new SuccessResult(await mapFunction(this.value));\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters\n  public mapErr<M>(mapFunction: (error: never) => M): SuccessResult<T> {\n    return new SuccessResult(this.value);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async\n  public mapErrAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<SuccessResult<T>> {\n    return Promise.resolve(new SuccessResult(this.value));\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACuCO,IAAM,cAAN,MAAM,aAA6D;AAAA,EAGjE,YAA4B,OAAU;AAAV;AAFnC,SAAgB,UAAU;AAAA,EAEiC;AAAA;AAAA,EAGpD,IAAO,aAAkD;AAC9D,WAAO,IAAI,aAAY,KAAK,KAAK;AAAA,EACnC;AAAA;AAAA,EAGO,SAAY,aAAoE;AACrF,WAAO,QAAQ,QAAQ,IAAI,aAAY,KAAK,KAAK,CAAC;AAAA,EACpD;AAAA,EAEO,OAAU,aAA8C;AAC7D,WAAO,IAAI,aAAY,YAAY,KAAK,KAAK,CAAC;AAAA,EAChD;AAAA,EAEA,MAAa,YAAe,aAAgE;AAC1F,WAAO,IAAI,aAAY,MAAM,YAAY,KAAK,KAAK,CAAC;AAAA,EACtD;AACF;;;ACtBO,IAAM,gBAAN,MAAM,eAAwE;AAAA,EAI5E,YAAY,OAAW;AAH9B,SAAgB,UAAU;AAIxB,SAAK,QAAQ;AAAA,EACf;AAAA,EAEO,IAAO,aAAgD;AAC5D,WAAO,IAAI,eAAc,YAAY,KAAK,KAAK,CAAC;AAAA,EAClD;AAAA,EAEA,MAAa,SAAY,aAAkE;AACzF,WAAO,IAAI,eAAc,MAAM,YAAY,KAAK,KAAK,CAAC;AAAA,EACxD;AAAA;AAAA,EAGO,OAAU,aAAoD;AACnE,WAAO,IAAI,eAAc,KAAK,KAAK;AAAA,EACrC;AAAA;AAAA,EAGO,YAAe,aAAsE;AAC1F,WAAO,QAAQ,QAAQ,IAAI,eAAc,KAAK,KAAK,CAAC;AAAA,EACtD;AACF;;;AFtDO,SAAS,QAAW,OAA8B;AACvD,SAAO,IAAI,cAAc,KAAU;AACrC;AAEO,SAAS,KAAQ,OAA2B;AACjD,SAAO,IAAI,YAAY,KAAK;AAC9B;AAEO,IAAM,kBAAkB,CAAe,WAAsD;AAClG,SAAO,OAAO;AAChB;AAEO,IAAM,gBAAgB,CAAe,WAAoD;AAC9F,SAAO,CAAC,OAAO;AACjB;AAEO,SAAS,QAAQ,SAAmE;AACzF,QAAM,SAAoB,CAAC;AAC3B,QAAM,SAAoB,CAAC;AAE3B,aAAW,KAAK,SAAS;AACvB,QAAI,EAAE,SAAS;AACb,aAAO,KAAK,EAAE,KAAK;AAAA,IACrB,OAAO;AACL,aAAO,KAAK,EAAE,KAAK;AAAA,IACrB;AAAA,EACF;AAEA,MAAI,OAAO,QAAQ;AACjB,WAAO,IAAI,YAAY,MAAM;AAAA,EAC/B;AACA,SAAO,IAAI,cAAc,MAAM;AACjC;AAEO,IAAM,UAAU,CAAC,WAA+D;AACrF,MAAI,gBAAgB,MAAM,GAAG;AAC3B,WAAO,SAAS,MAAM;AAAA,EACxB;AACA,SAAO,SAAS,MAAM;AACxB;AAEA,IAAM,WAAW,CAAC,WAA6D;AAE7E,MAAI,OAAO,iBAAiB,eAAe;AACzC,WAAO,SAAS,OAAO,KAAK;AAAA,EAC9B;AAGA,MAAI,OAAO,iBAAiB,aAAa;AACvC,WAAO,SAAS,OAAO,KAAK;AAAA,EAC9B;AAGA,SAAO;AACT;AAEA,IAAM,WAAW,CAAC,WAAuD;AAEvE,MAAI,OAAO,iBAAiB,eAAe;AACzC,UAAM,QAAQ,SAAS,OAAO,KAAK;AAGnC,QAAI,gBAAgB,KAAK,GAAG;AAC1B,aAAO,KAAK,KAAK;AAAA,IACnB;AAGA,WAAO;AAAA,EACT;AAGA,MAAI,OAAO,iBAAiB,aAAa;AACvC,WAAO,SAAS,OAAO,KAAK;AAAA,EAC9B;AAGA,SAAO;AACT;","names":[]}

package/dist/index.d.cts

@@ -1,21 +1,127 @@
-interface IErrorResult<E = Error> {
-    readonly success: false;
-    readonly error: E;
-    readonly map: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;
-}
-
 interface ISuccessResult<T = void> {
     readonly success: true;
     readonly value: T;
+    /**
+     * Calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `SuccessResult`
+     */
     readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;
+    /**
+     * Asynchronously calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
+     * @param mapFunction the mapping function
+     * @returns a new `SuccessResult`
+     */
+    readonly mapAsync: <M>(mapFunction: (value: T) => Promise<M>) => Promise<ISuccessResult<M>>;
+    /**
+     * Returns a new `SuccessResult` with the same `value` property as this one.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `SuccessResult`
+     */
+    readonly mapErr: <M>(mapFunction: (value: never) => M) => ISuccessResult<T>;
+    /**
+     * Asynchronously returns a new `SuccessResult` with the same `value` property as this one.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `SuccessResult`
+     */
+    readonly mapErrAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<ISuccessResult<T>>;
+}
+declare class SuccessResult<T = void> implements IResult<T, never>, ISuccessResult<T> {
+    readonly success: true;
+    readonly value: T;
+    constructor(value?: T);
+    map<M>(mapFunction: (value: T) => M): SuccessResult<M>;
+    mapAsync<M>(mapFunction: (value: T) => Promise<M>): Promise<SuccessResult<M>>;
+    mapErr<M>(mapFunction: (error: never) => M): SuccessResult<T>;
+    mapErrAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<SuccessResult<T>>;
+}
+
+interface IResult<T, E> {
+    readonly success: boolean;
+    /**
+     * If a `SuccessResult`, calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
+     * If an `ErrorResult`, returns a new `ErrorResult` with the same `error` property as this one.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `Result`
+     */
+    map: <M>(fn: (value: T) => M) => IResult<M, E>;
+    /**
+     * If a `SuccessResult`, asynchronously calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
+     * If an `ErrorResult`, asynchronously returns a new `ErrorResult` with the same `error` property as this one.
+     * @param mapFunction the mapping function
+     * @returns a new `Result`
+     */
+    mapAsync: <M>(fn: (value: T) => Promise<M>) => Promise<IResult<M, E>>;
+    /**
+     * If a `SuccessResult`, returns a new `SuccessResult` with the same `value` property as this one.
+     * If an `ErrorResult`, calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `Result`
+     */
+    mapErr: <M>(fn: (error: E) => M) => IResult<T, M>;
+    /**
+     * If a `SuccessResult`, asynchronously returns a new `SuccessResult` with the same `value` property as this one.
+     * If an `ErrorResult`, asynchronously calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `Result`
+     */
+    mapErrAsync: <M>(fn: (error: E) => Promise<M>) => Promise<IResult<T, M>>;
+}
+type Result<T = void, E = Error> = SuccessResult<T> | ErrorResult<E>;
+
+interface IErrorResult<E = Error> extends IResult<never, E> {
+    readonly success: false;
+    readonly error: E;
+    /**
+     * Returns a new `ErrorResult` with the same `error` property as this one.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `ErrorResult`
+     */
+    readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;
+    /**
+     * Asynchronously returns a new `ErrorResult` with the same `error` property as this one.
+     * @param mapFunction the mapping function
+     * @returns a new `ErrorResult`
+     */
+    readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;
+    /**
+     * Calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `ErrorResult`
+     */
+    readonly mapErr: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;
+    /**
+     * Asynchronously calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `ErrorResult`
+     */
+    readonly mapErrAsync: <M>(mapFunction: (value: E) => Promise<M>) => Promise<IErrorResult<M>>;
+}
+declare class ErrorResult<E> implements IResult<never, E>, IErrorResult<E> {
+    readonly error: E;
+    readonly success: false;
+    constructor(error: E);
+    map<M>(mapFunction: (error: never) => M): ErrorResult<E>;
+    mapAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<ErrorResult<E>>;
+    mapErr<M>(mapFunction: (error: E) => M): ErrorResult<M>;
+    mapErrAsync<M>(mapFunction: (value: E) => Promise<M>): Promise<ErrorResult<M>>;
 }
 
-type ResultType<T = void, E = Error> = ISuccessResult<T> | IErrorResult<E>;
 declare function success(): ISuccessResult;
 declare function success<T>(value: T): ISuccessResult<T>;
 declare function fail<E>(error: E): IErrorResult<E>;
-declare const isSuccessResult: <T, E = Error>(result: ResultType<T, E>) => result is ISuccessResult<T>;
-declare const isErrorResult: <T, E = Error>(result: ResultType<T, E>) => result is IErrorResult<E>;
-declare function combine(...results: ResultType[]): ResultType;
+declare const isSuccessResult: <T, E = Error>(result: Result<T, E>) => result is ISuccessResult<T>;
+declare const isErrorResult: <T, E = Error>(result: Result<T, E>) => result is IErrorResult<E>;
+declare function combine(results: Result<unknown, unknown>[]): Result<unknown[], unknown[]>;
+declare const flatten: (result: Result<unknown, unknown>) => Result<unknown, unknown>;
 
-export { type IErrorResult, type ISuccessResult, type ResultType, combine, fail, isErrorResult, isSuccessResult, success };
+export { type IErrorResult, type ISuccessResult, type Result, combine, fail, flatten, isErrorResult, isSuccessResult, success };

package/dist/index.d.ts

@@ -1,21 +1,127 @@
-interface IErrorResult<E = Error> {
-    readonly success: false;
-    readonly error: E;
-    readonly map: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;
-}
-
 interface ISuccessResult<T = void> {
     readonly success: true;
     readonly value: T;
+    /**
+     * Calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `SuccessResult`
+     */
     readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;
+    /**
+     * Asynchronously calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
+     * @param mapFunction the mapping function
+     * @returns a new `SuccessResult`
+     */
+    readonly mapAsync: <M>(mapFunction: (value: T) => Promise<M>) => Promise<ISuccessResult<M>>;
+    /**
+     * Returns a new `SuccessResult` with the same `value` property as this one.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `SuccessResult`
+     */
+    readonly mapErr: <M>(mapFunction: (value: never) => M) => ISuccessResult<T>;
+    /**
+     * Asynchronously returns a new `SuccessResult` with the same `value` property as this one.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `SuccessResult`
+     */
+    readonly mapErrAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<ISuccessResult<T>>;
+}
+declare class SuccessResult<T = void> implements IResult<T, never>, ISuccessResult<T> {
+    readonly success: true;
+    readonly value: T;
+    constructor(value?: T);
+    map<M>(mapFunction: (value: T) => M): SuccessResult<M>;
+    mapAsync<M>(mapFunction: (value: T) => Promise<M>): Promise<SuccessResult<M>>;
+    mapErr<M>(mapFunction: (error: never) => M): SuccessResult<T>;
+    mapErrAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<SuccessResult<T>>;
+}
+
+interface IResult<T, E> {
+    readonly success: boolean;
+    /**
+     * If a `SuccessResult`, calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
+     * If an `ErrorResult`, returns a new `ErrorResult` with the same `error` property as this one.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `Result`
+     */
+    map: <M>(fn: (value: T) => M) => IResult<M, E>;
+    /**
+     * If a `SuccessResult`, asynchronously calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.
+     * If an `ErrorResult`, asynchronously returns a new `ErrorResult` with the same `error` property as this one.
+     * @param mapFunction the mapping function
+     * @returns a new `Result`
+     */
+    mapAsync: <M>(fn: (value: T) => Promise<M>) => Promise<IResult<M, E>>;
+    /**
+     * If a `SuccessResult`, returns a new `SuccessResult` with the same `value` property as this one.
+     * If an `ErrorResult`, calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `Result`
+     */
+    mapErr: <M>(fn: (error: E) => M) => IResult<T, M>;
+    /**
+     * If a `SuccessResult`, asynchronously returns a new `SuccessResult` with the same `value` property as this one.
+     * If an `ErrorResult`, asynchronously calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `Result`
+     */
+    mapErrAsync: <M>(fn: (error: E) => Promise<M>) => Promise<IResult<T, M>>;
+}
+type Result<T = void, E = Error> = SuccessResult<T> | ErrorResult<E>;
+
+interface IErrorResult<E = Error> extends IResult<never, E> {
+    readonly success: false;
+    readonly error: E;
+    /**
+     * Returns a new `ErrorResult` with the same `error` property as this one.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `ErrorResult`
+     */
+    readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;
+    /**
+     * Asynchronously returns a new `ErrorResult` with the same `error` property as this one.
+     * @param mapFunction the mapping function
+     * @returns a new `ErrorResult`
+     */
+    readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;
+    /**
+     * Calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `ErrorResult`
+     */
+    readonly mapErr: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;
+    /**
+     * Asynchronously calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.
+     *
+     * @param mapFunction the mapping function
+     * @returns a new `ErrorResult`
+     */
+    readonly mapErrAsync: <M>(mapFunction: (value: E) => Promise<M>) => Promise<IErrorResult<M>>;
+}
+declare class ErrorResult<E> implements IResult<never, E>, IErrorResult<E> {
+    readonly error: E;
+    readonly success: false;
+    constructor(error: E);
+    map<M>(mapFunction: (error: never) => M): ErrorResult<E>;
+    mapAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<ErrorResult<E>>;
+    mapErr<M>(mapFunction: (error: E) => M): ErrorResult<M>;
+    mapErrAsync<M>(mapFunction: (value: E) => Promise<M>): Promise<ErrorResult<M>>;
 }
 
-type ResultType<T = void, E = Error> = ISuccessResult<T> | IErrorResult<E>;
 declare function success(): ISuccessResult;
 declare function success<T>(value: T): ISuccessResult<T>;
 declare function fail<E>(error: E): IErrorResult<E>;
-declare const isSuccessResult: <T, E = Error>(result: ResultType<T, E>) => result is ISuccessResult<T>;
-declare const isErrorResult: <T, E = Error>(result: ResultType<T, E>) => result is IErrorResult<E>;
-declare function combine(...results: ResultType[]): ResultType;
+declare const isSuccessResult: <T, E = Error>(result: Result<T, E>) => result is ISuccessResult<T>;
+declare const isErrorResult: <T, E = Error>(result: Result<T, E>) => result is IErrorResult<E>;
+declare function combine(results: Result<unknown, unknown>[]): Result<unknown[], unknown[]>;
+declare const flatten: (result: Result<unknown, unknown>) => Result<unknown, unknown>;
 
-export { type IErrorResult, type ISuccessResult, type ResultType, combine, fail, isErrorResult, isSuccessResult, success };
+export { type IErrorResult, type ISuccessResult, type Result, combine, fail, flatten, isErrorResult, isSuccessResult, success };

package/dist/index.js

@@ -4,20 +4,42 @@ var ErrorResult = class _ErrorResult {
     this.error = error;
     this.success = false;
   }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters
   map(mapFunction) {
+    return new _ErrorResult(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async
+  mapAsync(mapFunction) {
+    return Promise.resolve(new _ErrorResult(this.error));
+  }
+  mapErr(mapFunction) {
     return new _ErrorResult(mapFunction(this.error));
   }
+  async mapErrAsync(mapFunction) {
+    return new _ErrorResult(await mapFunction(this.error));
+  }
 };
 
 // src/successResult.mts
 var SuccessResult = class _SuccessResult {
   constructor(value) {
-    this.value = value;
     this.success = true;
+    this.value = value;
   }
   map(mapFunction) {
     return new _SuccessResult(mapFunction(this.value));
   }
+  async mapAsync(mapFunction) {
+    return new _SuccessResult(await mapFunction(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters
+  mapErr(mapFunction) {
+    return new _SuccessResult(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async
+  mapErrAsync(mapFunction) {
+    return Promise.resolve(new _SuccessResult(this.value));
+  }
 };
 
 // src/index.mts
@@ -33,17 +55,53 @@ var isSuccessResult = (result) => {
 var isErrorResult = (result) => {
   return !result.success;
 };
-function combine(...results) {
+function combine(results) {
+  const values = [];
+  const errors = [];
   for (const r of results) {
-    if (!r.success) {
-      return r;
+    if (r.success) {
+      values.push(r.value);
+    } else {
+      errors.push(r.error);
     }
   }
-  return new SuccessResult(void 0);
+  if (errors.length) {
+    return new ErrorResult(errors);
+  }
+  return new SuccessResult(values);
 }
+var flatten = (result) => {
+  if (isSuccessResult(result)) {
+    return getValue(result);
+  }
+  return getError(result);
+};
+var getValue = (result) => {
+  if (result.value instanceof SuccessResult) {
+    return getValue(result.value);
+  }
+  if (result.value instanceof ErrorResult) {
+    return getError(result.value);
+  }
+  return result;
+};
+var getError = (result) => {
+  if (result.error instanceof SuccessResult) {
+    const value = getValue(result.error);
+    if (isSuccessResult(value)) {
+      return fail(value);
+    }
+    return value;
+  }
+  if (result.error instanceof ErrorResult) {
+    return getError(result.error);
+  }
+  return result;
+};
 export {
   combine,
   fail,
+  flatten,
   isErrorResult,
   isSuccessResult,
   success

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/errorResult.mts","../src/successResult.mts","../src/index.mts"],"sourcesContent":["export interface IErrorResult<E = Error> {\n  readonly success: false;\n  readonly error: E;\n  readonly map: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;\n}\n\nexport class ErrorResult<E> implements IErrorResult<E> {\n  public readonly success = false as const;\n\n  public constructor(public readonly error: E) { /* empty */ }\n\n  public map<M>(mapFunction: (error: E) => M): ErrorResult<M> {\n    return new ErrorResult(mapFunction(this.error));\n  }\n}\n","export interface ISuccessResult<T = void> {\n  readonly success: true;\n  readonly value: T;\n  readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;\n}\n\nexport class SuccessResult<T = void> implements ISuccessResult<T> {\n  public readonly success = true as const;\n\n  public constructor(public readonly value: T) { /* empty */ }\n\n  public map<M>(mapFunction: (value: T) => M): SuccessResult<M> {\n    return new SuccessResult(mapFunction(this.value));\n  }\n};\n","import type { IErrorResult } from './errorResult.mjs';\nimport { ErrorResult } from './errorResult.mjs';\nimport type { ISuccessResult } from './successResult.mjs';\nimport { SuccessResult } from './successResult.mjs';\n\nexport type { ISuccessResult };\nexport type { IErrorResult };\n\nexport type ResultType<T = void, E = Error> = ISuccessResult<T> | IErrorResult<E>;\n\nexport function success(): ISuccessResult;\nexport function success<T>(value: T): ISuccessResult<T>;\nexport function success<T>(value?: T): ISuccessResult<T> {\n  return new SuccessResult(value as T);\n};\n\nexport function fail<E>(error: E): IErrorResult<E> {\n  return new ErrorResult(error);\n}\n\nexport const isSuccessResult = <T, E = Error>(result: ResultType<T, E>): result is ISuccessResult<T> => {\n  return result.success;\n};\n\nexport const isErrorResult = <T, E = Error>(result: ResultType<T, E>): result is IErrorResult<E> => {\n  return !result.success;\n};\n\nexport function combine(...results: ResultType[]): ResultType {\n  for (const r of results) {\n    if (!r.success) {\n      return r;\n    }\n  }\n  return new SuccessResult(undefined);\n}\n"],"mappings":";AAMO,IAAM,cAAN,MAAM,aAA0C;AAAA,EAG9C,YAA4B,OAAU;AAAV;AAFnC,SAAgB,UAAU;AAAA,EAEiC;AAAA,EAEpD,IAAO,aAA8C;AAC1D,WAAO,IAAI,aAAY,YAAY,KAAK,KAAK,CAAC;AAAA,EAChD;AACF;;;ACRO,IAAM,gBAAN,MAAM,eAAqD;AAAA,EAGzD,YAA4B,OAAU;AAAV;AAFnC,SAAgB,UAAU;AAAA,EAEiC;AAAA,EAEpD,IAAO,aAAgD;AAC5D,WAAO,IAAI,eAAc,YAAY,KAAK,KAAK,CAAC;AAAA,EAClD;AACF;;;ACFO,SAAS,QAAW,OAA8B;AACvD,SAAO,IAAI,cAAc,KAAU;AACrC;AAEO,SAAS,KAAQ,OAA2B;AACjD,SAAO,IAAI,YAAY,KAAK;AAC9B;AAEO,IAAM,kBAAkB,CAAe,WAA0D;AACtG,SAAO,OAAO;AAChB;AAEO,IAAM,gBAAgB,CAAe,WAAwD;AAClG,SAAO,CAAC,OAAO;AACjB;AAEO,SAAS,WAAW,SAAmC;AAC5D,aAAW,KAAK,SAAS;AACvB,QAAI,CAAC,EAAE,SAAS;AACd,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO,IAAI,cAAc,MAAS;AACpC;","names":[]}
+{"version":3,"sources":["../src/errorResult.mts","../src/successResult.mts","../src/index.mts"],"sourcesContent":["import type { IResult } from './result.mjs';\n\nexport interface IErrorResult<E = Error> extends IResult<never, E> {\n  readonly success: false;\n  readonly error: E;\n\n  /**\n   * Returns a new `ErrorResult` with the same `error` property as this one.\n   *\n   * @param mapFunction the mapping function\n   * @returns a new `ErrorResult`\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n  readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;\n\n  /**\n   * Asynchronously returns a new `ErrorResult` with the same `error` property as this one.\n   * @param mapFunction the mapping function\n   * @returns a new `ErrorResult`\n   */\n  readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;\n\n  /**\n   * Calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.\n   *\n   * @param mapFunction the mapping function\n   * @returns a new `ErrorResult`\n   */\n  readonly mapErr: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;\n\n  /**\n   * Asynchronously calls a defined callback function on the `error` property, and returns a new `ErrorResult` with the resulting value.\n   *\n   * @param mapFunction the mapping function\n   * @returns a new `ErrorResult`\n   */\n  readonly mapErrAsync: <M>(mapFunction: (value: E) => Promise<M>) => Promise<IErrorResult<M>>;\n}\n\nexport class ErrorResult<E> implements IResult<never, E>, IErrorResult<E> {\n  public readonly success = false as const;\n\n  public constructor(public readonly error: E) { /* empty */ }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters\n  public map<M>(mapFunction: (error: never) => M): ErrorResult<E> {\n    return new ErrorResult(this.error);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async\n  public mapAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<ErrorResult<E>> {\n    return Promise.resolve(new ErrorResult(this.error));\n  }\n\n  public mapErr<M>(mapFunction: (error: E) => M): ErrorResult<M> {\n    return new ErrorResult(mapFunction(this.error));\n  }\n\n  public async mapErrAsync<M>(mapFunction: (value: E) => Promise<M>): Promise<ErrorResult<M>> {\n    return new ErrorResult(await mapFunction(this.error));\n  }\n}\n","import type { IResult } from './result.mjs';\n\nexport interface ISuccessResult<T = void> {\n  readonly success: true;\n  readonly value: T;\n\n  /**\n   * Calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.\n   *\n   * @param mapFunction the mapping function\n   * @returns a new `SuccessResult`\n   */\n  readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;\n\n  /**\n   * Asynchronously calls a defined callback function on the `value` property, and returns a new `SuccessResult` with the resulting value.\n   * @param mapFunction the mapping function\n   * @returns a new `SuccessResult`\n   */\n  readonly mapAsync: <M>(mapFunction: (value: T) => Promise<M>) => Promise<ISuccessResult<M>>;\n\n  /**\n   * Returns a new `SuccessResult` with the same `value` property as this one.\n   *\n   * @param mapFunction the mapping function\n   * @returns a new `SuccessResult`\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n  readonly mapErr: <M>(mapFunction: (value: never) => M) => ISuccessResult<T>;\n\n  /**\n   * Asynchronously returns a new `SuccessResult` with the same `value` property as this one.\n   *\n   * @param mapFunction the mapping function\n   * @returns a new `SuccessResult`\n   */\n  readonly mapErrAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<ISuccessResult<T>>;\n}\n\nexport class SuccessResult<T = void> implements IResult<T, never>, ISuccessResult<T> {\n  public readonly success = true as const;\n  public readonly value: T;\n\n  public constructor(value?: T) {\n    this.value = value as T;\n  }\n\n  public map<M>(mapFunction: (value: T) => M): SuccessResult<M> {\n    return new SuccessResult(mapFunction(this.value));\n  }\n\n  public async mapAsync<M>(mapFunction: (value: T) => Promise<M>): Promise<SuccessResult<M>> {\n    return new SuccessResult(await mapFunction(this.value));\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters\n  public mapErr<M>(mapFunction: (error: never) => M): SuccessResult<T> {\n    return new SuccessResult(this.value);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/promise-function-async\n  public mapErrAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<SuccessResult<T>> {\n    return Promise.resolve(new SuccessResult(this.value));\n  }\n};\n","import type { IErrorResult } from './errorResult.mjs';\nimport { ErrorResult } from './errorResult.mjs';\nimport type { Result } from './result.mjs';\nimport type { ISuccessResult } from './successResult.mjs';\nimport { SuccessResult } from './successResult.mjs';\n\nexport type { Result, ISuccessResult, IErrorResult };\n\nexport function success(): ISuccessResult;\nexport function success<T>(value: T): ISuccessResult<T>;\nexport function success<T>(value?: T): ISuccessResult<T> {\n  return new SuccessResult(value as T);\n};\n\nexport function fail<E>(error: E): IErrorResult<E> {\n  return new ErrorResult(error);\n}\n\nexport const isSuccessResult = <T, E = Error>(result: Result<T, E>): result is ISuccessResult<T> => {\n  return result.success;\n};\n\nexport const isErrorResult = <T, E = Error>(result: Result<T, E>): result is IErrorResult<E> => {\n  return !result.success;\n};\n\nexport function combine(results: Result<unknown, unknown>[]): Result<unknown[], unknown[]> {\n  const values: unknown[] = [];\n  const errors: unknown[] = [];\n\n  for (const r of results) {\n    if (r.success) {\n      values.push(r.value);\n    } else {\n      errors.push(r.error);\n    }\n  }\n\n  if (errors.length) {\n    return new ErrorResult(errors);\n  }\n  return new SuccessResult(values);\n}\n\nexport const flatten = (result: Result<unknown, unknown>): Result<unknown, unknown> => {\n  if (isSuccessResult(result)) {\n    return getValue(result);\n  }\n  return getError(result);\n};\n\nconst getValue = (result: SuccessResult<unknown>): Result<unknown, unknown> => {\n  // value is a SuccessResult, drill down\n  if (result.value instanceof SuccessResult) {\n    return getValue(result.value);\n  }\n\n  // value is an ErrorResult, drill down\n  if (result.value instanceof ErrorResult) {\n    return getError(result.value);\n  }\n\n  // value is not a Result, return current SuccessResult\n  return result;\n};\n\nconst getError = (result: ErrorResult<unknown>): ErrorResult<unknown> => {\n  // error is a SuccessResult, consider this SuccessResult's value\n  if (result.error instanceof SuccessResult) {\n    const value = getValue(result.error);\n\n    // if the value is a SuccessResult, swallow it into an error\n    if (isSuccessResult(value)) {\n      return fail(value);\n    }\n\n    // otherwise the value is an ErrorResult, return it\n    return value;\n  }\n\n  // error is an ErrorResult, swallow it\n  if (result.error instanceof ErrorResult) {\n    return getError(result.error);\n  }\n\n  // error is not a Result, the current ErrorResult\n  return result;\n};\n"],"mappings":";AAuCO,IAAM,cAAN,MAAM,aAA6D;AAAA,EAGjE,YAA4B,OAAU;AAAV;AAFnC,SAAgB,UAAU;AAAA,EAEiC;AAAA;AAAA,EAGpD,IAAO,aAAkD;AAC9D,WAAO,IAAI,aAAY,KAAK,KAAK;AAAA,EACnC;AAAA;AAAA,EAGO,SAAY,aAAoE;AACrF,WAAO,QAAQ,QAAQ,IAAI,aAAY,KAAK,KAAK,CAAC;AAAA,EACpD;AAAA,EAEO,OAAU,aAA8C;AAC7D,WAAO,IAAI,aAAY,YAAY,KAAK,KAAK,CAAC;AAAA,EAChD;AAAA,EAEA,MAAa,YAAe,aAAgE;AAC1F,WAAO,IAAI,aAAY,MAAM,YAAY,KAAK,KAAK,CAAC;AAAA,EACtD;AACF;;;ACtBO,IAAM,gBAAN,MAAM,eAAwE;AAAA,EAI5E,YAAY,OAAW;AAH9B,SAAgB,UAAU;AAIxB,SAAK,QAAQ;AAAA,EACf;AAAA,EAEO,IAAO,aAAgD;AAC5D,WAAO,IAAI,eAAc,YAAY,KAAK,KAAK,CAAC;AAAA,EAClD;AAAA,EAEA,MAAa,SAAY,aAAkE;AACzF,WAAO,IAAI,eAAc,MAAM,YAAY,KAAK,KAAK,CAAC;AAAA,EACxD;AAAA;AAAA,EAGO,OAAU,aAAoD;AACnE,WAAO,IAAI,eAAc,KAAK,KAAK;AAAA,EACrC;AAAA;AAAA,EAGO,YAAe,aAAsE;AAC1F,WAAO,QAAQ,QAAQ,IAAI,eAAc,KAAK,KAAK,CAAC;AAAA,EACtD;AACF;;;ACtDO,SAAS,QAAW,OAA8B;AACvD,SAAO,IAAI,cAAc,KAAU;AACrC;AAEO,SAAS,KAAQ,OAA2B;AACjD,SAAO,IAAI,YAAY,KAAK;AAC9B;AAEO,IAAM,kBAAkB,CAAe,WAAsD;AAClG,SAAO,OAAO;AAChB;AAEO,IAAM,gBAAgB,CAAe,WAAoD;AAC9F,SAAO,CAAC,OAAO;AACjB;AAEO,SAAS,QAAQ,SAAmE;AACzF,QAAM,SAAoB,CAAC;AAC3B,QAAM,SAAoB,CAAC;AAE3B,aAAW,KAAK,SAAS;AACvB,QAAI,EAAE,SAAS;AACb,aAAO,KAAK,EAAE,KAAK;AAAA,IACrB,OAAO;AACL,aAAO,KAAK,EAAE,KAAK;AAAA,IACrB;AAAA,EACF;AAEA,MAAI,OAAO,QAAQ;AACjB,WAAO,IAAI,YAAY,MAAM;AAAA,EAC/B;AACA,SAAO,IAAI,cAAc,MAAM;AACjC;AAEO,IAAM,UAAU,CAAC,WAA+D;AACrF,MAAI,gBAAgB,MAAM,GAAG;AAC3B,WAAO,SAAS,MAAM;AAAA,EACxB;AACA,SAAO,SAAS,MAAM;AACxB;AAEA,IAAM,WAAW,CAAC,WAA6D;AAE7E,MAAI,OAAO,iBAAiB,eAAe;AACzC,WAAO,SAAS,OAAO,KAAK;AAAA,EAC9B;AAGA,MAAI,OAAO,iBAAiB,aAAa;AACvC,WAAO,SAAS,OAAO,KAAK;AAAA,EAC9B;AAGA,SAAO;AACT;AAEA,IAAM,WAAW,CAAC,WAAuD;AAEvE,MAAI,OAAO,iBAAiB,eAAe;AACzC,UAAM,QAAQ,SAAS,OAAO,KAAK;AAGnC,QAAI,gBAAgB,KAAK,GAAG;AAC1B,aAAO,KAAK,KAAK;AAAA,IACnB;AAGA,WAAO;AAAA,EACT;AAGA,MAAI,OAAO,iBAAiB,aAAa;AACvC,WAAO,SAAS,OAAO,KAAK;AAAA,EAC9B;AAGA,SAAO;AACT;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "generic-result-type",
-  "version": "2.0.0",
+  "version": "2.2.1",
   "description": "A generic result wrapper",
   "license": "ISC",
   "author": "Dave Welsh",