@onrails/result 0.4.2 → 0.5.0

package/dist/index.js

@@ -1,12 +1,86 @@
-// src/internal/ctor.ts
-var mkOk = (value) => ({
-  _tag: "Ok",
-  value
-});
-var mkErr = (error) => ({
-  _tag: "Err",
-  error
-});
+// src/internal/proto.ts
+var INSPECT = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+var OkImpl = class _OkImpl {
+  _tag;
+  value;
+  // explicit assignment order keeps `_tag` first, so JSON key order matches the plain-data shape
+  constructor(value) {
+    this._tag = "Ok";
+    this.value = value;
+  }
+  [INSPECT](_depth, options, inspect) {
+    return `Ok(${inspect(this.value, options)})`;
+  }
+  map(fn) {
+    return new _OkImpl(fn(this.value));
+  }
+  mapErr(_fn) {
+    return new _OkImpl(this.value);
+  }
+  flatMap(fn) {
+    return fn(this.value);
+  }
+  andThen(fn) {
+    return fn(this.value);
+  }
+  recover(_fn) {
+    return new _OkImpl(this.value);
+  }
+  tap(fn) {
+    fn(this.value);
+    return this;
+  }
+  tapErr(_fn) {
+    return this;
+  }
+  match(onOk, _onErr) {
+    return onOk(this.value);
+  }
+  unwrapOr(_defaultValue) {
+    return this.value;
+  }
+};
+var ErrImpl = class _ErrImpl {
+  _tag;
+  error;
+  constructor(error) {
+    this._tag = "Err";
+    this.error = error;
+  }
+  [INSPECT](_depth, options, inspect) {
+    return `Err(${inspect(this.error, options)})`;
+  }
+  map(_fn) {
+    return new _ErrImpl(this.error);
+  }
+  mapErr(fn) {
+    return new _ErrImpl(fn(this.error));
+  }
+  flatMap(_fn) {
+    return new _ErrImpl(this.error);
+  }
+  andThen(_fn) {
+    return new _ErrImpl(this.error);
+  }
+  recover(fn) {
+    return fn(this.error);
+  }
+  tap(_fn) {
+    return this;
+  }
+  tapErr(fn) {
+    fn(this.error);
+    return this;
+  }
+  match(_onOk, onErr) {
+    return onErr(this.error);
+  }
+  unwrapOr(defaultValue) {
+    return defaultValue;
+  }
+};
+var newOk = (value) => new OkImpl(value);
+var newErr = (error) => new ErrImpl(error);
 
 // src/internal/dual.ts
 var dual = (arity, body) => {
@@ -20,33 +94,33 @@ var toError = (error) => error instanceof Error ? error : new Error(String(error
 
 // src/result.ts
 function ok(value) {
-  return mkOk(value);
+  return newOk(value);
 }
 var of = ok;
 function err(error) {
-  return mkErr(error);
+  return newErr(error);
 }
 var isOk = (result) => result._tag === "Ok";
 var isErr = (result) => result._tag === "Err";
 var map = dual(
   2,
-  (result, fn) => isOk(result) ? mkOk(fn(result.value)) : mkErr(result.error)
+  (result, fn) => isOk(result) ? newOk(fn(result.value)) : newErr(result.error)
 );
 var mapErr = dual(
   2,
-  (result, fn) => isErr(result) ? mkErr(fn(result.error)) : mkOk(result.value)
+  (result, fn) => isErr(result) ? newErr(fn(result.error)) : newOk(result.value)
 );
 var bimap = dual(
   3,
-  (result, onOk, onErr) => isOk(result) ? mkOk(onOk(result.value)) : mkErr(onErr(result.error))
+  (result, onOk, onErr) => isOk(result) ? newOk(onOk(result.value)) : newErr(onErr(result.error))
 );
 var flatMap = dual(
   2,
-  (result, fn) => isOk(result) ? fn(result.value) : mkErr(result.error)
+  (result, fn) => isOk(result) ? fn(result.value) : newErr(result.error)
 );
 var recover = dual(
   2,
-  (result, fn) => isErr(result) ? fn(result.error) : mkOk(result.value)
+  (result, fn) => isErr(result) ? fn(result.error) : newOk(result.value)
 );
 var tap = dual(2, (result, fn) => {
   if (isOk(result)) fn(result.value);
@@ -76,17 +150,17 @@ function unwrapErr(result) {
 function fromThrowable(fn, onThrow) {
   return (...args) => {
     try {
-      return mkOk(fn(...args));
+      return newOk(fn(...args));
     } catch (error) {
-      return mkErr(onThrow(error));
+      return newErr(onThrow(error));
     }
   };
 }
 function trySync(fn, onThrow) {
   try {
-    return mkOk(fn());
+    return newOk(fn());
   } catch (error) {
-    return mkErr(onThrow ? onThrow(error) : toError(error));
+    return newErr(onThrow ? onThrow(error) : toError(error));
   }
 }
 var printPayload = (payload) => {
@@ -99,6 +173,13 @@ var printPayload = (payload) => {
 var show = (result) => isOk(result) ? `Ok(${printPayload(result.value)})` : `Err(${printPayload(result.error)})`;
 
 // src/types.ts
+var Result = {
+  from: (data) => {
+    if (data._tag === "Ok") return newOk(data.value);
+    if (data._tag === "Err") return newErr(data.error);
+    throw new TypeError(`Result.from: unknown _tag ${String(data._tag)}`);
+  }
+};
 var UnexpectedError = class extends Error {
   constructor(message, cause) {
     super(message);
@@ -113,11 +194,11 @@ var sequenceSettled = (settled) => {
   const values = [];
   for (const result of settled) {
     if (isErr(result)) {
-      return mkErr(result.error);
+      return newErr(result.error);
     }
     values.push(result.value);
   }
-  return mkOk(values);
+  return newOk(values);
 };
 var ResultAsync = class _ResultAsync {
   constructor(run) {
@@ -154,9 +235,9 @@ var ResultAsync = class _ResultAsync {
   static fromPromise(promise, onReject) {
     return new _ResultAsync(async () => {
       try {
-        return mkOk(await promise);
+        return newOk(await promise);
       } catch (error) {
-        return mkErr(onReject(error));
+        return newErr(onReject(error));
       }
     });
   }
@@ -170,7 +251,7 @@ var ResultAsync = class _ResultAsync {
    * ```
    */
   static fromSafePromise(promise) {
-    return new _ResultAsync(async () => mkOk(await promise));
+    return new _ResultAsync(async () => newOk(await promise));
   }
   /**
    * Defers work until {@link resolve}. Unlike {@link fromPromise}, the factory
@@ -188,13 +269,13 @@ var ResultAsync = class _ResultAsync {
     return new _ResultAsync(fn);
   }
   static ok(value) {
-    return new _ResultAsync(async () => mkOk(value));
+    return new _ResultAsync(async () => newOk(value));
   }
   static of(value) {
     return _ResultAsync.ok(value);
   }
   static err(error) {
-    return new _ResultAsync(async () => mkErr(error));
+    return new _ResultAsync(async () => newErr(error));
   }
   /**
    * Lifts an existing `Promise<Result<T, E>>` (e.g. from interop code) into a
@@ -212,7 +293,7 @@ var ResultAsync = class _ResultAsync {
       try {
         return await promise;
       } catch (error) {
-        return mkErr(mapDefect(error));
+        return newErr(mapDefect(error));
       }
     });
   }
@@ -234,11 +315,11 @@ var ResultAsync = class _ResultAsync {
       for (const ra of results) {
         const result = await ra.resolve();
         if (isErr(result)) {
-          return mkErr(result.error);
+          return newErr(result.error);
         }
         values.push(result.value);
       }
-      return mkOk(values);
+      return newOk(values);
     });
   }
   /**
@@ -333,7 +414,7 @@ var ResultAsync = class _ResultAsync {
     return new _ResultAsync(async () => {
       const first = await this.resolve();
       if (isErr(first)) {
-        return first;
+        return newErr(first.error);
       }
       const next = fn(first.value);
       return next instanceof _ResultAsync ? next.resolve() : next;
@@ -365,7 +446,7 @@ var ResultAsync = class _ResultAsync {
     return new _ResultAsync(async () => {
       const first = await this.resolve();
       if (!isErr(first)) {
-        return first;
+        return newOk(first.value);
       }
       const next = fn(first.error);
       return next instanceof _ResultAsync ? next.resolve() : next;
@@ -501,13 +582,14 @@ function tryAsync(promise, onReject) {
 var combine = (results) => {
   const values = [];
   for (const result of results) {
-    if (isErr(result)) return mkErr(result.error);
+    if (isErr(result)) return newErr(result.error);
     values.push(result.value);
   }
-  return mkOk(values);
+  return newOk(values);
 };
 var combineTuple = (results, ..._guard) => (
   // Runtime identical to combine; the cast restores per-index tuple types.
+  // `unknown` hop: the tuple type is computed from R, which TS cannot relate to the runtime array.
   combine(results)
 );
 function validateAll(results, combineErrors) {
@@ -520,8 +602,8 @@ function validateAll(results, combineErrors) {
       values.push(result.value);
     }
   }
-  if (errors.length === 0) return mkOk(values);
-  return mkErr(combineErrors ? errors.reduce(combineErrors) : errors);
+  if (errors.length === 0) return newOk(values);
+  return newErr(combineErrors ? errors.reduce(combineErrors) : errors);
 }
 function validateTuple(results, ...rest) {
   const combineErrors = rest[0];
@@ -566,12 +648,12 @@ var tryGen = (fn) => {
     return fn();
   } catch (error) {
     if (error instanceof ErrSignal) {
-      return mkErr(error.error);
+      return newErr(error.error);
     }
     throw error;
   }
 };
 
-export { $, ResultAsync, UnexpectedError, asyncAfter, bimap, combine, combineTuple, err, errAsync, flatMap, flow, fromAsync, fromPromise, fromResult, fromSafePromise, fromThrowable, isErr, isOk, map, mapErr, match, of, ok, okAsync, pipe, recover, show, tap, tapErr, tryAsync, tryGen, trySync, unwrap, unwrapErr, unwrapOk, unwrapOr, validateAll, validateTuple, yieldResult };
+export { $, Result, ResultAsync, UnexpectedError, asyncAfter, bimap, combine, combineTuple, err, errAsync, flatMap, flow, fromAsync, fromPromise, fromResult, fromSafePromise, fromThrowable, isErr, isOk, map, mapErr, match, of, ok, okAsync, pipe, recover, show, tap, tapErr, tryAsync, tryGen, trySync, unwrap, unwrapErr, unwrapOk, unwrapOr, validateAll, validateTuple, yieldResult };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map