generic-result-type 1.0.0 → 2.1.0

package/README.md

@@ -12,18 +12,18 @@ npm i generic-result-type
 
 ## Module support
 
-This package supports *both ESM and CommonJS* out of the box.
+This package supports **both ESM and CommonJS** out of the box.
 
 ESM:
 
 ```ts
-import { Result } from "generic-result-type"
+import { success, fail, type Result } from 'generic-result-type';
 ```
 
 CommonJS:
 
 ```js
-const { Result } = require("generic-result-type");
+const { success, fail } = require('generic-result-type');
 ```
 
 TypeScript typings are included.
@@ -33,6 +33,56 @@ TypeScript typings are included.
 This package has zero runtime dependencies.
 It does not rely on any external libraries.
 
+## Usage
+
+Create results using the `success` and `fail` functions, then narrow them with the provided type guards.
+
+### Example function
+
+```ts
+const parseNumber = (input: string): Result<number> => {
+  const value = Number(input);
+
+  if (Number.isNaN(value)) {
+    return fail(Error('Not a number'));
+  }
+
+  return success(value);
+}
+```
+
+### Handling results
+
+Use the type guard helpers to safely branch on the result type.
+
+```ts
+const result = getSomeValue();
+
+if (isErrorResult(result)) { // or if (result.success === false)
+  console.error('Error:', result.error.message);
+  return;
+}
+
+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

@@ -20,57 +20,85 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.mts
 var index_exports = {};
 __export(index_exports, {
-  Result: () => Result,
+  combine: () => combine,
+  fail: () => fail,
   isErrorResult: () => isErrorResult,
-  isSuccessResult: () => isSuccessResult
+  isSuccessResult: () => isSuccessResult,
+  success: () => success
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/errorResult.mts
-var ErrorResult = class {
+var ErrorResult = class _ErrorResult {
   constructor(error) {
     this.error = error;
     this.success = false;
   }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters
+  map(mapFunction) {
+    return this;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await
+  async mapAsync(mapFunction) {
+    return this;
+  }
+  mapErr(mapFunction) {
+    return new _ErrorResult(mapFunction(this.error));
+  }
+  async mapErrAsync(mapFunction) {
+    return new _ErrorResult(await mapFunction(this.error));
+  }
 };
 
 // src/successResult.mts
-var SuccessResult = class {
+var SuccessResult = class _SuccessResult {
   constructor(value) {
-    this.value = value;
     this.success = true;
+    this.value = value;
   }
-};
-
-// src/result.mts
-var Result = class _Result {
-  static success(value) {
-    return new SuccessResult(value);
+  map(mapFunction) {
+    return new _SuccessResult(mapFunction(this.value));
   }
-  static fail(error) {
-    return new ErrorResult(error);
+  async mapAsync(mapFunction) {
+    return new _SuccessResult(await mapFunction(this.value));
   }
-  static combine(results) {
-    for (const result of results) {
-      if (!result.success) {
-        return result;
-      }
-    }
-    return _Result.success(void 0);
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters
+  mapErr(mapFunction) {
+    return this;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await
+  async mapErrAsync(mapFunction) {
+    return this;
   }
 };
 
 // src/index.mts
+function success(value) {
+  return new SuccessResult(value);
+}
+function fail(error) {
+  return new ErrorResult(error);
+}
 var isSuccessResult = (result) => {
   return result.success;
 };
 var isErrorResult = (result) => {
   return !result.success;
 };
+function combine(...results) {
+  for (const r of results) {
+    if (!r.success) {
+      return r;
+    }
+  }
+  return new SuccessResult(void 0);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Result,
+  combine,
+  fail,
   isErrorResult,
-  isSuccessResult
+  isSuccessResult,
+  success
 });
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.mts","../src/errorResult.mts","../src/successResult.mts","../src/result.mts"],"sourcesContent":["import type { IErrorResult } from './errorResult.mjs';\nimport type { ISuccessResult } from './successResult.mjs';\n\nexport { Result } from './result.mjs';\nexport type { ISuccessResult };\nexport type { IErrorResult };\n\nexport type ResultType<T> = ISuccessResult<T> | IErrorResult;\n\n// eslint-disable-next-line @stylistic/comma-dangle\nexport const isSuccessResult = <T,>(result: ResultType<T>): result is ISuccessResult<T> => {\n  return result.success;\n};\n\n// eslint-disable-next-line @stylistic/comma-dangle\nexport const isErrorResult = <T,>(result: ResultType<T>): result is IErrorResult => {\n  return !result.success;\n};\n","export interface IErrorResult {\n  readonly success: false;\n  readonly error: Error;\n}\n\nexport class ErrorResult implements IErrorResult {\n  public readonly success = false as const;\n\n  public constructor(public readonly error: Error) { /* empty */ }\n}\n","export interface ISuccessResult<T> {\n  readonly success: true;\n  readonly value: T;\n}\n\nexport class SuccessResult<T> implements ISuccessResult<T> {\n  public readonly success = true as const;\n\n  public constructor(public readonly value: T) { /* empty */ }\n}\n","import type { IErrorResult } from './errorResult.mjs';\nimport { ErrorResult } from './errorResult.mjs';\nimport type { ResultType } from './index.mjs';\nimport type { ISuccessResult } from './successResult.mjs';\nimport { SuccessResult } from './successResult.mjs';\n\n// eslint-disable-next-line @typescript-eslint/no-extraneous-class\nexport abstract class Result {\n\n  public static success<T>(value: T): ISuccessResult<T> {\n    return new SuccessResult(value);\n  }\n\n  public static fail(error: Error): IErrorResult {\n    return new ErrorResult(error);\n  }\n\n  public static combine<T>(results: ResultType<T>[]): ResultType<T | undefined> {\n    for (const result of results) {\n      if (!result.success) {\n        return result;\n      }\n    }\n    return Result.success<undefined>(undefined);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACKO,IAAM,cAAN,MAA0C;AAAA,EAGxC,YAA4B,OAAc;AAAd;AAFnC,SAAgB,UAAU;AAAA,EAEqC;AACjE;;;ACJO,IAAM,gBAAN,MAAoD;AAAA,EAGlD,YAA4B,OAAU;AAAV;AAFnC,SAAgB,UAAU;AAAA,EAEiC;AAC7D;;;ACFO,IAAe,SAAf,MAAe,QAAO;AAAA,EAE3B,OAAc,QAAW,OAA6B;AACpD,WAAO,IAAI,cAAc,KAAK;AAAA,EAChC;AAAA,EAEA,OAAc,KAAK,OAA4B;AAC7C,WAAO,IAAI,YAAY,KAAK;AAAA,EAC9B;AAAA,EAEA,OAAc,QAAW,SAAqD;AAC5E,eAAW,UAAU,SAAS;AAC5B,UAAI,CAAC,OAAO,SAAS;AACnB,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO,QAAO,QAAmB,MAAS;AAAA,EAC5C;AACF;;;AHfO,IAAM,kBAAkB,CAAK,WAAuD;AACzF,SAAO,OAAO;AAChB;AAGO,IAAM,gBAAgB,CAAK,WAAkD;AAClF,SAAO,CAAC,OAAO;AACjB;","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 { ISuccessResult } from './successResult.mjs';\nimport { SuccessResult } from './successResult.mjs';\n\nexport type { ISuccessResult };\nexport type { IErrorResult };\n\nexport type Result<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: 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[]): Result {\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  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n  readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;\n  readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;\n  readonly mapErr: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;\n  readonly mapErrAsync: <M>(mapFunction: (value: E) => Promise<M>) => Promise<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  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters\n  public map<M>(mapFunction: (error: never) => M): this {\n    return this;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await\n  public async mapAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<this> {\n    return this;\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","export interface ISuccessResult<T = void> {\n  readonly success: true;\n  readonly value: T;\n  readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;\n  readonly mapAsync: <M>(mapFunction: (value: T) => Promise<M>) => Promise<ISuccessResult<M>>;\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n  readonly mapErr: <M>(mapFunction: (value: never) => M) => ISuccessResult<T>;\n  readonly mapErrAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<ISuccessResult<T>>;\n}\n\nexport class SuccessResult<T = void> implements 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): this {\n    return this;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await\n  public async mapErrAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<this> {\n    return this;\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACUO,IAAM,cAAN,MAAM,aAA0C;AAAA,EAG9C,YAA4B,OAAU;AAAV;AAFnC,SAAgB,UAAU;AAAA,EAEiC;AAAA;AAAA,EAGpD,IAAO,aAAwC;AACpD,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,MAAa,SAAY,aAA0D;AACjF,WAAO;AAAA,EACT;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,eAAqD;AAAA,EAIzD,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,aAAwC;AACvD,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,MAAa,YAAe,aAA0D;AACpF,WAAO;AAAA,EACT;AACF;;;AFvBO,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,WAAW,SAA2B;AACpD,aAAW,KAAK,SAAS;AACvB,QAAI,CAAC,EAAE,SAAS;AACd,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO,IAAI,cAAc,MAAS;AACpC;","names":[]}

package/dist/index.d.cts

@@ -1,21 +1,27 @@
-interface IErrorResult {
+interface IErrorResult<E = Error> {
     readonly success: false;
-    readonly error: Error;
+    readonly error: E;
+    readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;
+    readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;
+    readonly mapErr: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;
+    readonly mapErrAsync: <M>(mapFunction: (value: E) => Promise<M>) => Promise<IErrorResult<M>>;
 }
 
-interface ISuccessResult<T> {
+interface ISuccessResult<T = void> {
     readonly success: true;
     readonly value: T;
+    readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;
+    readonly mapAsync: <M>(mapFunction: (value: T) => Promise<M>) => Promise<ISuccessResult<M>>;
+    readonly mapErr: <M>(mapFunction: (value: never) => M) => ISuccessResult<T>;
+    readonly mapErrAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<ISuccessResult<T>>;
 }
 
-declare abstract class Result {
-    static success<T>(value: T): ISuccessResult<T>;
-    static fail(error: Error): IErrorResult;
-    static combine<T>(results: ResultType<T>[]): ResultType<T | undefined>;
-}
-
-type ResultType<T> = ISuccessResult<T> | IErrorResult;
-declare const isSuccessResult: <T>(result: ResultType<T>) => result is ISuccessResult<T>;
-declare const isErrorResult: <T>(result: ResultType<T>) => result is IErrorResult;
+type Result<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: 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[]): Result;
 
-export { type IErrorResult, type ISuccessResult, Result, type ResultType, isErrorResult, isSuccessResult };
+export { type IErrorResult, type ISuccessResult, type Result, combine, fail, isErrorResult, isSuccessResult, success };

package/dist/index.d.ts

@@ -1,21 +1,27 @@
-interface IErrorResult {
+interface IErrorResult<E = Error> {
     readonly success: false;
-    readonly error: Error;
+    readonly error: E;
+    readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;
+    readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;
+    readonly mapErr: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;
+    readonly mapErrAsync: <M>(mapFunction: (value: E) => Promise<M>) => Promise<IErrorResult<M>>;
 }
 
-interface ISuccessResult<T> {
+interface ISuccessResult<T = void> {
     readonly success: true;
     readonly value: T;
+    readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;
+    readonly mapAsync: <M>(mapFunction: (value: T) => Promise<M>) => Promise<ISuccessResult<M>>;
+    readonly mapErr: <M>(mapFunction: (value: never) => M) => ISuccessResult<T>;
+    readonly mapErrAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<ISuccessResult<T>>;
 }
 
-declare abstract class Result {
-    static success<T>(value: T): ISuccessResult<T>;
-    static fail(error: Error): IErrorResult;
-    static combine<T>(results: ResultType<T>[]): ResultType<T | undefined>;
-}
-
-type ResultType<T> = ISuccessResult<T> | IErrorResult;
-declare const isSuccessResult: <T>(result: ResultType<T>) => result is ISuccessResult<T>;
-declare const isErrorResult: <T>(result: ResultType<T>) => result is IErrorResult;
+type Result<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: 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[]): Result;
 
-export { type IErrorResult, type ISuccessResult, Result, type ResultType, isErrorResult, isSuccessResult };
+export { type IErrorResult, type ISuccessResult, type Result, combine, fail, isErrorResult, isSuccessResult, success };

package/dist/index.js

@@ -1,47 +1,73 @@
 // src/errorResult.mts
-var ErrorResult = class {
+var ErrorResult = class _ErrorResult {
   constructor(error) {
     this.error = error;
     this.success = false;
   }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters
+  map(mapFunction) {
+    return this;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await
+  async mapAsync(mapFunction) {
+    return this;
+  }
+  mapErr(mapFunction) {
+    return new _ErrorResult(mapFunction(this.error));
+  }
+  async mapErrAsync(mapFunction) {
+    return new _ErrorResult(await mapFunction(this.error));
+  }
 };
 
 // src/successResult.mts
-var SuccessResult = class {
+var SuccessResult = class _SuccessResult {
   constructor(value) {
-    this.value = value;
     this.success = true;
+    this.value = value;
   }
-};
-
-// src/result.mts
-var Result = class _Result {
-  static success(value) {
-    return new SuccessResult(value);
-  }
-  static fail(error) {
-    return new ErrorResult(error);
-  }
-  static combine(results) {
-    for (const result of results) {
-      if (!result.success) {
-        return result;
-      }
-    }
-    return _Result.success(void 0);
+  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 this;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await
+  async mapErrAsync(mapFunction) {
+    return this;
   }
 };
 
 // src/index.mts
+function success(value) {
+  return new SuccessResult(value);
+}
+function fail(error) {
+  return new ErrorResult(error);
+}
 var isSuccessResult = (result) => {
   return result.success;
 };
 var isErrorResult = (result) => {
   return !result.success;
 };
+function combine(...results) {
+  for (const r of results) {
+    if (!r.success) {
+      return r;
+    }
+  }
+  return new SuccessResult(void 0);
+}
 export {
-  Result,
+  combine,
+  fail,
   isErrorResult,
-  isSuccessResult
+  isSuccessResult,
+  success
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/errorResult.mts","../src/successResult.mts","../src/result.mts","../src/index.mts"],"sourcesContent":["export interface IErrorResult {\n  readonly success: false;\n  readonly error: Error;\n}\n\nexport class ErrorResult implements IErrorResult {\n  public readonly success = false as const;\n\n  public constructor(public readonly error: Error) { /* empty */ }\n}\n","export interface ISuccessResult<T> {\n  readonly success: true;\n  readonly value: T;\n}\n\nexport class SuccessResult<T> implements ISuccessResult<T> {\n  public readonly success = true as const;\n\n  public constructor(public readonly value: T) { /* empty */ }\n}\n","import type { IErrorResult } from './errorResult.mjs';\nimport { ErrorResult } from './errorResult.mjs';\nimport type { ResultType } from './index.mjs';\nimport type { ISuccessResult } from './successResult.mjs';\nimport { SuccessResult } from './successResult.mjs';\n\n// eslint-disable-next-line @typescript-eslint/no-extraneous-class\nexport abstract class Result {\n\n  public static success<T>(value: T): ISuccessResult<T> {\n    return new SuccessResult(value);\n  }\n\n  public static fail(error: Error): IErrorResult {\n    return new ErrorResult(error);\n  }\n\n  public static combine<T>(results: ResultType<T>[]): ResultType<T | undefined> {\n    for (const result of results) {\n      if (!result.success) {\n        return result;\n      }\n    }\n    return Result.success<undefined>(undefined);\n  }\n}\n","import type { IErrorResult } from './errorResult.mjs';\nimport type { ISuccessResult } from './successResult.mjs';\n\nexport { Result } from './result.mjs';\nexport type { ISuccessResult };\nexport type { IErrorResult };\n\nexport type ResultType<T> = ISuccessResult<T> | IErrorResult;\n\n// eslint-disable-next-line @stylistic/comma-dangle\nexport const isSuccessResult = <T,>(result: ResultType<T>): result is ISuccessResult<T> => {\n  return result.success;\n};\n\n// eslint-disable-next-line @stylistic/comma-dangle\nexport const isErrorResult = <T,>(result: ResultType<T>): result is IErrorResult => {\n  return !result.success;\n};\n"],"mappings":";AAKO,IAAM,cAAN,MAA0C;AAAA,EAGxC,YAA4B,OAAc;AAAd;AAFnC,SAAgB,UAAU;AAAA,EAEqC;AACjE;;;ACJO,IAAM,gBAAN,MAAoD;AAAA,EAGlD,YAA4B,OAAU;AAAV;AAFnC,SAAgB,UAAU;AAAA,EAEiC;AAC7D;;;ACFO,IAAe,SAAf,MAAe,QAAO;AAAA,EAE3B,OAAc,QAAW,OAA6B;AACpD,WAAO,IAAI,cAAc,KAAK;AAAA,EAChC;AAAA,EAEA,OAAc,KAAK,OAA4B;AAC7C,WAAO,IAAI,YAAY,KAAK;AAAA,EAC9B;AAAA,EAEA,OAAc,QAAW,SAAqD;AAC5E,eAAW,UAAU,SAAS;AAC5B,UAAI,CAAC,OAAO,SAAS;AACnB,eAAO;AAAA,MACT;AAAA,IACF;AACA,WAAO,QAAO,QAAmB,MAAS;AAAA,EAC5C;AACF;;;ACfO,IAAM,kBAAkB,CAAK,WAAuD;AACzF,SAAO,OAAO;AAChB;AAGO,IAAM,gBAAgB,CAAK,WAAkD;AAClF,SAAO,CAAC,OAAO;AACjB;","names":[]}
+{"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  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n  readonly map: <M>(mapFunction: (value: never) => M) => IErrorResult<E>;\n  readonly mapAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<IErrorResult<E>>;\n  readonly mapErr: <M>(mapFunction: (value: E) => M) => IErrorResult<M>;\n  readonly mapErrAsync: <M>(mapFunction: (value: E) => Promise<M>) => Promise<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  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-unnecessary-type-parameters\n  public map<M>(mapFunction: (error: never) => M): this {\n    return this;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await\n  public async mapAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<this> {\n    return this;\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","export interface ISuccessResult<T = void> {\n  readonly success: true;\n  readonly value: T;\n  readonly map: <M>(mapFunction: (value: T) => M) => ISuccessResult<M>;\n  readonly mapAsync: <M>(mapFunction: (value: T) => Promise<M>) => Promise<ISuccessResult<M>>;\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters\n  readonly mapErr: <M>(mapFunction: (value: never) => M) => ISuccessResult<T>;\n  readonly mapErrAsync: <M>(mapFunction: (value: never) => Promise<M>) => Promise<ISuccessResult<T>>;\n}\n\nexport class SuccessResult<T = void> implements 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): this {\n    return this;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/require-await\n  public async mapErrAsync<M>(mapFunction: (value: never) => Promise<M>): Promise<this> {\n    return this;\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 Result<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: 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[]): Result {\n  for (const r of results) {\n    if (!r.success) {\n      return r;\n    }\n  }\n  return new SuccessResult(undefined);\n}\n"],"mappings":";AAUO,IAAM,cAAN,MAAM,aAA0C;AAAA,EAG9C,YAA4B,OAAU;AAAV;AAFnC,SAAgB,UAAU;AAAA,EAEiC;AAAA;AAAA,EAGpD,IAAO,aAAwC;AACpD,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,MAAa,SAAY,aAA0D;AACjF,WAAO;AAAA,EACT;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,eAAqD;AAAA,EAIzD,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,aAAwC;AACvD,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,MAAa,YAAe,aAA0D;AACpF,WAAO;AAAA,EACT;AACF;;;ACvBO,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,WAAW,SAA2B;AACpD,aAAW,KAAK,SAAS;AACvB,QAAI,CAAC,EAAE,SAAS;AACd,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO,IAAI,cAAc,MAAS;AACpC;","names":[]}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "generic-result-type",
-  "version": "1.0.0",
+  "version": "2.1.0",
   "description": "A generic result wrapper",
   "license": "ISC",
   "author": "Dave Welsh",
   "repository": {
     "type": "git",
-    "url": "https://github.com/move-zig/generic-result-type.git"
+    "url": "git+https://github.com/move-zig/generic-result-type.git"
   },
   "type": "module",
   "main": "./dist/index.cjs",
@@ -31,7 +31,7 @@
     "typecheck": "tsc -p tsconfig.build.json --noEmit",
     "test": "jest --verbose",
     "test:watch": "jest --verbose --watch",
-    "lint": "eslint src"
+    "lint": "eslint"
   },
   "devDependencies": {
     "@eslint/compat": "^2.0.0",
@@ -48,9 +48,10 @@
     "eslint-plugin-jest": "^29.12.1",
     "jest": "^30.2.0",
     "jiti": "^2.6.1",
+    "ts-node": "^10.9.2",
     "tsup": "^8.5.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.52.0"
   }
-}
+}