retuple 0.0.1 → 1.0.0-next.1

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2025 Matthew Wilson
+
+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/README.md

@@ -0,0 +1 @@
+## Retuple

package/dist/index.cjs

@@ -0,0 +1,531 @@
+"use strict";
+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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Result = exports.RetupleThrownValueError = exports.RetupleExpectFailed = exports.RetupleUnwrapErrFailed = exports.RetupleUnwrapFailed = void 0;
+exports.Ok = Ok;
+exports.Err = Err;
+exports.from = from;
+exports.safe = safe;
+exports.safeAsync = safeAsync;
+exports.safePromise = safePromise;
+class RetupleUnwrapFailed extends Error {
+    constructor(value, msg = "Unwrap failed") {
+        super(msg, value instanceof Error ? { cause: value } : undefined);
+        this.value = value;
+    }
+}
+exports.RetupleUnwrapFailed = RetupleUnwrapFailed;
+class RetupleUnwrapErrFailed extends Error {
+    constructor(value, msg = "Unwrap error failed") {
+        super(msg);
+        this.value = value;
+    }
+}
+exports.RetupleUnwrapErrFailed = RetupleUnwrapErrFailed;
+class RetupleExpectFailed extends Error {
+    constructor(value) {
+        super("Expect failed");
+        this.value = value;
+    }
+}
+exports.RetupleExpectFailed = RetupleExpectFailed;
+class RetupleThrownValueError extends Error {
+    constructor(value) {
+        super("Caught value was not an instance of Error");
+        this.value = value;
+    }
+}
+exports.RetupleThrownValueError = RetupleThrownValueError;
+/**
+ * ## Result
+ *
+ * @TODO
+ */
+exports.Result = {
+    Ok,
+    Err,
+    from,
+    safe,
+    safeAsync,
+    safePromise,
+};
+exports.default = exports.Result;
+function Ok(val) {
+    return new ResultOk(val);
+}
+function Err(err) {
+    return new ResultErr(err);
+}
+function from(value, error) {
+    if (value) {
+        return new ResultOk(value);
+    }
+    if (error) {
+        return new ResultErr(error());
+    }
+    return new ResultErr(true);
+}
+function safe(f, mapError = ensureError) {
+    try {
+        return Ok(f());
+    }
+    catch (err) {
+        return Err(mapError(err));
+    }
+}
+function safeAsync(f, mapError = ensureError) {
+    return new ResultAsync((async () => {
+        try {
+            return Ok(await f());
+        }
+        catch (err) {
+            return Err(await mapError(err));
+        }
+    })());
+}
+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(exports.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);