retuple 1.0.0-next.1 → 1.0.0-next.3

package/dist/index.js

@@ -10,74 +10,122 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _ResultAsync_inner;
+/**
+ * ## Retuple Unwrap Failed
+ *
+ * An error which occurs when calling `$unwrap` on `Err`.
+ */
 export class RetupleUnwrapFailed extends Error {
     constructor(value, msg = "Unwrap failed") {
         super(msg, value instanceof Error ? { cause: value } : undefined);
         this.value = value;
     }
 }
+/**
+ * ## Retuple Unwrap Err Failed
+ *
+ * An error which occurs when calling `$unwrapErr` on `Ok`.
+ */
 export class RetupleUnwrapErrFailed extends Error {
     constructor(value, msg = "Unwrap error failed") {
         super(msg);
         this.value = value;
     }
 }
+/**
+ * ## Retuple Expect Failed
+ *
+ * An error which occurs when calling `$expect` on `Err`, and when the value
+ * contained in the `Err` is not an instance of `Error`.
+ */
 export class RetupleExpectFailed extends Error {
     constructor(value) {
         super("Expect failed");
         this.value = value;
     }
 }
+/**
+ * ## Retuple Thrown Value Error
+ *
+ * An error constructed when a safe function call throws or rejects, when the
+ * thrown error or rejected value is not an instance of `Error`, and when no
+ * map error function is provided.
+ */
 export class RetupleThrownValueError extends Error {
     constructor(value) {
         super("Caught value was not an instance of Error");
         this.value = value;
     }
 }
+/**
+ * ## Retuple Invalid Result Error
+ *
+ * An error constructed when a safe function call throws or rejects, when the
+ * thrown error or rejected value is not an instance of `Error`, and when no
+ * map error function is provided.
+ */
+export class RetupleInvalidResultError extends Error {
+    constructor(value) {
+        super("Constructing a Result from tuple failed, at least one of the values at index 0 or 1 should be undefined");
+        this.value = value;
+    }
+}
 /**
  * ## Result
  *
  * @TODO
  */
-export const Result = {
-    Ok,
-    Err,
-    from,
-    safe,
-    safeAsync,
-    safePromise,
-};
-export default Result;
+export function Result(resultLike) {
+    const [err, ok] = resultLike;
+    if (err === null || err === undefined) {
+        return new ResultOk(ok);
+    }
+    if (ok === null || ok === undefined) {
+        return new ResultErr(err);
+    }
+    throw new RetupleInvalidResultError(resultLike);
+}
+Result.Ok = Ok;
+Result.Err = Err;
+Result.nonNullable = nonNullable;
+Result.truthy = truthy;
+Result.safe = safe;
+Result.safeAsync = safeAsync;
+Result.safePromise = safePromise;
+Object.freeze(Result);
 export function Ok(val) {
     return new ResultOk(val);
 }
 export function Err(err) {
     return new ResultErr(err);
 }
-export function from(value, error) {
-    if (value) {
+export function nonNullable(value, error = mapTrue) {
+    if (value !== null && value !== undefined) {
         return new ResultOk(value);
     }
-    if (error) {
-        return new ResultErr(error());
+    return new ResultErr(error());
+}
+export function truthy(value, error = mapTrue) {
+    if (value) {
+        return new ResultOk(value);
     }
-    return new ResultErr(true);
+    return new ResultErr(error());
 }
 export function safe(f, mapError = ensureError) {
     try {
-        return Ok(f());
+        return new ResultOk(f());
     }
     catch (err) {
-        return Err(mapError(err));
+        return new ResultErr(mapError(err));
     }
 }
 export function safeAsync(f, mapError = ensureError) {
     return new ResultAsync((async () => {
         try {
-            return Ok(await f());
+            return new ResultOk(await f());
         }
         catch (err) {
-            return Err(await mapError(err));
+            return new ResultErr(await mapError(err));
         }
     })());
 }
@@ -95,6 +143,12 @@ class ResultOk extends Array {
         this[0] = undefined;
         this[1] = value;
     }
+    toJSON() {
+        return this[1];
+    }
+    $toNativeTuple() {
+        return [undefined, this[1]];
+    }
     $value() {
         return this[1];
     }
@@ -102,7 +156,7 @@ class ResultOk extends Array {
         return true;
     }
     $isOkAnd(f) {
-        return f(this[1]);
+        return !!f(this[1]);
     }
     $isErr() {
         return false;
@@ -137,6 +191,12 @@ class ResultOk extends Array {
     $mapOrElse(_def, f) {
         return new ResultOk(f(this[1]));
     }
+    $assertOr(def, condition = isTruthy) {
+        return condition(this[1]) ? this : def;
+    }
+    $assertOrElse(def, condition = isTruthy) {
+        return condition(this[1]) ? this : def();
+    }
     $or() {
         return this;
     }
@@ -196,6 +256,12 @@ class ResultErr extends Array {
         this[0] = err;
         this[1] = undefined;
     }
+    toJSON() {
+        return null;
+    }
+    $toNativeTuple() {
+        return [this[0], undefined];
+    }
     $value() {
         return this[0];
     }
@@ -209,7 +275,7 @@ class ResultErr extends Array {
         return true;
     }
     $isErrAnd(f) {
-        return f(this[0]);
+        return !!f(this[0]);
     }
     $expect() {
         if (this[0] instanceof Error) {
@@ -241,6 +307,12 @@ class ResultErr extends Array {
     $mapOrElse(def) {
         return new ResultOk(def(this[0]));
     }
+    $assertOr() {
+        return this;
+    }
+    $assertOrElse() {
+        return this;
+    }
     $or(or) {
         return or;
     }
@@ -378,6 +450,22 @@ class ResultAsync {
                 : new ResultOk(def(res[0]));
         }));
     }
+    $assertOr(def, condition = isTruthy) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr || condition(res[1])) {
+                return res;
+            }
+            return await def;
+        }));
+    }
+    $assertOrElse(def, condition = isTruthy) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr || condition(res[1])) {
+                return res;
+            }
+            return await def();
+        }));
+    }
     /**
      * @TODO
      */
@@ -394,9 +482,6 @@ class ResultAsync {
             return res instanceof ResultErr ? await f(res[0]) : res;
         }));
     }
-    /**
-     * @TODO
-     */
     $orSafe(f, mapError = ensureError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultOk) {
@@ -440,9 +525,6 @@ class ResultAsync {
             return res;
         }));
     }
-    /**
-     * @TODO
-     */
     $andSafe(f, mapError = ensureError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultErr) {
@@ -501,18 +583,9 @@ function ensureError(err) {
     }
     return new RetupleThrownValueError(err);
 }
-Object.freeze(Result);
-Object.freeze(ResultOk);
-Object.freeze(ResultErr);
-Object.freeze(ResultAsync);
-Object.freeze(RetupleUnwrapFailed);
-Object.freeze(RetupleUnwrapErrFailed);
-Object.freeze(RetupleExpectFailed);
-Object.freeze(RetupleThrownValueError);
-Object.freeze(ResultOk.prototype);
-Object.freeze(ResultErr.prototype);
-Object.freeze(ResultAsync.prototype);
-Object.freeze(RetupleUnwrapFailed.prototype);
-Object.freeze(RetupleUnwrapErrFailed.prototype);
-Object.freeze(RetupleExpectFailed.prototype);
-Object.freeze(RetupleThrownValueError.prototype);
+function mapTrue() {
+    return true;
+}
+function isTruthy(val) {
+    return !!val;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "retuple",
-  "version": "1.0.0-next.1",
+  "version": "1.0.0-next.3",
   "scripts": {
     "test": "vitest",
     "lint": "eslint . --ext .ts -c eslint.config.mjs --fix",