@j2blasco/ts-result 0.0.9 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,139 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  andThen: () => andThen,
+  andThenAsync: () => andThenAsync,
+  errorUnkown: () => errorUnkown,
+  errorWithCode: () => errorWithCode,
+  makeSafePromise: () => makeSafePromise,
+  resultError: () => resultError,
+  resultSuccess: () => resultSuccess,
+  resultSuccessVoid: () => resultSuccessVoid,
+  unwrapSuccessResult: () => unwrapSuccessResult
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/result.ts
+function unwrapSuccessResult(result) {
+  if (result instanceof ResultSuccessImp) {
+    return result["value"];
+  }
+  throw new Error("Unreachable code. Result is an error");
+}
+function errorWithCode(code, data) {
+  return {
+    code,
+    data
+  };
+}
+function errorUnkown(message) {
+  return {
+    code: "unknown",
+    data: { message }
+  };
+}
+function resultSuccessVoid() {
+  return new ResultSuccessImp(void 0);
+}
+function resultSuccess(value) {
+  return new ResultSuccessImp(value);
+}
+var resultError = class {
+  static unknown(message) {
+    return new ResultErrorImp(errorUnkown(message));
+  }
+  static withCode(code, data = {}) {
+    return new ResultErrorImp(
+      errorWithCode(code, data)
+    );
+  }
+  static fromError(error) {
+    return new ResultErrorImp(error);
+  }
+};
+var ResultSuccessImp = class {
+  constructor(value) {
+    this.value = value;
+  }
+  andThen(f) {
+    return f(this.value);
+  }
+  async andThenAsync(f) {
+    return await f(this.value);
+  }
+  catchError(_f) {
+    return this;
+  }
+  async catchErrorAsync(_f) {
+    return this;
+  }
+  unwrapOrThrow(_errorCallback) {
+    return this.value;
+  }
+};
+var ResultErrorImp = class {
+  constructor(error) {
+    this.error = error;
+  }
+  andThen(_f) {
+    return this;
+  }
+  async andThenAsync(_f) {
+    return this;
+  }
+  catchError(f) {
+    return f(this.error);
+  }
+  async catchErrorAsync(f) {
+    return await f(this.error);
+  }
+  unwrapOrThrow(errorCallback) {
+    if (errorCallback !== void 0) {
+      errorCallback(this.error);
+    }
+    throw this.error;
+  }
+};
+function makeSafePromise(promise) {
+  return promise.then((value) => resultSuccess(value)).catch((error) => resultError.unknown(error.message));
+}
+
+// src/result-functions.ts
+function andThen(callback) {
+  return (result) => result.andThen(callback);
+}
+function andThenAsync(callback) {
+  return (result) => result.andThenAsync(callback);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  andThen,
+  andThenAsync,
+  errorUnkown,
+  errorWithCode,
+  makeSafePromise,
+  resultError,
+  resultSuccess,
+  resultSuccessVoid,
+  unwrapSuccessResult
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/result.ts","../src/result-functions.ts"],"sourcesContent":["export * from './result';\r\nexport * from './result-functions';","export interface Result<TSuccess1, TError1> {\r\n  andThen<TResult extends Result<any, any>>(\r\n    f: (value: TSuccess1) => TResult,\r\n  ): Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>;\r\n  andThenAsync<TResult extends Result<any, any>>(\r\n    f: (value: TSuccess1) => Promise<TResult>,\r\n  ): Promise<Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>>;\r\n  catchError<TResult extends Result<any, any>>(\r\n    f: (error: TError1) => TResult,\r\n  ): Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>;\r\n  catchErrorAsync<TResult extends Result<any, any>>(\r\n    f: (error: TError1) => Promise<TResult>,\r\n  ): Promise<Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>>;\r\n  unwrapOrThrow(errorCallback?: (e: TError1) => void): TSuccess1;\r\n}\r\n\r\nexport function unwrapSuccessResult<T>(result: Result<T, never>): T {\r\n  if (result instanceof ResultSuccessImp) {\r\n    return result['value'];\r\n  }\r\n  throw new Error('Unreachable code. Result is an error');\r\n}\r\n\r\nexport type ErrorWithCode<TCode, TData = object> = { code: TCode; data: TData };\r\nexport function errorWithCode<TCode, TData>(\r\n  code: TCode,\r\n  data: TData,\r\n): ErrorWithCode<TCode, TData> {\r\n  return {\r\n    code,\r\n    data,\r\n  };\r\n}\r\n\r\nexport type ErrorUnknown = {\r\n  code: 'unknown';\r\n  data: { message: string };\r\n};\r\nexport function errorUnkown(message: string): ErrorUnknown {\r\n  return {\r\n    code: 'unknown',\r\n    data: { message },\r\n  };\r\n}\r\n\r\nexport type SuccessType<T> = T extends Result<infer S, any> ? S : never;\r\nexport type ErrorType<T> = T extends Result<any, infer E> ? E : never;\r\n\r\nexport type SuccessVoid = never;\r\n\r\nexport function resultSuccessVoid(): Result<SuccessVoid, never> {\r\n  return new ResultSuccessImp<SuccessVoid>(undefined as never);\r\n}\r\n\r\nexport function resultSuccess<TSuccess1>(\r\n  value: TSuccess1,\r\n): Result<TSuccess1, never> {\r\n  return new ResultSuccessImp<TSuccess1>(value);\r\n}\r\n\r\ntype EnforceLiteral<T> = string extends T ? never : T;\r\n\r\nexport class resultError {\r\n  public static unknown(message: string): Result<never, ErrorUnknown> {\r\n    return new ResultErrorImp<ErrorUnknown>(errorUnkown(message));\r\n  }\r\n  public static withCode<TCode, TData = object>(\r\n    code: EnforceLiteral<TCode>,\r\n    data: TData = {} as TData,\r\n  ): Result<never, ErrorWithCode<TCode, TData>> {\r\n    return new ResultErrorImp<ErrorWithCode<TCode, TData>>(\r\n      errorWithCode(code, data),\r\n    );\r\n  }\r\n  public static fromError<\r\n    TSuccess1,\r\n    TError1 extends ErrorWithCode<any, object>,\r\n  >(error: TError1): Result<TSuccess1, TError1> {\r\n    return new ResultErrorImp<TError1>(error);\r\n  }\r\n}\r\n\r\nclass ResultSuccessImp<TSuccess1> implements Result<TSuccess1, never> {\r\n  constructor(private value: TSuccess1) {}\r\n\r\n  public andThen<TSuccess2, TError2>(\r\n    f: (value: TSuccess1) => Result<TSuccess2, TError2>,\r\n  ): Result<TSuccess2, TError2> {\r\n    return f(this.value);\r\n  }\r\n\r\n  public async andThenAsync<TSuccess2, TError2>(\r\n    f: (value: TSuccess1) => Promise<Result<TSuccess2, TError2>>,\r\n  ): Promise<Result<TSuccess2, TError2>> {\r\n    return await f(this.value);\r\n  }\r\n\r\n  public catchError<TSuccess2, TError2>(\r\n    _f: (error: never) => Result<TSuccess2, TError2>,\r\n  ): Result<TSuccess1 | TSuccess2, TError2> {\r\n    return this;\r\n  }\r\n\r\n  public async catchErrorAsync<TSuccess2, TError2>(\r\n    _f: (error: never) => Promise<Result<TSuccess2, TError2>>,\r\n  ): Promise<Result<TSuccess1 | TSuccess2, TError2>> {\r\n    return this;\r\n  }\r\n\r\n  public unwrapOrThrow(_errorCallback?: (e: never) => void): TSuccess1 {\r\n    return this.value;\r\n  }\r\n}\r\n\r\nclass ResultErrorImp<TError1> implements Result<never, TError1> {\r\n  constructor(private error: TError1) {}\r\n\r\n  public andThen<TSuccess2, TError2>(\r\n    _f: (value: never) => Result<TSuccess2, TError2>,\r\n  ): Result<TSuccess2, TError1 | TError2> {\r\n    return this;\r\n  }\r\n\r\n  public async andThenAsync<TSuccess2, TError2>(\r\n    _f: (value: never) => Promise<Result<TSuccess2, TError2>>,\r\n  ): Promise<Result<TSuccess2, TError1 | TError2>> {\r\n    return this;\r\n  }\r\n\r\n  public catchError<TSuccess2, TError2>(\r\n    f: (error: TError1) => Result<TSuccess2, TError2>,\r\n  ): Result<TSuccess2, TError2> {\r\n    return f(this.error);\r\n  }\r\n\r\n  public async catchErrorAsync<TSuccess2, TError2>(\r\n    f: (error: TError1) => Promise<Result<TSuccess2, TError2>>,\r\n  ): Promise<Result<TSuccess2, TError2>> {\r\n    return await f(this.error);\r\n  }\r\n\r\n  public unwrapOrThrow(errorCallback?: (e: TError1) => void): never {\r\n    if (errorCallback !== undefined) {\r\n      errorCallback(this.error);\r\n    }\r\n    throw this.error;\r\n  }\r\n}\r\n\r\nexport type UnwrapErrorFromResult<T> =\r\n  T extends Result<any, infer U> ? U : never;\r\n\r\nexport function makeSafePromise<T>(\r\n  promise: Promise<T>,\r\n): Promise<Result<T, ErrorUnknown>> {\r\n  return promise\r\n    .then((value) => resultSuccess(value))\r\n    .catch((error) => resultError.unknown(error.message));\r\n}","import { ErrorType, Result, SuccessType } from \"./result\";\r\n\r\nexport function andThen<TSuccess, TError, TResult extends Result<any, any>>(\r\n  callback: (value: TSuccess) => TResult\r\n): (\r\n  result: Result<TSuccess, TError>\r\n) => Result<SuccessType<TResult>, TError | ErrorType<TResult>> {\r\n  return (result) => result.andThen(callback);\r\n}\r\n\r\nexport function andThenAsync<\r\n  TSuccess,\r\n  TError,\r\n  TResult extends Result<any, any>\r\n>(\r\n  callback: (value: TSuccess) => Promise<TResult>\r\n): (\r\n  result: Result<TSuccess, TError>\r\n) => Promise<Result<SuccessType<TResult>, TError | ErrorType<TResult>>> {\r\n  return (result) => result.andThenAsync(callback);\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACgBO,SAAS,oBAAuB,QAA6B;AAClE,MAAI,kBAAkB,kBAAkB;AACtC,WAAO,OAAO,OAAO;AAAA,EACvB;AACA,QAAM,IAAI,MAAM,sCAAsC;AACxD;AAGO,SAAS,cACd,MACA,MAC6B;AAC7B,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;AAMO,SAAS,YAAY,SAA+B;AACzD,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,EAAE,QAAQ;AAAA,EAClB;AACF;AAOO,SAAS,oBAAgD;AAC9D,SAAO,IAAI,iBAA8B,MAAkB;AAC7D;AAEO,SAAS,cACd,OAC0B;AAC1B,SAAO,IAAI,iBAA4B,KAAK;AAC9C;AAIO,IAAM,cAAN,MAAkB;AAAA,EACvB,OAAc,QAAQ,SAA8C;AAClE,WAAO,IAAI,eAA6B,YAAY,OAAO,CAAC;AAAA,EAC9D;AAAA,EACA,OAAc,SACZ,MACA,OAAc,CAAC,GAC6B;AAC5C,WAAO,IAAI;AAAA,MACT,cAAc,MAAM,IAAI;AAAA,IAC1B;AAAA,EACF;AAAA,EACA,OAAc,UAGZ,OAA4C;AAC5C,WAAO,IAAI,eAAwB,KAAK;AAAA,EAC1C;AACF;AAEA,IAAM,mBAAN,MAAsE;AAAA,EACpE,YAAoB,OAAkB;AAAlB;AAAA,EAAmB;AAAA,EAEhC,QACL,GAC4B;AAC5B,WAAO,EAAE,KAAK,KAAK;AAAA,EACrB;AAAA,EAEA,MAAa,aACX,GACqC;AACrC,WAAO,MAAM,EAAE,KAAK,KAAK;AAAA,EAC3B;AAAA,EAEO,WACL,IACwC;AACxC,WAAO;AAAA,EACT;AAAA,EAEA,MAAa,gBACX,IACiD;AACjD,WAAO;AAAA,EACT;AAAA,EAEO,cAAc,gBAAgD;AACnE,WAAO,KAAK;AAAA,EACd;AACF;AAEA,IAAM,iBAAN,MAAgE;AAAA,EAC9D,YAAoB,OAAgB;AAAhB;AAAA,EAAiB;AAAA,EAE9B,QACL,IACsC;AACtC,WAAO;AAAA,EACT;AAAA,EAEA,MAAa,aACX,IAC+C;AAC/C,WAAO;AAAA,EACT;AAAA,EAEO,WACL,GAC4B;AAC5B,WAAO,EAAE,KAAK,KAAK;AAAA,EACrB;AAAA,EAEA,MAAa,gBACX,GACqC;AACrC,WAAO,MAAM,EAAE,KAAK,KAAK;AAAA,EAC3B;AAAA,EAEO,cAAc,eAA6C;AAChE,QAAI,kBAAkB,QAAW;AAC/B,oBAAc,KAAK,KAAK;AAAA,IAC1B;AACA,UAAM,KAAK;AAAA,EACb;AACF;AAKO,SAAS,gBACd,SACkC;AAClC,SAAO,QACJ,KAAK,CAAC,UAAU,cAAc,KAAK,CAAC,EACpC,MAAM,CAAC,UAAU,YAAY,QAAQ,MAAM,OAAO,CAAC;AACxD;;;AC5JO,SAAS,QACd,UAG6D;AAC7D,SAAO,CAAC,WAAW,OAAO,QAAQ,QAAQ;AAC5C;AAEO,SAAS,aAKd,UAGsE;AACtE,SAAO,CAAC,WAAW,OAAO,aAAa,QAAQ;AACjD;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,38 @@
+interface Result<TSuccess1, TError1> {
+    andThen<TResult extends Result<any, any>>(f: (value: TSuccess1) => TResult): Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>;
+    andThenAsync<TResult extends Result<any, any>>(f: (value: TSuccess1) => Promise<TResult>): Promise<Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>>;
+    catchError<TResult extends Result<any, any>>(f: (error: TError1) => TResult): Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>;
+    catchErrorAsync<TResult extends Result<any, any>>(f: (error: TError1) => Promise<TResult>): Promise<Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>>;
+    unwrapOrThrow(errorCallback?: (e: TError1) => void): TSuccess1;
+}
+declare function unwrapSuccessResult<T>(result: Result<T, never>): T;
+type ErrorWithCode<TCode, TData = object> = {
+    code: TCode;
+    data: TData;
+};
+declare function errorWithCode<TCode, TData>(code: TCode, data: TData): ErrorWithCode<TCode, TData>;
+type ErrorUnknown = {
+    code: 'unknown';
+    data: {
+        message: string;
+    };
+};
+declare function errorUnkown(message: string): ErrorUnknown;
+type SuccessType<T> = T extends Result<infer S, any> ? S : never;
+type ErrorType<T> = T extends Result<any, infer E> ? E : never;
+type SuccessVoid = never;
+declare function resultSuccessVoid(): Result<SuccessVoid, never>;
+declare function resultSuccess<TSuccess1>(value: TSuccess1): Result<TSuccess1, never>;
+type EnforceLiteral<T> = string extends T ? never : T;
+declare class resultError {
+    static unknown(message: string): Result<never, ErrorUnknown>;
+    static withCode<TCode, TData = object>(code: EnforceLiteral<TCode>, data?: TData): Result<never, ErrorWithCode<TCode, TData>>;
+    static fromError<TSuccess1, TError1 extends ErrorWithCode<any, object>>(error: TError1): Result<TSuccess1, TError1>;
+}
+type UnwrapErrorFromResult<T> = T extends Result<any, infer U> ? U : never;
+declare function makeSafePromise<T>(promise: Promise<T>): Promise<Result<T, ErrorUnknown>>;
+
+declare function andThen<TSuccess, TError, TResult extends Result<any, any>>(callback: (value: TSuccess) => TResult): (result: Result<TSuccess, TError>) => Result<SuccessType<TResult>, TError | ErrorType<TResult>>;
+declare function andThenAsync<TSuccess, TError, TResult extends Result<any, any>>(callback: (value: TSuccess) => Promise<TResult>): (result: Result<TSuccess, TError>) => Promise<Result<SuccessType<TResult>, TError | ErrorType<TResult>>>;
+
+export { type ErrorType, type ErrorUnknown, type ErrorWithCode, type Result, type SuccessType, type SuccessVoid, type UnwrapErrorFromResult, andThen, andThenAsync, errorUnkown, errorWithCode, makeSafePromise, resultError, resultSuccess, resultSuccessVoid, unwrapSuccessResult };

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+interface Result<TSuccess1, TError1> {
+    andThen<TResult extends Result<any, any>>(f: (value: TSuccess1) => TResult): Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>;
+    andThenAsync<TResult extends Result<any, any>>(f: (value: TSuccess1) => Promise<TResult>): Promise<Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>>;
+    catchError<TResult extends Result<any, any>>(f: (error: TError1) => TResult): Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>;
+    catchErrorAsync<TResult extends Result<any, any>>(f: (error: TError1) => Promise<TResult>): Promise<Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>>;
+    unwrapOrThrow(errorCallback?: (e: TError1) => void): TSuccess1;
+}
+declare function unwrapSuccessResult<T>(result: Result<T, never>): T;
+type ErrorWithCode<TCode, TData = object> = {
+    code: TCode;
+    data: TData;
+};
+declare function errorWithCode<TCode, TData>(code: TCode, data: TData): ErrorWithCode<TCode, TData>;
+type ErrorUnknown = {
+    code: 'unknown';
+    data: {
+        message: string;
+    };
+};
+declare function errorUnkown(message: string): ErrorUnknown;
+type SuccessType<T> = T extends Result<infer S, any> ? S : never;
+type ErrorType<T> = T extends Result<any, infer E> ? E : never;
+type SuccessVoid = never;
+declare function resultSuccessVoid(): Result<SuccessVoid, never>;
+declare function resultSuccess<TSuccess1>(value: TSuccess1): Result<TSuccess1, never>;
+type EnforceLiteral<T> = string extends T ? never : T;
+declare class resultError {
+    static unknown(message: string): Result<never, ErrorUnknown>;
+    static withCode<TCode, TData = object>(code: EnforceLiteral<TCode>, data?: TData): Result<never, ErrorWithCode<TCode, TData>>;
+    static fromError<TSuccess1, TError1 extends ErrorWithCode<any, object>>(error: TError1): Result<TSuccess1, TError1>;
+}
+type UnwrapErrorFromResult<T> = T extends Result<any, infer U> ? U : never;
+declare function makeSafePromise<T>(promise: Promise<T>): Promise<Result<T, ErrorUnknown>>;
+
+declare function andThen<TSuccess, TError, TResult extends Result<any, any>>(callback: (value: TSuccess) => TResult): (result: Result<TSuccess, TError>) => Result<SuccessType<TResult>, TError | ErrorType<TResult>>;
+declare function andThenAsync<TSuccess, TError, TResult extends Result<any, any>>(callback: (value: TSuccess) => Promise<TResult>): (result: Result<TSuccess, TError>) => Promise<Result<SuccessType<TResult>, TError | ErrorType<TResult>>>;
+
+export { type ErrorType, type ErrorUnknown, type ErrorWithCode, type Result, type SuccessType, type SuccessVoid, type UnwrapErrorFromResult, andThen, andThenAsync, errorUnkown, errorWithCode, makeSafePromise, resultError, resultSuccess, resultSuccessVoid, unwrapSuccessResult };

package/dist/index.js

@@ -0,0 +1,104 @@
+// src/result.ts
+function unwrapSuccessResult(result) {
+  if (result instanceof ResultSuccessImp) {
+    return result["value"];
+  }
+  throw new Error("Unreachable code. Result is an error");
+}
+function errorWithCode(code, data) {
+  return {
+    code,
+    data
+  };
+}
+function errorUnkown(message) {
+  return {
+    code: "unknown",
+    data: { message }
+  };
+}
+function resultSuccessVoid() {
+  return new ResultSuccessImp(void 0);
+}
+function resultSuccess(value) {
+  return new ResultSuccessImp(value);
+}
+var resultError = class {
+  static unknown(message) {
+    return new ResultErrorImp(errorUnkown(message));
+  }
+  static withCode(code, data = {}) {
+    return new ResultErrorImp(
+      errorWithCode(code, data)
+    );
+  }
+  static fromError(error) {
+    return new ResultErrorImp(error);
+  }
+};
+var ResultSuccessImp = class {
+  constructor(value) {
+    this.value = value;
+  }
+  andThen(f) {
+    return f(this.value);
+  }
+  async andThenAsync(f) {
+    return await f(this.value);
+  }
+  catchError(_f) {
+    return this;
+  }
+  async catchErrorAsync(_f) {
+    return this;
+  }
+  unwrapOrThrow(_errorCallback) {
+    return this.value;
+  }
+};
+var ResultErrorImp = class {
+  constructor(error) {
+    this.error = error;
+  }
+  andThen(_f) {
+    return this;
+  }
+  async andThenAsync(_f) {
+    return this;
+  }
+  catchError(f) {
+    return f(this.error);
+  }
+  async catchErrorAsync(f) {
+    return await f(this.error);
+  }
+  unwrapOrThrow(errorCallback) {
+    if (errorCallback !== void 0) {
+      errorCallback(this.error);
+    }
+    throw this.error;
+  }
+};
+function makeSafePromise(promise) {
+  return promise.then((value) => resultSuccess(value)).catch((error) => resultError.unknown(error.message));
+}
+
+// src/result-functions.ts
+function andThen(callback) {
+  return (result) => result.andThen(callback);
+}
+function andThenAsync(callback) {
+  return (result) => result.andThenAsync(callback);
+}
+export {
+  andThen,
+  andThenAsync,
+  errorUnkown,
+  errorWithCode,
+  makeSafePromise,
+  resultError,
+  resultSuccess,
+  resultSuccessVoid,
+  unwrapSuccessResult
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/result.ts","../src/result-functions.ts"],"sourcesContent":["export interface Result<TSuccess1, TError1> {\r\n  andThen<TResult extends Result<any, any>>(\r\n    f: (value: TSuccess1) => TResult,\r\n  ): Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>;\r\n  andThenAsync<TResult extends Result<any, any>>(\r\n    f: (value: TSuccess1) => Promise<TResult>,\r\n  ): Promise<Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>>;\r\n  catchError<TResult extends Result<any, any>>(\r\n    f: (error: TError1) => TResult,\r\n  ): Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>;\r\n  catchErrorAsync<TResult extends Result<any, any>>(\r\n    f: (error: TError1) => Promise<TResult>,\r\n  ): Promise<Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>>;\r\n  unwrapOrThrow(errorCallback?: (e: TError1) => void): TSuccess1;\r\n}\r\n\r\nexport function unwrapSuccessResult<T>(result: Result<T, never>): T {\r\n  if (result instanceof ResultSuccessImp) {\r\n    return result['value'];\r\n  }\r\n  throw new Error('Unreachable code. Result is an error');\r\n}\r\n\r\nexport type ErrorWithCode<TCode, TData = object> = { code: TCode; data: TData };\r\nexport function errorWithCode<TCode, TData>(\r\n  code: TCode,\r\n  data: TData,\r\n): ErrorWithCode<TCode, TData> {\r\n  return {\r\n    code,\r\n    data,\r\n  };\r\n}\r\n\r\nexport type ErrorUnknown = {\r\n  code: 'unknown';\r\n  data: { message: string };\r\n};\r\nexport function errorUnkown(message: string): ErrorUnknown {\r\n  return {\r\n    code: 'unknown',\r\n    data: { message },\r\n  };\r\n}\r\n\r\nexport type SuccessType<T> = T extends Result<infer S, any> ? S : never;\r\nexport type ErrorType<T> = T extends Result<any, infer E> ? E : never;\r\n\r\nexport type SuccessVoid = never;\r\n\r\nexport function resultSuccessVoid(): Result<SuccessVoid, never> {\r\n  return new ResultSuccessImp<SuccessVoid>(undefined as never);\r\n}\r\n\r\nexport function resultSuccess<TSuccess1>(\r\n  value: TSuccess1,\r\n): Result<TSuccess1, never> {\r\n  return new ResultSuccessImp<TSuccess1>(value);\r\n}\r\n\r\ntype EnforceLiteral<T> = string extends T ? never : T;\r\n\r\nexport class resultError {\r\n  public static unknown(message: string): Result<never, ErrorUnknown> {\r\n    return new ResultErrorImp<ErrorUnknown>(errorUnkown(message));\r\n  }\r\n  public static withCode<TCode, TData = object>(\r\n    code: EnforceLiteral<TCode>,\r\n    data: TData = {} as TData,\r\n  ): Result<never, ErrorWithCode<TCode, TData>> {\r\n    return new ResultErrorImp<ErrorWithCode<TCode, TData>>(\r\n      errorWithCode(code, data),\r\n    );\r\n  }\r\n  public static fromError<\r\n    TSuccess1,\r\n    TError1 extends ErrorWithCode<any, object>,\r\n  >(error: TError1): Result<TSuccess1, TError1> {\r\n    return new ResultErrorImp<TError1>(error);\r\n  }\r\n}\r\n\r\nclass ResultSuccessImp<TSuccess1> implements Result<TSuccess1, never> {\r\n  constructor(private value: TSuccess1) {}\r\n\r\n  public andThen<TSuccess2, TError2>(\r\n    f: (value: TSuccess1) => Result<TSuccess2, TError2>,\r\n  ): Result<TSuccess2, TError2> {\r\n    return f(this.value);\r\n  }\r\n\r\n  public async andThenAsync<TSuccess2, TError2>(\r\n    f: (value: TSuccess1) => Promise<Result<TSuccess2, TError2>>,\r\n  ): Promise<Result<TSuccess2, TError2>> {\r\n    return await f(this.value);\r\n  }\r\n\r\n  public catchError<TSuccess2, TError2>(\r\n    _f: (error: never) => Result<TSuccess2, TError2>,\r\n  ): Result<TSuccess1 | TSuccess2, TError2> {\r\n    return this;\r\n  }\r\n\r\n  public async catchErrorAsync<TSuccess2, TError2>(\r\n    _f: (error: never) => Promise<Result<TSuccess2, TError2>>,\r\n  ): Promise<Result<TSuccess1 | TSuccess2, TError2>> {\r\n    return this;\r\n  }\r\n\r\n  public unwrapOrThrow(_errorCallback?: (e: never) => void): TSuccess1 {\r\n    return this.value;\r\n  }\r\n}\r\n\r\nclass ResultErrorImp<TError1> implements Result<never, TError1> {\r\n  constructor(private error: TError1) {}\r\n\r\n  public andThen<TSuccess2, TError2>(\r\n    _f: (value: never) => Result<TSuccess2, TError2>,\r\n  ): Result<TSuccess2, TError1 | TError2> {\r\n    return this;\r\n  }\r\n\r\n  public async andThenAsync<TSuccess2, TError2>(\r\n    _f: (value: never) => Promise<Result<TSuccess2, TError2>>,\r\n  ): Promise<Result<TSuccess2, TError1 | TError2>> {\r\n    return this;\r\n  }\r\n\r\n  public catchError<TSuccess2, TError2>(\r\n    f: (error: TError1) => Result<TSuccess2, TError2>,\r\n  ): Result<TSuccess2, TError2> {\r\n    return f(this.error);\r\n  }\r\n\r\n  public async catchErrorAsync<TSuccess2, TError2>(\r\n    f: (error: TError1) => Promise<Result<TSuccess2, TError2>>,\r\n  ): Promise<Result<TSuccess2, TError2>> {\r\n    return await f(this.error);\r\n  }\r\n\r\n  public unwrapOrThrow(errorCallback?: (e: TError1) => void): never {\r\n    if (errorCallback !== undefined) {\r\n      errorCallback(this.error);\r\n    }\r\n    throw this.error;\r\n  }\r\n}\r\n\r\nexport type UnwrapErrorFromResult<T> =\r\n  T extends Result<any, infer U> ? U : never;\r\n\r\nexport function makeSafePromise<T>(\r\n  promise: Promise<T>,\r\n): Promise<Result<T, ErrorUnknown>> {\r\n  return promise\r\n    .then((value) => resultSuccess(value))\r\n    .catch((error) => resultError.unknown(error.message));\r\n}","import { ErrorType, Result, SuccessType } from \"./result\";\r\n\r\nexport function andThen<TSuccess, TError, TResult extends Result<any, any>>(\r\n  callback: (value: TSuccess) => TResult\r\n): (\r\n  result: Result<TSuccess, TError>\r\n) => Result<SuccessType<TResult>, TError | ErrorType<TResult>> {\r\n  return (result) => result.andThen(callback);\r\n}\r\n\r\nexport function andThenAsync<\r\n  TSuccess,\r\n  TError,\r\n  TResult extends Result<any, any>\r\n>(\r\n  callback: (value: TSuccess) => Promise<TResult>\r\n): (\r\n  result: Result<TSuccess, TError>\r\n) => Promise<Result<SuccessType<TResult>, TError | ErrorType<TResult>>> {\r\n  return (result) => result.andThenAsync(callback);\r\n}\r\n"],"mappings":";AAgBO,SAAS,oBAAuB,QAA6B;AAClE,MAAI,kBAAkB,kBAAkB;AACtC,WAAO,OAAO,OAAO;AAAA,EACvB;AACA,QAAM,IAAI,MAAM,sCAAsC;AACxD;AAGO,SAAS,cACd,MACA,MAC6B;AAC7B,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EACF;AACF;AAMO,SAAS,YAAY,SAA+B;AACzD,SAAO;AAAA,IACL,MAAM;AAAA,IACN,MAAM,EAAE,QAAQ;AAAA,EAClB;AACF;AAOO,SAAS,oBAAgD;AAC9D,SAAO,IAAI,iBAA8B,MAAkB;AAC7D;AAEO,SAAS,cACd,OAC0B;AAC1B,SAAO,IAAI,iBAA4B,KAAK;AAC9C;AAIO,IAAM,cAAN,MAAkB;AAAA,EACvB,OAAc,QAAQ,SAA8C;AAClE,WAAO,IAAI,eAA6B,YAAY,OAAO,CAAC;AAAA,EAC9D;AAAA,EACA,OAAc,SACZ,MACA,OAAc,CAAC,GAC6B;AAC5C,WAAO,IAAI;AAAA,MACT,cAAc,MAAM,IAAI;AAAA,IAC1B;AAAA,EACF;AAAA,EACA,OAAc,UAGZ,OAA4C;AAC5C,WAAO,IAAI,eAAwB,KAAK;AAAA,EAC1C;AACF;AAEA,IAAM,mBAAN,MAAsE;AAAA,EACpE,YAAoB,OAAkB;AAAlB;AAAA,EAAmB;AAAA,EAEhC,QACL,GAC4B;AAC5B,WAAO,EAAE,KAAK,KAAK;AAAA,EACrB;AAAA,EAEA,MAAa,aACX,GACqC;AACrC,WAAO,MAAM,EAAE,KAAK,KAAK;AAAA,EAC3B;AAAA,EAEO,WACL,IACwC;AACxC,WAAO;AAAA,EACT;AAAA,EAEA,MAAa,gBACX,IACiD;AACjD,WAAO;AAAA,EACT;AAAA,EAEO,cAAc,gBAAgD;AACnE,WAAO,KAAK;AAAA,EACd;AACF;AAEA,IAAM,iBAAN,MAAgE;AAAA,EAC9D,YAAoB,OAAgB;AAAhB;AAAA,EAAiB;AAAA,EAE9B,QACL,IACsC;AACtC,WAAO;AAAA,EACT;AAAA,EAEA,MAAa,aACX,IAC+C;AAC/C,WAAO;AAAA,EACT;AAAA,EAEO,WACL,GAC4B;AAC5B,WAAO,EAAE,KAAK,KAAK;AAAA,EACrB;AAAA,EAEA,MAAa,gBACX,GACqC;AACrC,WAAO,MAAM,EAAE,KAAK,KAAK;AAAA,EAC3B;AAAA,EAEO,cAAc,eAA6C;AAChE,QAAI,kBAAkB,QAAW;AAC/B,oBAAc,KAAK,KAAK;AAAA,IAC1B;AACA,UAAM,KAAK;AAAA,EACb;AACF;AAKO,SAAS,gBACd,SACkC;AAClC,SAAO,QACJ,KAAK,CAAC,UAAU,cAAc,KAAK,CAAC,EACpC,MAAM,CAAC,UAAU,YAAY,QAAQ,MAAM,OAAO,CAAC;AACxD;;;AC5JO,SAAS,QACd,UAG6D;AAC7D,SAAO,CAAC,WAAW,OAAO,QAAQ,QAAQ;AAC5C;AAEO,SAAS,aAKd,UAGsE;AACtE,SAAO,CAAC,WAAW,OAAO,aAAa,QAAQ;AACjD;","names":[]}

package/package.json

@@ -1,43 +1,51 @@
 {
   "name": "@j2blasco/ts-result",
-  "version": "0.0.9",
-  "description": "Result Monad for TypeScript",  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
+  "version": "0.1.2",
+  "description": "Result Monad for TypeScript",
+  "author": "j2blasco",
+  "license": "MIT",
+  "keywords": [
+    "typescript",
+    "result",
+    "monad",
+    "error-handling"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/j2blasco/ts-crud"
   },
-  "types": "./types/index.d.ts",
   "exports": {
     ".": {
-      "types": "./types/index.d.ts",
-      "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     }
-  },  "files": [
-    "dist/cjs",
-    "dist/esm", 
-    "types",
+  },
+  "files": [
+    "dist",
     "README.md",
     "LICENSE"
-  ],  "scripts": {
-    "test": "jest",
-    "build": "npm run build:cjs && npm run build:esm",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build:esm": "tsc -p tsconfig.esm.json",
-    "clean": "rimraf dist types"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsup --dts",
+    "clean": "shx rm -rf dist",
+    "prepublishOnly": "npm run build",
+    "test": "jest"
   },
-  "keywords": [],
-  "author": "",
-  "license": "MIT",
-  "type": "module",  "devDependencies": {
+  "type": "module",
+  "devDependencies": {
     "@j2blasco/ts-pipe": "^0.0.4",
     "@types/jest": "^29.5.14",
     "jest": "^29.7.0",
-    "rimraf": "^5.0.0",
-    "ts-jest": "^29.3.2"
-  },
-  "publishConfig": {
-    "access": "public"
+    "shx": "^0.4.0",
+    "ts-jest": "^29.3.2",
+    "tsup": "^8.5.0",
+    "typescript": "~5.7.2"
   }
 }

package/dist/cjs/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./result"), exports);
-__exportStar(require("./result-functions"), exports);

package/dist/cjs/result-functions.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.andThen = andThen;
-exports.andThenAsync = andThenAsync;
-function andThen(callback) {
-    return (result) => result.andThen(callback);
-}
-function andThenAsync(callback) {
-    return (result) => result.andThenAsync(callback);
-}

package/dist/cjs/result.js

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resultError = void 0;
-exports.unwrapSuccessResult = unwrapSuccessResult;
-exports.errorWithCode = errorWithCode;
-exports.errorUnkown = errorUnkown;
-exports.resultSuccessVoid = resultSuccessVoid;
-exports.resultSuccess = resultSuccess;
-exports.makeSafePromise = makeSafePromise;
-function unwrapSuccessResult(result) {
-    if (result instanceof ResultSuccessImp) {
-        return result['value'];
-    }
-    throw new Error('Unreachable code. Result is an error');
-}
-function errorWithCode(code, data) {
-    return {
-        code,
-        data,
-    };
-}
-function errorUnkown(message) {
-    return {
-        code: 'unknown',
-        data: { message },
-    };
-}
-function resultSuccessVoid() {
-    return new ResultSuccessImp(undefined);
-}
-function resultSuccess(value) {
-    return new ResultSuccessImp(value);
-}
-class resultError {
-    static unknown(message) {
-        return new ResultErrorImp(errorUnkown(message));
-    }
-    static withCode(code, data = {}) {
-        return new ResultErrorImp(errorWithCode(code, data));
-    }
-    static fromError(error) {
-        return new ResultErrorImp(error);
-    }
-}
-exports.resultError = resultError;
-class ResultSuccessImp {
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-    andThen(f) {
-        return f(this.value);
-    }
-    async andThenAsync(f) {
-        return await f(this.value);
-    }
-    catchError(_f) {
-        return this;
-    }
-    async catchErrorAsync(_f) {
-        return this;
-    }
-    unwrapOrThrow(_errorCallback) {
-        return this.value;
-    }
-}
-class ResultErrorImp {
-    error;
-    constructor(error) {
-        this.error = error;
-    }
-    andThen(_f) {
-        return this;
-    }
-    async andThenAsync(_f) {
-        return this;
-    }
-    catchError(f) {
-        return f(this.error);
-    }
-    async catchErrorAsync(f) {
-        return await f(this.error);
-    }
-    unwrapOrThrow(errorCallback) {
-        if (errorCallback !== undefined) {
-            errorCallback(this.error);
-        }
-        throw this.error;
-    }
-}
-function makeSafePromise(promise) {
-    return promise
-        .then((value) => resultSuccess(value))
-        .catch((error) => resultError.unknown(error.message));
-}

package/dist/cjs/utils/test/assert-type.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertType = assertType;
-exports.expectToCompile = expectToCompile;
-function assertType(_value) { }
-function expectToCompile() {
-    expect(true).toBe(true);
-}

package/dist/esm/index.js

@@ -1,2 +0,0 @@
-export * from './result';
-export * from './result-functions';

package/dist/esm/result-functions.js

@@ -1,6 +0,0 @@
-export function andThen(callback) {
-    return (result) => result.andThen(callback);
-}
-export function andThenAsync(callback) {
-    return (result) => result.andThenAsync(callback);
-}

package/dist/esm/result.js

@@ -1,85 +0,0 @@
-export function unwrapSuccessResult(result) {
-    if (result instanceof ResultSuccessImp) {
-        return result['value'];
-    }
-    throw new Error('Unreachable code. Result is an error');
-}
-export function errorWithCode(code, data) {
-    return {
-        code,
-        data,
-    };
-}
-export function errorUnkown(message) {
-    return {
-        code: 'unknown',
-        data: { message },
-    };
-}
-export function resultSuccessVoid() {
-    return new ResultSuccessImp(undefined);
-}
-export function resultSuccess(value) {
-    return new ResultSuccessImp(value);
-}
-export class resultError {
-    static unknown(message) {
-        return new ResultErrorImp(errorUnkown(message));
-    }
-    static withCode(code, data = {}) {
-        return new ResultErrorImp(errorWithCode(code, data));
-    }
-    static fromError(error) {
-        return new ResultErrorImp(error);
-    }
-}
-class ResultSuccessImp {
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-    andThen(f) {
-        return f(this.value);
-    }
-    async andThenAsync(f) {
-        return await f(this.value);
-    }
-    catchError(_f) {
-        return this;
-    }
-    async catchErrorAsync(_f) {
-        return this;
-    }
-    unwrapOrThrow(_errorCallback) {
-        return this.value;
-    }
-}
-class ResultErrorImp {
-    error;
-    constructor(error) {
-        this.error = error;
-    }
-    andThen(_f) {
-        return this;
-    }
-    async andThenAsync(_f) {
-        return this;
-    }
-    catchError(f) {
-        return f(this.error);
-    }
-    async catchErrorAsync(f) {
-        return await f(this.error);
-    }
-    unwrapOrThrow(errorCallback) {
-        if (errorCallback !== undefined) {
-            errorCallback(this.error);
-        }
-        throw this.error;
-    }
-}
-export function makeSafePromise(promise) {
-    return promise
-        .then((value) => resultSuccess(value))
-        .catch((error) => resultError.unknown(error.message));
-}

package/dist/esm/utils/test/assert-type.js

@@ -1,4 +0,0 @@
-export function assertType(_value) { }
-export function expectToCompile() {
-    expect(true).toBe(true);
-}

package/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from './result';
-export * from './result-functions';

package/types/result-functions.d.ts

@@ -1,3 +0,0 @@
-import { ErrorType, Result, SuccessType } from "./result";
-export declare function andThen<TSuccess, TError, TResult extends Result<any, any>>(callback: (value: TSuccess) => TResult): (result: Result<TSuccess, TError>) => Result<SuccessType<TResult>, TError | ErrorType<TResult>>;
-export declare function andThenAsync<TSuccess, TError, TResult extends Result<any, any>>(callback: (value: TSuccess) => Promise<TResult>): (result: Result<TSuccess, TError>) => Promise<Result<SuccessType<TResult>, TError | ErrorType<TResult>>>;

package/types/result.d.ts

@@ -1,34 +0,0 @@
-export interface Result<TSuccess1, TError1> {
-    andThen<TResult extends Result<any, any>>(f: (value: TSuccess1) => TResult): Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>;
-    andThenAsync<TResult extends Result<any, any>>(f: (value: TSuccess1) => Promise<TResult>): Promise<Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>>;
-    catchError<TResult extends Result<any, any>>(f: (error: TError1) => TResult): Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>;
-    catchErrorAsync<TResult extends Result<any, any>>(f: (error: TError1) => Promise<TResult>): Promise<Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>>;
-    unwrapOrThrow(errorCallback?: (e: TError1) => void): TSuccess1;
-}
-export declare function unwrapSuccessResult<T>(result: Result<T, never>): T;
-export type ErrorWithCode<TCode, TData = object> = {
-    code: TCode;
-    data: TData;
-};
-export declare function errorWithCode<TCode, TData>(code: TCode, data: TData): ErrorWithCode<TCode, TData>;
-export type ErrorUnknown = {
-    code: 'unknown';
-    data: {
-        message: string;
-    };
-};
-export declare function errorUnkown(message: string): ErrorUnknown;
-export type SuccessType<T> = T extends Result<infer S, any> ? S : never;
-export type ErrorType<T> = T extends Result<any, infer E> ? E : never;
-export type SuccessVoid = never;
-export declare function resultSuccessVoid(): Result<SuccessVoid, never>;
-export declare function resultSuccess<TSuccess1>(value: TSuccess1): Result<TSuccess1, never>;
-type EnforceLiteral<T> = string extends T ? never : T;
-export declare class resultError {
-    static unknown(message: string): Result<never, ErrorUnknown>;
-    static withCode<TCode, TData = object>(code: EnforceLiteral<TCode>, data?: TData): Result<never, ErrorWithCode<TCode, TData>>;
-    static fromError<TSuccess1, TError1 extends ErrorWithCode<any, object>>(error: TError1): Result<TSuccess1, TError1>;
-}
-export type UnwrapErrorFromResult<T> = T extends Result<any, infer U> ? U : never;
-export declare function makeSafePromise<T>(promise: Promise<T>): Promise<Result<T, ErrorUnknown>>;
-export {};

package/types/utils/test/assert-type.d.ts

@@ -1,2 +0,0 @@
-export declare function assertType<TActual, TExpected>(_value: TActual extends TExpected ? true : false): void;
-export declare function expectToCompile(): void;