@onrails/result 0.4.1 → 0.5.0

package/dist/compat/neverthrow.cjs

@@ -1,14 +1,88 @@
 'use strict';
 
-// 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) => {
@@ -22,30 +96,22 @@ 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))
-);
-var flatMap = dual(
-  2,
-  (result, fn) => isOk(result) ? fn(result.value) : mkErr(result.error)
-);
-var unwrapOr = dual(
-  2,
-  (result, defaultValue) => isOk(result) ? result.value : defaultValue
+  (result, onOk, onErr) => isOk(result) ? newOk(onOk(result.value)) : newErr(onErr(result.error))
 );
 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));
     }
   };
 }
@@ -65,11 +131,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) {
@@ -106,9 +172,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));
       }
     });
   }
@@ -122,7 +188,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
@@ -140,13 +206,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
@@ -164,7 +230,7 @@ var ResultAsync = class _ResultAsync {
       try {
         return await promise;
       } catch (error) {
-        return mkErr(mapDefect(error));
+        return newErr(mapDefect(error));
       }
     });
   }
@@ -186,11 +252,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);
     });
   }
   /**
@@ -285,7 +351,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;
@@ -317,7 +383,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;
@@ -438,15 +504,29 @@ var ResultAsync = class _ResultAsync {
 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) {
+  const values = [];
+  const errors = [];
+  for (const result of results) {
+    if (isErr(result)) {
+      errors.push(result.error);
+    } else {
+      values.push(result.value);
+    }
+  }
+  if (errors.length === 0) return newOk(values);
+  return newErr(errors);
+}
 
 // src/compat/neverthrow.ts
 var CompatResult = class _CompatResult {
@@ -463,11 +543,12 @@ var CompatResult = class _CompatResult {
       combineTuple(results.map((r) => r.inner))
     );
   }
-  get value() {
-    return this._unsafeUnwrap();
-  }
-  get error() {
-    return this._unsafeUnwrapErr();
+  // The `as unknown as` casts below restore per-index tuple types computed from R, which TS cannot
+  // relate to the runtime arrays.
+  static combineWithAllErrors(results) {
+    return new _CompatResult(
+      validateAll(results.map((r) => r.inner))
+    );
   }
   isOk() {
     return isOk(this.inner);
@@ -476,25 +557,68 @@ var CompatResult = class _CompatResult {
     return isErr(this.inner);
   }
   map(fn) {
-    return new _CompatResult(map(this.inner, fn));
+    return new _CompatResult(this.inner.map(fn));
   }
   mapErr(fn) {
-    return new _CompatResult(mapErr(this.inner, fn));
+    return new _CompatResult(this.inner.mapErr(fn));
   }
   andThen(fn) {
-    return new _CompatResult(flatMap(this.inner, (value) => fn(value).inner));
+    return new _CompatResult(this.inner.flatMap((value) => fn(value).inner));
   }
   asyncAndThen(fn) {
     return isErr(this.inner) ? CompatResultAsync.err(this.inner.error) : CompatResultAsync.fromInner(coerceToCoreAsync(fn(this.inner.value)));
   }
   orElse(fn) {
-    return isOk(this.inner) ? new _CompatResult(this.inner) : fn(this.inner.error);
+    return isOk(this.inner) ? new _CompatResult(newOk(this.inner.value)) : fn(this.inner.error);
   }
   match(onOk, onErr) {
     return isOk(this.inner) ? onOk(this.inner.value) : onErr(this.inner.error);
   }
   unwrapOr(defaultValue) {
-    return unwrapOr(this.inner, defaultValue);
+    return this.inner.unwrapOr(defaultValue);
+  }
+  andTee(fn) {
+    if (isOk(this.inner)) {
+      try {
+        fn(this.inner.value);
+      } catch {
+      }
+    }
+    return this;
+  }
+  orTee(fn) {
+    if (isErr(this.inner)) {
+      try {
+        fn(this.inner.error);
+      } catch {
+      }
+    }
+    return this;
+  }
+  andThrough(fn) {
+    if (isErr(this.inner)) return this;
+    const through = fn(this.inner.value).inner;
+    return isErr(through) ? new _CompatResult(newErr(through.error)) : this;
+  }
+  asyncAndThrough(fn) {
+    const inner = this.inner;
+    return CompatResultAsync.fromInner(
+      ResultAsync.defer(async () => {
+        if (isErr(inner)) return inner;
+        const through = await coerceToCoreAsync(fn(inner.value)).resolve();
+        return isErr(through) ? newErr(through.error) : inner;
+      })
+    );
+  }
+  asyncMap(fn) {
+    return isErr(this.inner) ? CompatResultAsync.err(this.inner.error) : CompatResultAsync.fromSafePromise(fn(this.inner.value));
+  }
+  /** Yields the `Err` to {@link safeTry} on failure; returns the `Ok` value otherwise. */
+  *safeUnwrap() {
+    if (isErr(this.inner)) {
+      yield new _CompatResult(newErr(this.inner.error));
+    }
+    return this._unsafeUnwrap();
   }
   _unsafeUnwrap() {
     if (isErr(this.inner)) {
@@ -510,8 +634,34 @@ var CompatResult = class _CompatResult {
   }
 };
 var Result = CompatResult;
-var ok = (value) => new CompatResult(mkOk(value));
-var err = (error) => new CompatResult(mkErr(error));
+var ok = (value) => new CompatResult(newOk(value));
+var err = (error) => new CompatResult(newErr(error));
+Object.defineProperty(CompatResult.prototype, "value", {
+  get() {
+    return this._unsafeUnwrap();
+  }
+});
+Object.defineProperty(CompatResult.prototype, "error", {
+  get() {
+    return this._unsafeUnwrapErr();
+  }
+});
+var Ok = class extends CompatResult {
+  constructor(value) {
+    super(newOk(value));
+  }
+  static [Symbol.hasInstance](candidate) {
+    return candidate instanceof CompatResult && isOk(candidate.inner);
+  }
+};
+var Err = class extends CompatResult {
+  constructor(error) {
+    super(newErr(error));
+  }
+  static [Symbol.hasInstance](candidate) {
+    return candidate instanceof CompatResult && isErr(candidate.inner);
+  }
+};
 var CompatResultAsync = class _CompatResultAsync {
   constructor(inner) {
     this.inner = inner;
@@ -543,6 +693,13 @@ var CompatResultAsync = class _CompatResultAsync {
       ResultAsync.combine(results.map((r) => r.inner))
     );
   }
+  static combineWithAllErrors(results) {
+    return new _CompatResultAsync(
+      ResultAsync.defer(
+        async () => validateAll(await Promise.all(results.map((r) => r.resolve())))
+      )
+    );
+  }
   // biome-ignore lint/suspicious/noThenProperty: thenable shim for `await ra` -> CompatResult
   then(onfulfilled, onrejected) {
     return this.inner.resolve().then((r) => {
@@ -607,6 +764,21 @@ var CompatResultAsync = class _CompatResultAsync {
       })
     );
   }
+  andThrough(fn) {
+    return new _CompatResultAsync(
+      ResultAsync.defer(async () => {
+        const r = await this.inner.resolve();
+        if (isErr(r)) return r;
+        const next = coerceToCore(fn(r.value));
+        const through = next instanceof ResultAsync ? await next.resolve() : next;
+        return isErr(through) ? newErr(through.error) : r;
+      })
+    );
+  }
+  /** Async twin of {@link CompatResult.safeUnwrap}. */
+  async *safeUnwrap() {
+    return yield* new CompatResult(await this.inner.resolve()).safeUnwrap();
+  }
   orTee(fn) {
     return new _CompatResultAsync(
       ResultAsync.defer(async () => {
@@ -629,20 +801,34 @@ function coerceToCore(next) {
   return next;
 }
 var coerceToCoreAsync = (next) => next instanceof CompatResultAsync ? next.toCore() : next;
+function safeTry(body) {
+  const step = body().next();
+  if (step instanceof Promise) {
+    return CompatResultAsync.fromInner(ResultAsync.defer(async () => (await step).value.inner));
+  }
+  return step.value;
+}
 var okAsync = CompatResultAsync.ok;
 var errAsync = CompatResultAsync.err;
 var fromPromise = CompatResultAsync.fromPromise;
 var fromSafePromise = CompatResultAsync.fromSafePromise;
+var fromThrowable2 = CompatResult.fromThrowable;
+var fromAsyncThrowable = CompatResultAsync.fromThrowable;
 
 exports.CompatResult = CompatResult;
 exports.CompatResultAsync = CompatResultAsync;
+exports.Err = Err;
+exports.Ok = Ok;
 exports.Result = Result;
 exports.ResultAsync = CompatResultAsync;
 exports.err = err;
 exports.errAsync = errAsync;
+exports.fromAsyncThrowable = fromAsyncThrowable;
 exports.fromPromise = fromPromise;
 exports.fromSafePromise = fromSafePromise;
+exports.fromThrowable = fromThrowable2;
 exports.ok = ok;
 exports.okAsync = okAsync;
+exports.safeTry = safeTry;
 //# sourceMappingURL=neverthrow.cjs.map
 //# sourceMappingURL=neverthrow.cjs.map