@j2blasco/ts-result 0.1.6 → 0.1.8

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2025 [Your Name]
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+MIT License
+
+Copyright (c) 2025 [Your Name]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.

package/dist/index.cjs.map

@@ -1 +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    TError1 extends ErrorWithCode<any, object>,\r\n  >(error: TError1): Result<never, 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\r\nexport function catchError<TSuccess, TError, TResult extends Result<any, any>>(\r\n  callback: (error: TError) => TResult\r\n): (\r\n  result: Result<TSuccess, TError>\r\n) => Result<TSuccess | SuccessType<TResult>, ErrorType<TResult>> {\r\n  return (result) => result.catchError(callback);\r\n}\r\n\r\nexport function catchErrorAsync<\r\n  TSuccess,\r\n  TError,\r\n  TResult extends Result<any, any>\r\n>(\r\n  callback: (error: TError) => Promise<TResult>\r\n): (\r\n  result: Result<TSuccess, TError>\r\n) => Promise<Result<TSuccess | SuccessType<TResult>, ErrorType<TResult>>> {\r\n  return (result) => result.catchErrorAsync(callback);\r\n}\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;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,UAEZ,OAAwC;AACxC,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;;;AC3JO,SAAS,QACd,UAG6D;AAC7D,SAAO,CAAC,WAAW,OAAO,QAAQ,QAAQ;AAC5C;AAEO,SAAS,aAKd,UAGsE;AACtE,SAAO,CAAC,WAAW,OAAO,aAAa,QAAQ;AACjD;AAEO,SAAS,WACd,UAG+D;AAC/D,SAAO,CAAC,WAAW,OAAO,WAAW,QAAQ;AAC/C;AAEO,SAAS,gBAKd,UAGwE;AACxE,SAAO,CAAC,WAAW,OAAO,gBAAgB,QAAQ;AACpD;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/result.ts","../src/result-functions.ts"],"sourcesContent":["export * from './result';\nexport * from './result-functions';","export interface Result<TSuccess1, TError1> {\n  andThen<TResult extends Result<any, any>>(\n    f: (value: TSuccess1) => TResult,\n  ): Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>;\n  andThenAsync<TResult extends Result<any, any>>(\n    f: (value: TSuccess1) => Promise<TResult>,\n  ): Promise<Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>>;\n  catchError<TResult extends Result<any, any>>(\n    f: (error: TError1) => TResult,\n  ): Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>;\n  catchErrorAsync<TResult extends Result<any, any>>(\n    f: (error: TError1) => Promise<TResult>,\n  ): Promise<Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>>;\n  unwrapOrThrow(errorCallback?: (e: TError1) => void): TSuccess1;\n}\n\nexport function unwrapSuccessResult<T>(result: Result<T, never>): T {\n  if (result instanceof ResultSuccessImp) {\n    return result['value'];\n  }\n  throw new Error('Unreachable code. Result is an error');\n}\n\nexport type ErrorWithCode<TCode, TData = object> = { code: TCode; data: TData };\nexport function errorWithCode<TCode, TData>(\n  code: TCode,\n  data: TData,\n): ErrorWithCode<TCode, TData> {\n  return {\n    code,\n    data,\n  };\n}\n\nexport type ErrorUnknown = {\n  code: 'unknown';\n  data: { message: string };\n};\nexport function errorUnkown(message: string): ErrorUnknown {\n  return {\n    code: 'unknown',\n    data: { message },\n  };\n}\n\nexport type SuccessType<T> = T extends Result<infer S, any> ? S : never;\nexport type ErrorType<T> = T extends Result<any, infer E> ? E : never;\n\nexport type SuccessVoid = never;\n\nexport function resultSuccessVoid(): Result<SuccessVoid, never> {\n  return new ResultSuccessImp<SuccessVoid>(undefined as never);\n}\n\nexport function resultSuccess<TSuccess1>(\n  value: TSuccess1,\n): Result<TSuccess1, never> {\n  return new ResultSuccessImp<TSuccess1>(value);\n}\n\ntype EnforceLiteral<T> = string extends T ? never : T;\n\nexport class resultError {\n  public static unknown(message: string): Result<never, ErrorUnknown> {\n    return new ResultErrorImp<ErrorUnknown>(errorUnkown(message));\n  }\n  public static withCode<TCode, TData = object>(\n    code: EnforceLiteral<TCode>,\n    data: TData = {} as TData,\n  ): Result<never, ErrorWithCode<TCode, TData>> {\n    return new ResultErrorImp<ErrorWithCode<TCode, TData>>(\n      errorWithCode(code, data),\n    );\n  }\n  public static fromError<\n    TError1 extends ErrorWithCode<any, object>,\n  >(error: TError1): Result<never, TError1> {\n    return new ResultErrorImp<TError1>(error);\n  }\n}\n\nclass ResultSuccessImp<TSuccess1> implements Result<TSuccess1, never> {\n  constructor(private value: TSuccess1) {}\n\n  public andThen<TSuccess2, TError2>(\n    f: (value: TSuccess1) => Result<TSuccess2, TError2>,\n  ): Result<TSuccess2, TError2> {\n    return f(this.value);\n  }\n\n  public async andThenAsync<TSuccess2, TError2>(\n    f: (value: TSuccess1) => Promise<Result<TSuccess2, TError2>>,\n  ): Promise<Result<TSuccess2, TError2>> {\n    return await f(this.value);\n  }\n\n  public catchError<TSuccess2, TError2>(\n    _f: (error: never) => Result<TSuccess2, TError2>,\n  ): Result<TSuccess1 | TSuccess2, TError2> {\n    return this;\n  }\n\n  public async catchErrorAsync<TSuccess2, TError2>(\n    _f: (error: never) => Promise<Result<TSuccess2, TError2>>,\n  ): Promise<Result<TSuccess1 | TSuccess2, TError2>> {\n    return this;\n  }\n\n  public unwrapOrThrow(_errorCallback?: (e: never) => void): TSuccess1 {\n    return this.value;\n  }\n}\n\nclass ResultErrorImp<TError1> implements Result<never, TError1> {\n  constructor(private error: TError1) {}\n\n  public andThen<TSuccess2, TError2>(\n    _f: (value: never) => Result<TSuccess2, TError2>,\n  ): Result<TSuccess2, TError1 | TError2> {\n    return this;\n  }\n\n  public async andThenAsync<TSuccess2, TError2>(\n    _f: (value: never) => Promise<Result<TSuccess2, TError2>>,\n  ): Promise<Result<TSuccess2, TError1 | TError2>> {\n    return this;\n  }\n\n  public catchError<TSuccess2, TError2>(\n    f: (error: TError1) => Result<TSuccess2, TError2>,\n  ): Result<TSuccess2, TError2> {\n    return f(this.error);\n  }\n\n  public async catchErrorAsync<TSuccess2, TError2>(\n    f: (error: TError1) => Promise<Result<TSuccess2, TError2>>,\n  ): Promise<Result<TSuccess2, TError2>> {\n    return await f(this.error);\n  }\n\n  public unwrapOrThrow(errorCallback?: (e: TError1) => void): never {\n    if (errorCallback !== undefined) {\n      errorCallback(this.error);\n    }\n    throw this.error;\n  }\n}\n\nexport type UnwrapErrorFromResult<T> =\n  T extends Result<any, infer U> ? U : never;\n\nexport function makeSafePromise<T>(\n  promise: Promise<T>,\n): Promise<Result<T, ErrorUnknown>> {\n  return promise\n    .then((value) => resultSuccess(value))\n    .catch((error) => resultError.unknown(error.message));\n}","import { ErrorType, Result, SuccessType } from \"./result\";\n\nexport function andThen<TSuccess, TError, TResult extends Result<any, any>>(\n  callback: (value: TSuccess) => TResult\n): (\n  result: Result<TSuccess, TError>\n) => Result<SuccessType<TResult>, TError | ErrorType<TResult>> {\n  return (result) => result.andThen(callback);\n}\n\nexport function andThenAsync<\n  TSuccess,\n  TError,\n  TResult extends Result<any, any>\n>(\n  callback: (value: TSuccess) => Promise<TResult>\n): (\n  result: Result<TSuccess, TError>\n) => Promise<Result<SuccessType<TResult>, TError | ErrorType<TResult>>> {\n  return (result) => result.andThenAsync(callback);\n}\n\nexport function catchError<TSuccess, TError, TResult extends Result<any, any>>(\n  callback: (error: TError) => TResult\n): (\n  result: Result<TSuccess, TError>\n) => Result<TSuccess | SuccessType<TResult>, ErrorType<TResult>> {\n  return (result) => result.catchError(callback);\n}\n\nexport function catchErrorAsync<\n  TSuccess,\n  TError,\n  TResult extends Result<any, any>\n>(\n  callback: (error: TError) => Promise<TResult>\n): (\n  result: Result<TSuccess, TError>\n) => Promise<Result<TSuccess | SuccessType<TResult>, ErrorType<TResult>>> {\n  return (result) => result.catchErrorAsync(callback);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;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,UAEZ,OAAwC;AACxC,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;;;AC3JO,SAAS,QACd,UAG6D;AAC7D,SAAO,CAAC,WAAW,OAAO,QAAQ,QAAQ;AAC5C;AAEO,SAAS,aAKd,UAGsE;AACtE,SAAO,CAAC,WAAW,OAAO,aAAa,QAAQ;AACjD;AAEO,SAAS,WACd,UAG+D;AAC/D,SAAO,CAAC,WAAW,OAAO,WAAW,QAAQ;AAC/C;AAEO,SAAS,gBAKd,UAGwE;AACxE,SAAO,CAAC,WAAW,OAAO,gBAAgB,QAAQ;AACpD;","names":[]}

package/dist/index.js.map

@@ -1 +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    TError1 extends ErrorWithCode<any, object>,\r\n  >(error: TError1): Result<never, 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\r\nexport function catchError<TSuccess, TError, TResult extends Result<any, any>>(\r\n  callback: (error: TError) => TResult\r\n): (\r\n  result: Result<TSuccess, TError>\r\n) => Result<TSuccess | SuccessType<TResult>, ErrorType<TResult>> {\r\n  return (result) => result.catchError(callback);\r\n}\r\n\r\nexport function catchErrorAsync<\r\n  TSuccess,\r\n  TError,\r\n  TResult extends Result<any, any>\r\n>(\r\n  callback: (error: TError) => Promise<TResult>\r\n): (\r\n  result: Result<TSuccess, TError>\r\n) => Promise<Result<TSuccess | SuccessType<TResult>, ErrorType<TResult>>> {\r\n  return (result) => result.catchErrorAsync(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,UAEZ,OAAwC;AACxC,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;;;AC3JO,SAAS,QACd,UAG6D;AAC7D,SAAO,CAAC,WAAW,OAAO,QAAQ,QAAQ;AAC5C;AAEO,SAAS,aAKd,UAGsE;AACtE,SAAO,CAAC,WAAW,OAAO,aAAa,QAAQ;AACjD;AAEO,SAAS,WACd,UAG+D;AAC/D,SAAO,CAAC,WAAW,OAAO,WAAW,QAAQ;AAC/C;AAEO,SAAS,gBAKd,UAGwE;AACxE,SAAO,CAAC,WAAW,OAAO,gBAAgB,QAAQ;AACpD;","names":[]}
+{"version":3,"sources":["../src/result.ts","../src/result-functions.ts"],"sourcesContent":["export interface Result<TSuccess1, TError1> {\n  andThen<TResult extends Result<any, any>>(\n    f: (value: TSuccess1) => TResult,\n  ): Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>;\n  andThenAsync<TResult extends Result<any, any>>(\n    f: (value: TSuccess1) => Promise<TResult>,\n  ): Promise<Result<SuccessType<TResult>, TError1 | ErrorType<TResult>>>;\n  catchError<TResult extends Result<any, any>>(\n    f: (error: TError1) => TResult,\n  ): Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>;\n  catchErrorAsync<TResult extends Result<any, any>>(\n    f: (error: TError1) => Promise<TResult>,\n  ): Promise<Result<TSuccess1 | SuccessType<TResult>, ErrorType<TResult>>>;\n  unwrapOrThrow(errorCallback?: (e: TError1) => void): TSuccess1;\n}\n\nexport function unwrapSuccessResult<T>(result: Result<T, never>): T {\n  if (result instanceof ResultSuccessImp) {\n    return result['value'];\n  }\n  throw new Error('Unreachable code. Result is an error');\n}\n\nexport type ErrorWithCode<TCode, TData = object> = { code: TCode; data: TData };\nexport function errorWithCode<TCode, TData>(\n  code: TCode,\n  data: TData,\n): ErrorWithCode<TCode, TData> {\n  return {\n    code,\n    data,\n  };\n}\n\nexport type ErrorUnknown = {\n  code: 'unknown';\n  data: { message: string };\n};\nexport function errorUnkown(message: string): ErrorUnknown {\n  return {\n    code: 'unknown',\n    data: { message },\n  };\n}\n\nexport type SuccessType<T> = T extends Result<infer S, any> ? S : never;\nexport type ErrorType<T> = T extends Result<any, infer E> ? E : never;\n\nexport type SuccessVoid = never;\n\nexport function resultSuccessVoid(): Result<SuccessVoid, never> {\n  return new ResultSuccessImp<SuccessVoid>(undefined as never);\n}\n\nexport function resultSuccess<TSuccess1>(\n  value: TSuccess1,\n): Result<TSuccess1, never> {\n  return new ResultSuccessImp<TSuccess1>(value);\n}\n\ntype EnforceLiteral<T> = string extends T ? never : T;\n\nexport class resultError {\n  public static unknown(message: string): Result<never, ErrorUnknown> {\n    return new ResultErrorImp<ErrorUnknown>(errorUnkown(message));\n  }\n  public static withCode<TCode, TData = object>(\n    code: EnforceLiteral<TCode>,\n    data: TData = {} as TData,\n  ): Result<never, ErrorWithCode<TCode, TData>> {\n    return new ResultErrorImp<ErrorWithCode<TCode, TData>>(\n      errorWithCode(code, data),\n    );\n  }\n  public static fromError<\n    TError1 extends ErrorWithCode<any, object>,\n  >(error: TError1): Result<never, TError1> {\n    return new ResultErrorImp<TError1>(error);\n  }\n}\n\nclass ResultSuccessImp<TSuccess1> implements Result<TSuccess1, never> {\n  constructor(private value: TSuccess1) {}\n\n  public andThen<TSuccess2, TError2>(\n    f: (value: TSuccess1) => Result<TSuccess2, TError2>,\n  ): Result<TSuccess2, TError2> {\n    return f(this.value);\n  }\n\n  public async andThenAsync<TSuccess2, TError2>(\n    f: (value: TSuccess1) => Promise<Result<TSuccess2, TError2>>,\n  ): Promise<Result<TSuccess2, TError2>> {\n    return await f(this.value);\n  }\n\n  public catchError<TSuccess2, TError2>(\n    _f: (error: never) => Result<TSuccess2, TError2>,\n  ): Result<TSuccess1 | TSuccess2, TError2> {\n    return this;\n  }\n\n  public async catchErrorAsync<TSuccess2, TError2>(\n    _f: (error: never) => Promise<Result<TSuccess2, TError2>>,\n  ): Promise<Result<TSuccess1 | TSuccess2, TError2>> {\n    return this;\n  }\n\n  public unwrapOrThrow(_errorCallback?: (e: never) => void): TSuccess1 {\n    return this.value;\n  }\n}\n\nclass ResultErrorImp<TError1> implements Result<never, TError1> {\n  constructor(private error: TError1) {}\n\n  public andThen<TSuccess2, TError2>(\n    _f: (value: never) => Result<TSuccess2, TError2>,\n  ): Result<TSuccess2, TError1 | TError2> {\n    return this;\n  }\n\n  public async andThenAsync<TSuccess2, TError2>(\n    _f: (value: never) => Promise<Result<TSuccess2, TError2>>,\n  ): Promise<Result<TSuccess2, TError1 | TError2>> {\n    return this;\n  }\n\n  public catchError<TSuccess2, TError2>(\n    f: (error: TError1) => Result<TSuccess2, TError2>,\n  ): Result<TSuccess2, TError2> {\n    return f(this.error);\n  }\n\n  public async catchErrorAsync<TSuccess2, TError2>(\n    f: (error: TError1) => Promise<Result<TSuccess2, TError2>>,\n  ): Promise<Result<TSuccess2, TError2>> {\n    return await f(this.error);\n  }\n\n  public unwrapOrThrow(errorCallback?: (e: TError1) => void): never {\n    if (errorCallback !== undefined) {\n      errorCallback(this.error);\n    }\n    throw this.error;\n  }\n}\n\nexport type UnwrapErrorFromResult<T> =\n  T extends Result<any, infer U> ? U : never;\n\nexport function makeSafePromise<T>(\n  promise: Promise<T>,\n): Promise<Result<T, ErrorUnknown>> {\n  return promise\n    .then((value) => resultSuccess(value))\n    .catch((error) => resultError.unknown(error.message));\n}","import { ErrorType, Result, SuccessType } from \"./result\";\n\nexport function andThen<TSuccess, TError, TResult extends Result<any, any>>(\n  callback: (value: TSuccess) => TResult\n): (\n  result: Result<TSuccess, TError>\n) => Result<SuccessType<TResult>, TError | ErrorType<TResult>> {\n  return (result) => result.andThen(callback);\n}\n\nexport function andThenAsync<\n  TSuccess,\n  TError,\n  TResult extends Result<any, any>\n>(\n  callback: (value: TSuccess) => Promise<TResult>\n): (\n  result: Result<TSuccess, TError>\n) => Promise<Result<SuccessType<TResult>, TError | ErrorType<TResult>>> {\n  return (result) => result.andThenAsync(callback);\n}\n\nexport function catchError<TSuccess, TError, TResult extends Result<any, any>>(\n  callback: (error: TError) => TResult\n): (\n  result: Result<TSuccess, TError>\n) => Result<TSuccess | SuccessType<TResult>, ErrorType<TResult>> {\n  return (result) => result.catchError(callback);\n}\n\nexport function catchErrorAsync<\n  TSuccess,\n  TError,\n  TResult extends Result<any, any>\n>(\n  callback: (error: TError) => Promise<TResult>\n): (\n  result: Result<TSuccess, TError>\n) => Promise<Result<TSuccess | SuccessType<TResult>, ErrorType<TResult>>> {\n  return (result) => result.catchErrorAsync(callback);\n}\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,UAEZ,OAAwC;AACxC,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;;;AC3JO,SAAS,QACd,UAG6D;AAC7D,SAAO,CAAC,WAAW,OAAO,QAAQ,QAAQ;AAC5C;AAEO,SAAS,aAKd,UAGsE;AACtE,SAAO,CAAC,WAAW,OAAO,aAAa,QAAQ;AACjD;AAEO,SAAS,WACd,UAG+D;AAC/D,SAAO,CAAC,WAAW,OAAO,WAAW,QAAQ;AAC/C;AAEO,SAAS,gBAKd,UAGwE;AACxE,SAAO,CAAC,WAAW,OAAO,gBAAgB,QAAQ;AACpD;","names":[]}

package/package.json

@@ -1,48 +1,49 @@
-{
-  "name": "@j2blasco/ts-result",
-  "version": "0.1.6",
-  "description": "Result Monad for TypeScript",
-  "author": "j2blasco",
-  "license": "MIT",
-  "keywords": [
-    "typescript",
-    "result",
-    "monad",
-    "error-handling"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/j2blasco/ts-result.git"
-  },
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "npm run clean && tsup",
-    "clean": "shx rm -rf dist",
-    "prepublishOnly": "npm run build",
-    "test": "jest"
-  },
-  "type": "module",
-  "devDependencies": {
-    "@j2blasco/ts-pipe": "^0.0.8",
-    "@types/jest": "^29.5.14",
-    "jest": "^29.7.0",
-    "shx": "^0.4.0",
-    "ts-jest": "^29.3.2",
-    "tsup": "^8.5.0",
-    "typescript": "~5.7.2"
-  }
-}
+{
+  "name": "@j2blasco/ts-result",
+  "version": "0.1.8",
+  "description": "Result Monad for TypeScript",
+  "author": "j2blasco",
+  "license": "MIT",
+  "keywords": [
+    "typescript",
+    "result",
+    "monad",
+    "error-handling"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/j2blasco/ts-result.git"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsup",
+    "clean": "shx rm -rf dist",
+    "prepublishOnly": "npm run build",
+    "test": "jest"
+  },
+  "type": "module",
+  "devDependencies": {
+    "@j2blasco/ts-pipe": "^0.0.8",
+    "@types/jest": "^29.5.14",
+    "jest": "^29.7.0",
+    "shx": "^0.4.0",
+    "ts-jest": "^29.3.2",
+    "tsup": "^8.5.0",
+    "typescript": "~5.7.2"
+  }
+}

package/src/index.ts

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

package/src/result-functions.test.ts

@@ -0,0 +1,113 @@
+// import { asyncPipe, pipe } from "@j2blasco/ts-pipe";
+import { andThen, andThenAsync, catchError, catchErrorAsync } from "./result-functions";
+import { resultSuccess, resultError, ErrorUnknown, Result } from "./result";
+import { assertType } from "./utils/test/assert-type";
+import { asyncPipe, pipe } from "@j2blasco/ts-pipe";
+
+function doSomething(): Result<string, ErrorUnknown> {
+  return resultSuccess("5");
+}
+
+describe("Result functions", () => {
+  test("andThen transforms success values", () => {
+    const result = resultSuccess(5);
+    const transformed = andThen((x: number) => resultSuccess(x * 2))(result);
+    expect(transformed.unwrapOrThrow()).toBe(10);
+  });
+
+  test("andThen preserves failures", () => {
+    const result = resultError.unknown("error message");
+    const transformed = andThen((x: any) => resultSuccess(x * 2))(result);
+
+    // Check if the transformation preserves the error by trying to unwrap
+    expect(() => transformed.unwrapOrThrow()).toThrow();
+  });
+
+  test("andThenAsync transforms success values", async () => {
+    const result = resultSuccess(5);
+    const transformed = await andThenAsync(async (x: number) =>
+      resultSuccess(x * 2)
+    )(result);
+    expect(transformed.unwrapOrThrow()).toBe(10);
+  });
+
+  test("andThenAsync preserves failures", async () => {
+    const result = resultError.unknown("error message");
+    const transformed = await andThenAsync(async (x: any) =>
+      resultSuccess(x * 2)
+    )(result);
+
+    // Check if the transformation preserves the error by trying to unwrap
+    expect(() => transformed.unwrapOrThrow()).toThrow();
+  });
+
+  test("catchError handles errors", () => {
+    const result = resultError.unknown("error message");
+    const recovered = catchError((error: ErrorUnknown) => 
+      resultSuccess("recovered")
+    )(result);
+    expect(recovered.unwrapOrThrow()).toBe("recovered");
+  });
+
+  test("catchError preserves success values", () => {
+    const result = resultSuccess(42);
+    const recovered = catchError((error: any) => 
+      resultSuccess("should not be called")
+    )(result);
+    expect(recovered.unwrapOrThrow()).toBe(42);
+  });
+
+  test("catchErrorAsync handles errors", async () => {
+    const result = resultError.unknown("error message");
+    const recovered = await catchErrorAsync(async (error: ErrorUnknown) => 
+      resultSuccess("recovered async")
+    )(result);
+    expect(recovered.unwrapOrThrow()).toBe("recovered async");
+  });
+
+  test("catchErrorAsync preserves success values", async () => {
+    const result = resultSuccess(42);
+    const recovered = await catchErrorAsync(async (error: any) => 
+      resultSuccess("should not be called")
+    )(result);
+    expect(recovered.unwrapOrThrow()).toBe(42);
+  });
+});
+
+describe("Result integration with ts-pipe", () => {
+  test("asyncPipe", async () => {
+    var result = await asyncPipe(
+      doSomething(),
+      andThenAsync(async (_e) => resultSuccess(new Date())),
+      andThen((r) => {
+        assertType<typeof r, Date>(true);
+        return resultSuccess("test");
+      })
+    );
+    expect(result.unwrapOrThrow()).toBe("test");
+  });
+
+  test("pipe", async () => {
+    var result = pipe(
+      doSomething(),
+      andThen((_e) => resultSuccess(new Date())),
+      andThen((r) => {
+        assertType<typeof r, Date>(true);
+        return resultSuccess("test");
+      })
+    );
+    expect(result.unwrapOrThrow()).toBe("test");
+  });
+
+  test("pipe", async () => {
+    var result = pipe(
+      doSomething(),
+      andThen((_e) => resultSuccess(new Date())),
+      andThen((r) => {
+        assertType<typeof r, Date>(true);
+        return resultSuccess("test");
+      })
+    );
+    expect(result.unwrapOrThrow()).toBe("test");
+  });
+});

package/src/result-functions.ts

@@ -0,0 +1,41 @@
+import { ErrorType, Result, SuccessType } from "./result";
+
+export function andThen<TSuccess, TError, TResult extends Result<any, any>>(
+  callback: (value: TSuccess) => TResult
+): (
+  result: Result<TSuccess, TError>
+) => Result<SuccessType<TResult>, TError | ErrorType<TResult>> {
+  return (result) => result.andThen(callback);
+}
+
+export 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>>> {
+  return (result) => result.andThenAsync(callback);
+}
+
+export function catchError<TSuccess, TError, TResult extends Result<any, any>>(
+  callback: (error: TError) => TResult
+): (
+  result: Result<TSuccess, TError>
+) => Result<TSuccess | SuccessType<TResult>, ErrorType<TResult>> {
+  return (result) => result.catchError(callback);
+}
+
+export function catchErrorAsync<
+  TSuccess,
+  TError,
+  TResult extends Result<any, any>
+>(
+  callback: (error: TError) => Promise<TResult>
+): (
+  result: Result<TSuccess, TError>
+) => Promise<Result<TSuccess | SuccessType<TResult>, ErrorType<TResult>>> {
+  return (result) => result.catchErrorAsync(callback);
+}

package/src/result.test.ts

@@ -0,0 +1,113 @@
+import {
+  resultSuccess,
+  resultError,
+  unwrapSuccessResult,
+  Result,
+  ErrorWithCode,
+  resultSuccessVoid,
+  SuccessVoid,
+  ErrorUnknown,
+} from "./result";
+import { assertType, expectToCompile } from "./utils/test/assert-type";
+
+function createResult<TSuccess, TError>(): Result<TSuccess, TError> {
+  return resultSuccessVoid() as object as Result<TSuccess, TError>;
+}
+
+describe("Result Monad", () => {
+  test("resultSuccess should create a success result", () => {
+    const success = resultSuccess("test");
+    expect(unwrapSuccessResult(success)).toBe("test");
+  });
+
+  test("resultError.unknown should create an unknown error result", () => {
+    const error = resultError.unknown("An error occurred");
+    try {
+      error.unwrapOrThrow();
+    } catch (e) {
+      expect(e).toMatchObject({
+        code: "unknown",
+        data: { message: "An error occurred" },
+      });
+    }
+  });
+
+  test("resultError.withCode should create a coded error result", () => {
+    const error = resultError.withCode("test-code" as const, {
+      detail: "Some details",
+    });
+    try {
+      error.unwrapOrThrow();
+    } catch (e) {
+      expect(e).toMatchObject({
+        code: "test-code" as const,
+        data: { detail: "Some details" },
+      });
+    }
+  });
+
+  test("Result Monad success should be chainable with inferred types - string -> int", () => {
+    const resultString = createResult<string, ErrorWithCode<"test">>();
+
+    const resultInt = resultString.andThen((value) => {
+      type Expected = string;
+      assertType<typeof value, Expected>(true);
+      return resultSuccess(42);
+    });
+
+    type Expected = Result<number, ErrorWithCode<"test">>;
+    assertType<typeof resultInt, Expected>(true);
+
+    expectToCompile();
+  });
+
+  test("Result Monad success should be chainable with inferred types - obj -> obj", () => {
+    const resultString = createResult<
+      { test: string },
+      ErrorWithCode<"test">
+    >();
+
+    const resultInt = resultString.andThen((value) => {
+      type Expected = { test: string };
+      assertType<typeof value, Expected>(true);
+      return resultSuccess({ test2: "test" });
+    });
+
+    type Expected = Result<{ test2: string }, ErrorWithCode<"test">>;
+    assertType<typeof resultInt, Expected>(true);
+
+    expectToCompile();
+  });
+
+  test("Type is properly infered in resultError.fromError (simple case)", () => {
+    const result = createResult<
+      SuccessVoid,
+      ErrorWithCode<"error-code"> | ErrorUnknown
+    >();
+    const catchedResult = result.catchError((e) => {
+      if (e.code === "error-code") {
+        return resultSuccessVoid();
+      }
+      return resultError.fromError(e);
+    });
+    type Expected = Result<never, ErrorUnknown>;
+    assertType<typeof catchedResult, Expected>(true);
+  });
+
+  test("Type is properly infered in resultError.fromError (complex case)", () => {
+    const result = createResult<
+      SuccessVoid,
+      | ErrorWithCode<"error-code-1">
+      | ErrorWithCode<"error-code-2">
+      | ErrorUnknown
+    >();
+    const catchedResult = result.catchError((e) => {
+      if (e.code === "error-code-1") {
+        return resultSuccess(5);
+      }
+      return resultError.fromError(e);
+    });
+    type Expected = Result<number, ErrorUnknown | ErrorWithCode<'error-code-2'>>;
+    assertType<typeof catchedResult, Expected>(true);
+  });
+});

package/src/result.ts

@@ -0,0 +1,158 @@
+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 function unwrapSuccessResult<T>(result: Result<T, never>): T {
+  if (result instanceof ResultSuccessImp) {
+    return result['value'];
+  }
+  throw new Error('Unreachable code. Result is an error');
+}
+
+export type ErrorWithCode<TCode, TData = object> = { code: TCode; data: TData };
+export function errorWithCode<TCode, TData>(
+  code: TCode,
+  data: TData,
+): ErrorWithCode<TCode, TData> {
+  return {
+    code,
+    data,
+  };
+}
+
+export type ErrorUnknown = {
+  code: 'unknown';
+  data: { message: string };
+};
+export function errorUnkown(message: string): ErrorUnknown {
+  return {
+    code: 'unknown',
+    data: { message },
+  };
+}
+
+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 function resultSuccessVoid(): Result<SuccessVoid, never> {
+  return new ResultSuccessImp<SuccessVoid>(undefined as never);
+}
+
+export function resultSuccess<TSuccess1>(
+  value: TSuccess1,
+): Result<TSuccess1, never> {
+  return new ResultSuccessImp<TSuccess1>(value);
+}
+
+type EnforceLiteral<T> = string extends T ? never : T;
+
+export class resultError {
+  public static unknown(message: string): Result<never, ErrorUnknown> {
+    return new ResultErrorImp<ErrorUnknown>(errorUnkown(message));
+  }
+  public static withCode<TCode, TData = object>(
+    code: EnforceLiteral<TCode>,
+    data: TData = {} as TData,
+  ): Result<never, ErrorWithCode<TCode, TData>> {
+    return new ResultErrorImp<ErrorWithCode<TCode, TData>>(
+      errorWithCode(code, data),
+    );
+  }
+  public static fromError<
+    TError1 extends ErrorWithCode<any, object>,
+  >(error: TError1): Result<never, TError1> {
+    return new ResultErrorImp<TError1>(error);
+  }
+}
+
+class ResultSuccessImp<TSuccess1> implements Result<TSuccess1, never> {
+  constructor(private value: TSuccess1) {}
+
+  public andThen<TSuccess2, TError2>(
+    f: (value: TSuccess1) => Result<TSuccess2, TError2>,
+  ): Result<TSuccess2, TError2> {
+    return f(this.value);
+  }
+
+  public async andThenAsync<TSuccess2, TError2>(
+    f: (value: TSuccess1) => Promise<Result<TSuccess2, TError2>>,
+  ): Promise<Result<TSuccess2, TError2>> {
+    return await f(this.value);
+  }
+
+  public catchError<TSuccess2, TError2>(
+    _f: (error: never) => Result<TSuccess2, TError2>,
+  ): Result<TSuccess1 | TSuccess2, TError2> {
+    return this;
+  }
+
+  public async catchErrorAsync<TSuccess2, TError2>(
+    _f: (error: never) => Promise<Result<TSuccess2, TError2>>,
+  ): Promise<Result<TSuccess1 | TSuccess2, TError2>> {
+    return this;
+  }
+
+  public unwrapOrThrow(_errorCallback?: (e: never) => void): TSuccess1 {
+    return this.value;
+  }
+}
+
+class ResultErrorImp<TError1> implements Result<never, TError1> {
+  constructor(private error: TError1) {}
+
+  public andThen<TSuccess2, TError2>(
+    _f: (value: never) => Result<TSuccess2, TError2>,
+  ): Result<TSuccess2, TError1 | TError2> {
+    return this;
+  }
+
+  public async andThenAsync<TSuccess2, TError2>(
+    _f: (value: never) => Promise<Result<TSuccess2, TError2>>,
+  ): Promise<Result<TSuccess2, TError1 | TError2>> {
+    return this;
+  }
+
+  public catchError<TSuccess2, TError2>(
+    f: (error: TError1) => Result<TSuccess2, TError2>,
+  ): Result<TSuccess2, TError2> {
+    return f(this.error);
+  }
+
+  public async catchErrorAsync<TSuccess2, TError2>(
+    f: (error: TError1) => Promise<Result<TSuccess2, TError2>>,
+  ): Promise<Result<TSuccess2, TError2>> {
+    return await f(this.error);
+  }
+
+  public unwrapOrThrow(errorCallback?: (e: TError1) => void): never {
+    if (errorCallback !== undefined) {
+      errorCallback(this.error);
+    }
+    throw this.error;
+  }
+}
+
+export type UnwrapErrorFromResult<T> =
+  T extends Result<any, infer U> ? U : never;
+
+export function makeSafePromise<T>(
+  promise: Promise<T>,
+): Promise<Result<T, ErrorUnknown>> {
+  return promise
+    .then((value) => resultSuccess(value))
+    .catch((error) => resultError.unknown(error.message));
+}

package/src/utils/test/assert-type.ts

@@ -0,0 +1,7 @@
+export function assertType<TActual, TExpected>(
+  _value: TActual extends TExpected ? true : false
+): void {}
+
+export function expectToCompile() {
+  expect(true).toBe(true);
+}