retuple 0.0.1 → 1.0.0-next.1

package/dist/index.js

@@ -0,0 +1,518 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ResultAsync_inner;
+export class RetupleUnwrapFailed extends Error {
+    constructor(value, msg = "Unwrap failed") {
+        super(msg, value instanceof Error ? { cause: value } : undefined);
+        this.value = value;
+    }
+}
+export class RetupleUnwrapErrFailed extends Error {
+    constructor(value, msg = "Unwrap error failed") {
+        super(msg);
+        this.value = value;
+    }
+}
+export class RetupleExpectFailed extends Error {
+    constructor(value) {
+        super("Expect failed");
+        this.value = value;
+    }
+}
+export class RetupleThrownValueError extends Error {
+    constructor(value) {
+        super("Caught value was not an instance of Error");
+        this.value = value;
+    }
+}
+/**
+ * ## Result
+ *
+ * @TODO
+ */
+export const Result = {
+    Ok,
+    Err,
+    from,
+    safe,
+    safeAsync,
+    safePromise,
+};
+export default Result;
+export function Ok(val) {
+    return new ResultOk(val);
+}
+export function Err(err) {
+    return new ResultErr(err);
+}
+export function from(value, error) {
+    if (value) {
+        return new ResultOk(value);
+    }
+    if (error) {
+        return new ResultErr(error());
+    }
+    return new ResultErr(true);
+}
+export function safe(f, mapError = ensureError) {
+    try {
+        return Ok(f());
+    }
+    catch (err) {
+        return Err(mapError(err));
+    }
+}
+export function safeAsync(f, mapError = ensureError) {
+    return new ResultAsync((async () => {
+        try {
+            return Ok(await f());
+        }
+        catch (err) {
+            return Err(await mapError(err));
+        }
+    })());
+}
+export function safePromise(promise, mapError = ensureError) {
+    return new ResultAsync(promise.then((Ok), async (err) => Err(await mapError(err))));
+}
+/**
+ * ## Ok
+ *
+ * @TODO
+ */
+class ResultOk extends Array {
+    constructor(value) {
+        super(2);
+        this[0] = undefined;
+        this[1] = value;
+    }
+    $value() {
+        return this[1];
+    }
+    $isOk() {
+        return true;
+    }
+    $isOkAnd(f) {
+        return f(this[1]);
+    }
+    $isErr() {
+        return false;
+    }
+    $isErrAnd() {
+        return false;
+    }
+    $expect() {
+        return this[1];
+    }
+    $unwrap() {
+        return this[1];
+    }
+    $unwrapErr(msg) {
+        throw new RetupleUnwrapErrFailed(this[1], msg);
+    }
+    $unwrapOr() {
+        return this[1];
+    }
+    $unwrapOrElse() {
+        return this[1];
+    }
+    $map(f) {
+        return new ResultOk(f(this[1]));
+    }
+    $mapErr() {
+        return this;
+    }
+    $mapOr(_def, f) {
+        return new ResultOk(f(this[1]));
+    }
+    $mapOrElse(_def, f) {
+        return new ResultOk(f(this[1]));
+    }
+    $or() {
+        return this;
+    }
+    $orElse() {
+        return this;
+    }
+    $orSafe() {
+        return this;
+    }
+    $and(and) {
+        return and;
+    }
+    $andThen(f) {
+        return f(this[1]);
+    }
+    $andThrough(f) {
+        const res = f(this[1]);
+        return res instanceof ResultErr ? res : this;
+    }
+    $andSafe(f, mapError = ensureError) {
+        try {
+            return new ResultOk(f(this[1]));
+        }
+        catch (err) {
+            return new ResultErr(mapError(err));
+        }
+    }
+    $peek(f) {
+        f(this);
+        return this;
+    }
+    $tap(f) {
+        f(this[1]);
+        return this;
+    }
+    $tapErr() {
+        return this;
+    }
+    $flatten() {
+        return this[1];
+    }
+    $async() {
+        return new ResultAsync(Promise.resolve(this));
+    }
+    $promise() {
+        return Promise.resolve(this);
+    }
+}
+/**
+ * ## Err
+ *
+ * @TODO
+ */
+class ResultErr extends Array {
+    constructor(err) {
+        super(2);
+        this[0] = err;
+        this[1] = undefined;
+    }
+    $value() {
+        return this[0];
+    }
+    $isOk() {
+        return false;
+    }
+    $isOkAnd() {
+        return false;
+    }
+    $isErr() {
+        return true;
+    }
+    $isErrAnd(f) {
+        return f(this[0]);
+    }
+    $expect() {
+        if (this[0] instanceof Error) {
+            throw this[0];
+        }
+        throw new RetupleExpectFailed(this[0]);
+    }
+    $unwrap(msg) {
+        throw new RetupleUnwrapFailed(this[0], msg);
+    }
+    $unwrapErr() {
+        return this[0];
+    }
+    $unwrapOr(def) {
+        return def;
+    }
+    $unwrapOrElse(f) {
+        return f();
+    }
+    $map() {
+        return this;
+    }
+    $mapErr(f) {
+        return new ResultErr(f(this[0]));
+    }
+    $mapOr(def) {
+        return new ResultOk(def);
+    }
+    $mapOrElse(def) {
+        return new ResultOk(def(this[0]));
+    }
+    $or(or) {
+        return or;
+    }
+    $orElse(f) {
+        return f(this[0]);
+    }
+    $orSafe(f, mapError = ensureError) {
+        try {
+            return new ResultOk(f(this[0]));
+        }
+        catch (err) {
+            return new ResultErr(mapError(err));
+        }
+    }
+    $and() {
+        return this;
+    }
+    $andThen() {
+        return this;
+    }
+    $andThrough() {
+        return this;
+    }
+    $andSafe() {
+        return this;
+    }
+    $peek(f) {
+        f(this);
+        return this;
+    }
+    $tap() {
+        return this;
+    }
+    $tapErr(f) {
+        f(this[0]);
+        return this;
+    }
+    $flatten() {
+        return this;
+    }
+    $async() {
+        return new ResultAsync(Promise.resolve(this));
+    }
+    $promise() {
+        return Promise.resolve(this);
+    }
+}
+/**
+ * ## ResultAsync
+ *
+ * @TODO
+ */
+class ResultAsync {
+    constructor(inner) {
+        _ResultAsync_inner.set(this, void 0);
+        __classPrivateFieldSet(this, _ResultAsync_inner, inner, "f");
+    }
+    then(onfulfilled, onrejected) {
+        return __classPrivateFieldGet(this, _ResultAsync_inner, "f").then(onfulfilled, onrejected);
+    }
+    /**
+     * @TODO
+     */
+    async $value() {
+        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$value();
+    }
+    /**
+     * @TODO
+     */
+    async $expect() {
+        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$expect();
+    }
+    /**
+     * @TODO
+     */
+    async $unwrap(msg) {
+        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$unwrap(msg);
+    }
+    /**
+     * @TODO
+     */
+    async $unwrapErr(msg) {
+        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$unwrapErr(msg);
+    }
+    /**
+     * @TODO
+     */
+    async $unwrapOr(def) {
+        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$unwrapOr(def);
+    }
+    /**
+     * @TODO
+     */
+    async $unwrapOrElse(f) {
+        const res = await __classPrivateFieldGet(this, _ResultAsync_inner, "f");
+        return res instanceof ResultOk ? res[1] : f();
+    }
+    /**
+     * @TODO
+     */
+    $map(f) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            return res instanceof ResultOk
+                ? new ResultOk(f(res[1]))
+                : res;
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $mapErr(f) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            return res instanceof ResultErr
+                ? new ResultErr(f(res[0]))
+                : res;
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $mapOr(def, f) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            return res instanceof ResultOk
+                ? new ResultOk(f(res[1]))
+                : new ResultOk(def);
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $mapOrElse(def, f) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            return res instanceof ResultOk
+                ? new ResultOk(f(res[1]))
+                : new ResultOk(def(res[0]));
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $or(or) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            return res instanceof ResultErr ? await or : res;
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $orElse(f) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            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) {
+                return res;
+            }
+            try {
+                return new ResultOk(await f(res[0]));
+            }
+            catch (err) {
+                return new ResultErr(mapError(err));
+            }
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $and(and) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            return res instanceof ResultOk ? await and : res;
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $andThen(f) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            return res instanceof ResultOk ? await f(res[1]) : res;
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $andThrough(f) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultOk) {
+                const through = await f(res[1]);
+                if (through instanceof ResultErr) {
+                    return through;
+                }
+            }
+            return res;
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $andSafe(f, mapError = ensureError) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr) {
+                return res;
+            }
+            try {
+                return new ResultOk(await f(res[1]));
+            }
+            catch (err) {
+                return new ResultErr(mapError(err));
+            }
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $peek(f) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            await f(res);
+            return res;
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $tap(f) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultOk) {
+                await f(res[1]);
+            }
+            return res;
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $tapErr(f) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr) {
+                await f(res[0]);
+            }
+            return res;
+        }));
+    }
+    /**
+     * @TODO
+     */
+    $promise() {
+        return Promise.resolve(this);
+    }
+}
+_ResultAsync_inner = new WeakMap();
+function ensureError(err) {
+    if (err instanceof Error) {
+        return 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);

package/package.json

@@ -1,13 +1,51 @@
 {
   "name": "retuple",
-  "version": "0.0.1",
-  "description": "An errors-as-values library for TypeScript",
+  "version": "1.0.0-next.1",
+  "scripts": {
+    "test": "vitest",
+    "lint": "eslint . --ext .ts -c eslint.config.mjs --fix",
+    "build": "zshy",
+    "coverage": "vitest run --coverage && open './coverage/index.html'"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.cts",
+  "module": "./dist/index.js",
+  "zshy": "./src/index.ts",
   "keywords": [
-    "result",
-    "monad",
     "error",
-    "handling"
+    "handling",
+    "safe",
+    "result",
+    "throw",
+    "monad"
   ],
   "author": "Matthew Wilson",
-  "license": "MIT"
+  "license": "MIT",
+  "description": "A strongly typed errors as values library built around tuples.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/traverse1984/retuple.git"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.2",
+    "zshy": "^0.4.1",
+    "vitest": "^3.2.4",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^9.35.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "@typescript-eslint/eslint-plugin": "^8.43.0",
+    "@typescript-eslint/parser": "^8.43.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.cts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ]
 }