@zokugun/xtry 0.6.2 → 0.6.4

package/lib/cjs/async.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xtry = exports.stringifyError = exports.OK_FALSE = exports.OK_TRUE = exports.OK_NULL = exports.OK = exports.err = exports.ok = exports.YOK_FALSE = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK = exports.yep = exports.yres = exports.yerr = exports.yok = exports.xdefer = void 0;
+var defer_js_1 = require("./defer.cjs");
+Object.defineProperty(exports, "xdefer", { enumerable: true, get: function () { return defer_js_1.xdeferAsync; } });
+var partial_js_1 = require("./partial.cjs");
+Object.defineProperty(exports, "yok", { enumerable: true, get: function () { return partial_js_1.yok; } });
+Object.defineProperty(exports, "yerr", { enumerable: true, get: function () { return partial_js_1.yerr; } });
+Object.defineProperty(exports, "yres", { enumerable: true, get: function () { return partial_js_1.yresAsync; } });
+Object.defineProperty(exports, "yep", { enumerable: true, get: function () { return partial_js_1.yep; } });
+Object.defineProperty(exports, "YOK", { enumerable: true, get: function () { return partial_js_1.YOK; } });
+Object.defineProperty(exports, "YOK_NULL", { enumerable: true, get: function () { return partial_js_1.YOK_NULL; } });
+Object.defineProperty(exports, "YOK_TRUE", { enumerable: true, get: function () { return partial_js_1.YOK_TRUE; } });
+Object.defineProperty(exports, "YOK_FALSE", { enumerable: true, get: function () { return partial_js_1.YOK_FALSE; } });
+var result_js_1 = require("./result.cjs");
+Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return result_js_1.ok; } });
+Object.defineProperty(exports, "err", { enumerable: true, get: function () { return result_js_1.err; } });
+Object.defineProperty(exports, "OK", { enumerable: true, get: function () { return result_js_1.OK; } });
+Object.defineProperty(exports, "OK_NULL", { enumerable: true, get: function () { return result_js_1.OK_NULL; } });
+Object.defineProperty(exports, "OK_TRUE", { enumerable: true, get: function () { return result_js_1.OK_TRUE; } });
+Object.defineProperty(exports, "OK_FALSE", { enumerable: true, get: function () { return result_js_1.OK_FALSE; } });
+var stringify_error_js_1 = require("./stringify-error.cjs");
+Object.defineProperty(exports, "stringifyError", { enumerable: true, get: function () { return stringify_error_js_1.stringifyError; } });
+var try_js_1 = require("./try.cjs");
+Object.defineProperty(exports, "xtry", { enumerable: true, get: function () { return try_js_1.xtryAsync; } });

package/lib/cjs/async.d.cts

@@ -0,0 +1,7 @@
+export { xdeferAsync as xdefer } from './defer.cjs';
+export type { YResult, YSuccess, YFailure } from './partial.cjs';
+export { yok, yerr, yresAsync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.cjs';
+export type { Success, Failure, Result } from './result.cjs';
+export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.cjs';
+export { stringifyError } from './stringify-error.cjs';
+export { xtryAsync as xtry } from './try.cjs';

package/lib/cjs/defer.cjs

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xdefer = xdefer;
+exports.xdeferAsync = xdeferAsync;
+exports.xdeferSync = xdeferSync;
+const result_js_1 = require("./result.cjs");
+const is_promise_like_js_1 = require("./utils/is-promise-like.cjs");
+function xdefer(callback) {
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    return ((result) => {
+        const finalize = (deferResult) => {
+            if (deferResult.fails) {
+                if ((result)?.fails) {
+                    return result;
+                }
+                return deferResult;
+            }
+            return (result) ?? (0, result_js_1.ok)();
+        };
+        const deferredValue = callback instanceof Function ? callback() : callback;
+        if ((0, is_promise_like_js_1.isPromiseLike)(deferredValue)) {
+            return Promise.resolve(deferredValue).then(finalize);
+        }
+        return finalize(deferredValue);
+    });
+}
+function xdeferAsync(callback) {
+    return (async (result) => {
+        const deferResult = await (callback instanceof Promise ? callback : callback());
+        if (deferResult.fails) {
+            if (result?.fails) {
+                return result;
+            }
+            return deferResult;
+        }
+        return result ?? (0, result_js_1.ok)();
+    });
+}
+function xdeferSync(callback) {
+    return ((result) => {
+        const deferResult = callback();
+        if (deferResult.fails) {
+            if (result?.fails) {
+                return result;
+            }
+            return deferResult;
+        }
+        return result ?? (0, result_js_1.ok)();
+    });
+}

package/lib/cjs/defer.d.cts

@@ -0,0 +1,19 @@
+import { type Failure, type Result, type Success } from './result.cjs';
+import { type NonPromiseCallback, type PromiseCallback } from './utils/types.cjs';
+type DeferAsync<E> = {
+    (): Promise<Success<void>>;
+    <T>(result: Success<T>): Promise<Result<T, E>>;
+    <F>(result: Failure<F>): Promise<Failure<F>>;
+    <T, F>(result: Result<T, F>): Promise<Result<T, E | F>>;
+};
+type DeferSync<E> = {
+    (): Success<void>;
+    <T>(result: Success<T>): Result<T, E>;
+    <F>(result: Failure<F>): Failure<F>;
+    <T, F>(result: Result<T, F>): Result<T, E | F>;
+};
+export declare function xdefer<E>(callback: NonPromiseCallback<Result<unknown, E>>): DeferSync<E>;
+export declare function xdefer<E>(callback: PromiseCallback<Result<unknown, E>>): DeferAsync<E>;
+export declare function xdeferAsync<E>(callback: PromiseCallback<Result<unknown, E>>): DeferAsync<E>;
+export declare function xdeferSync<E>(callback: NonPromiseCallback<Result<unknown, E>>): DeferSync<E>;
+export {};

package/lib/cjs/index.cjs

@@ -1,29 +1,31 @@
-const require__home_runner_work_node_xtry_node_xtry_src_result = require('./result.cjs');
-const require__home_runner_work_node_xtry_node_xtry_src_defer = require('./defer.cjs');
-const require__home_runner_work_node_xtry_node_xtry_src_partial = require('./partial.cjs');
-const require__home_runner_work_node_xtry_node_xtry_src_stringify_error = require('./stringify-error.cjs');
-const require__home_runner_work_node_xtry_node_xtry_src_try = require('./try.cjs');
-
-exports.OK = require__home_runner_work_node_xtry_node_xtry_src_result.OK;
-exports.OK_FALSE = require__home_runner_work_node_xtry_node_xtry_src_result.OK_FALSE;
-exports.OK_NULL = require__home_runner_work_node_xtry_node_xtry_src_result.OK_NULL;
-exports.OK_TRUE = require__home_runner_work_node_xtry_node_xtry_src_result.OK_TRUE;
-exports.YOK = require__home_runner_work_node_xtry_node_xtry_src_partial.YOK;
-exports.YOK_FALSE = require__home_runner_work_node_xtry_node_xtry_src_partial.YOK_FALSE;
-exports.YOK_NULL = require__home_runner_work_node_xtry_node_xtry_src_partial.YOK_NULL;
-exports.YOK_TRUE = require__home_runner_work_node_xtry_node_xtry_src_partial.YOK_TRUE;
-exports.err = require__home_runner_work_node_xtry_node_xtry_src_result.err;
-exports.ok = require__home_runner_work_node_xtry_node_xtry_src_result.ok;
-exports.stringifyError = require__home_runner_work_node_xtry_node_xtry_src_stringify_error.stringifyError;
-exports.xdefer = require__home_runner_work_node_xtry_node_xtry_src_defer.xdefer;
-exports.xdeferAsync = require__home_runner_work_node_xtry_node_xtry_src_defer.xdeferAsync;
-exports.xdeferSync = require__home_runner_work_node_xtry_node_xtry_src_defer.xdeferSync;
-exports.xtry = require__home_runner_work_node_xtry_node_xtry_src_try.xtry;
-exports.xtryAsync = require__home_runner_work_node_xtry_node_xtry_src_try.xtryAsync;
-exports.xtrySync = require__home_runner_work_node_xtry_node_xtry_src_try.xtrySync;
-exports.yep = require__home_runner_work_node_xtry_node_xtry_src_partial.yep;
-exports.yerr = require__home_runner_work_node_xtry_node_xtry_src_partial.yerr;
-exports.yok = require__home_runner_work_node_xtry_node_xtry_src_partial.yok;
-exports.yres = require__home_runner_work_node_xtry_node_xtry_src_partial.yres;
-exports.yresAsync = require__home_runner_work_node_xtry_node_xtry_src_partial.yresAsync;
-exports.yresSync = require__home_runner_work_node_xtry_node_xtry_src_partial.yresSync;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xtrySync = exports.xtryAsync = exports.xtry = exports.stringifyError = exports.OK_FALSE = exports.OK_TRUE = exports.OK_NULL = exports.OK = exports.err = exports.ok = exports.YOK_FALSE = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK = exports.yep = exports.yresSync = exports.yresAsync = exports.yres = exports.yerr = exports.yok = exports.xdeferSync = exports.xdeferAsync = exports.xdefer = void 0;
+var defer_js_1 = require("./defer.cjs");
+Object.defineProperty(exports, "xdefer", { enumerable: true, get: function () { return defer_js_1.xdefer; } });
+Object.defineProperty(exports, "xdeferAsync", { enumerable: true, get: function () { return defer_js_1.xdeferAsync; } });
+Object.defineProperty(exports, "xdeferSync", { enumerable: true, get: function () { return defer_js_1.xdeferSync; } });
+var partial_js_1 = require("./partial.cjs");
+Object.defineProperty(exports, "yok", { enumerable: true, get: function () { return partial_js_1.yok; } });
+Object.defineProperty(exports, "yerr", { enumerable: true, get: function () { return partial_js_1.yerr; } });
+Object.defineProperty(exports, "yres", { enumerable: true, get: function () { return partial_js_1.yres; } });
+Object.defineProperty(exports, "yresAsync", { enumerable: true, get: function () { return partial_js_1.yresAsync; } });
+Object.defineProperty(exports, "yresSync", { enumerable: true, get: function () { return partial_js_1.yresSync; } });
+Object.defineProperty(exports, "yep", { enumerable: true, get: function () { return partial_js_1.yep; } });
+Object.defineProperty(exports, "YOK", { enumerable: true, get: function () { return partial_js_1.YOK; } });
+Object.defineProperty(exports, "YOK_NULL", { enumerable: true, get: function () { return partial_js_1.YOK_NULL; } });
+Object.defineProperty(exports, "YOK_TRUE", { enumerable: true, get: function () { return partial_js_1.YOK_TRUE; } });
+Object.defineProperty(exports, "YOK_FALSE", { enumerable: true, get: function () { return partial_js_1.YOK_FALSE; } });
+var result_js_1 = require("./result.cjs");
+Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return result_js_1.ok; } });
+Object.defineProperty(exports, "err", { enumerable: true, get: function () { return result_js_1.err; } });
+Object.defineProperty(exports, "OK", { enumerable: true, get: function () { return result_js_1.OK; } });
+Object.defineProperty(exports, "OK_NULL", { enumerable: true, get: function () { return result_js_1.OK_NULL; } });
+Object.defineProperty(exports, "OK_TRUE", { enumerable: true, get: function () { return result_js_1.OK_TRUE; } });
+Object.defineProperty(exports, "OK_FALSE", { enumerable: true, get: function () { return result_js_1.OK_FALSE; } });
+var stringify_error_js_1 = require("./stringify-error.cjs");
+Object.defineProperty(exports, "stringifyError", { enumerable: true, get: function () { return stringify_error_js_1.stringifyError; } });
+var try_js_1 = require("./try.cjs");
+Object.defineProperty(exports, "xtry", { enumerable: true, get: function () { return try_js_1.xtry; } });
+Object.defineProperty(exports, "xtryAsync", { enumerable: true, get: function () { return try_js_1.xtryAsync; } });
+Object.defineProperty(exports, "xtrySync", { enumerable: true, get: function () { return try_js_1.xtrySync; } });

package/lib/cjs/index.d.cts

@@ -0,0 +1,7 @@
+export { xdefer, xdeferAsync, xdeferSync } from './defer.cjs';
+export type { YResult, YSuccess, YFailure } from './partial.cjs';
+export { yok, yerr, yres, yresAsync, yresSync, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.cjs';
+export type { Success, Failure, Result } from './result.cjs';
+export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.cjs';
+export { stringifyError } from './stringify-error.cjs';
+export { xtry, xtryAsync, xtrySync } from './try.cjs';

package/lib/cjs/partial.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YOK_FALSE = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK = void 0;
+exports.yok = yok;
+exports.yerr = yerr;
+exports.yres = yres;
+exports.yresSync = yresSync;
+exports.yresAsync = yresAsync;
+exports.yep = yep;
+const is_promise_like_js_1 = require("./utils/is-promise-like.cjs");
+function yok(value) {
+    return {
+        fails: false,
+        success: true,
+        value: value,
+        error: undefined,
+    };
+}
+function yerr(miscue) {
+    return {
+        fails: false,
+        success: false,
+        miscue,
+        value: undefined,
+        error: undefined,
+    };
+}
+function yres(result) {
+    if ((0, is_promise_like_js_1.isPromiseLike)(result)) {
+        return result.then(yresSync);
+    }
+    return yresSync(result);
+}
+function yresSync(result) {
+    if (result.fails) {
+        return result;
+    }
+    return yep(result);
+}
+async function yresAsync(promise) {
+    return promise.then(yresSync);
+}
+function yep(result) {
+    return {
+        ...result,
+        success: true,
+    };
+}
+exports.YOK = Object.freeze(yok());
+exports.YOK_NULL = Object.freeze(yok(null));
+exports.YOK_TRUE = Object.freeze(yok(true));
+exports.YOK_FALSE = Object.freeze(yok(false));

package/lib/cjs/partial.d.cts

@@ -0,0 +1,27 @@
+import { type Result, type Failure, type Success } from './result.cjs';
+import { type NotPromise } from './utils/types.cjs';
+export type YResult<T, E, M> = Failure<E> | YSuccess<T> | YFailure<M>;
+export type YSuccess<T> = Success<T> & {
+    success: true;
+};
+export type YFailure<M> = {
+    fails: false;
+    success: false;
+    miscue: M;
+    value: undefined;
+    error: undefined;
+};
+export declare function yok(): YSuccess<void>;
+export declare function yok<T>(value: T): YSuccess<T>;
+export declare function yerr<M>(miscue: M): YFailure<M>;
+type YRResult<T, E> = Failure<E> | YSuccess<T>;
+export declare function yres<T, E>(result: NotPromise<Result<T, E>>): YRResult<T, E>;
+export declare function yres<T, E>(result: Promise<Result<T, E>>): Promise<YRResult<T, E>>;
+export declare function yresSync<T, E>(result: NotPromise<Result<T, E>>): YRResult<T, E>;
+export declare function yresAsync<T, E>(promise: Promise<Result<T, E>>): Promise<YRResult<T, E>>;
+export declare function yep<T>(result: Success<T>): YSuccess<T>;
+export declare const YOK: Readonly<YSuccess<void>>;
+export declare const YOK_NULL: Readonly<YSuccess<null>>;
+export declare const YOK_TRUE: Readonly<YSuccess<boolean>>;
+export declare const YOK_FALSE: Readonly<YSuccess<boolean>>;
+export {};

package/lib/cjs/result.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OK_FALSE = exports.OK_TRUE = exports.OK_NULL = exports.OK = void 0;
+exports.ok = ok;
+exports.err = err;
+function ok(value) {
+    return {
+        fails: false,
+        value: value,
+        error: undefined,
+    };
+}
+function err(error) {
+    return {
+        fails: true,
+        value: undefined,
+        error,
+    };
+}
+exports.OK = Object.freeze(ok());
+exports.OK_NULL = Object.freeze(ok(null));
+exports.OK_TRUE = Object.freeze(ok(true));
+exports.OK_FALSE = Object.freeze(ok(false));

package/lib/cjs/result.d.cts

@@ -0,0 +1,18 @@
+export type Success<T> = {
+    fails: false;
+    value: T;
+    error: undefined;
+};
+export type Failure<E> = {
+    fails: true;
+    value: undefined;
+    error: E;
+};
+export type Result<T, E> = Success<T> | Failure<E>;
+export declare function ok(): Success<void>;
+export declare function ok<T>(value: T): Success<T>;
+export declare function err<E>(error: E): Failure<E>;
+export declare const OK: Readonly<Success<void>>;
+export declare const OK_NULL: Readonly<Success<null>>;
+export declare const OK_TRUE: Readonly<Success<boolean>>;
+export declare const OK_FALSE: Readonly<Success<boolean>>;

package/lib/cjs/stringify-error.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyError = stringifyError;
+function stringifyError(error) {
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error instanceof Error) {
+        return error.message ?? String(error);
+    }
+    try {
+        const json = JSON.stringify(error);
+        if (typeof json === 'string') {
+            return json;
+        }
+    }
+    catch {
+        // fallthrough
+    }
+    return String(error);
+}

package/lib/cjs/stringify-error.d.cts

@@ -0,0 +1 @@
+export declare function stringifyError(error: unknown): string;

package/lib/cjs/sync.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xtry = exports.stringifyError = exports.OK_FALSE = exports.OK_TRUE = exports.OK_NULL = exports.OK = exports.err = exports.ok = exports.YOK_FALSE = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK = exports.yep = exports.yres = exports.yerr = exports.yok = exports.xdefer = void 0;
+var defer_js_1 = require("./defer.cjs");
+Object.defineProperty(exports, "xdefer", { enumerable: true, get: function () { return defer_js_1.xdeferSync; } });
+var partial_js_1 = require("./partial.cjs");
+Object.defineProperty(exports, "yok", { enumerable: true, get: function () { return partial_js_1.yok; } });
+Object.defineProperty(exports, "yerr", { enumerable: true, get: function () { return partial_js_1.yerr; } });
+Object.defineProperty(exports, "yres", { enumerable: true, get: function () { return partial_js_1.yresSync; } });
+Object.defineProperty(exports, "yep", { enumerable: true, get: function () { return partial_js_1.yep; } });
+Object.defineProperty(exports, "YOK", { enumerable: true, get: function () { return partial_js_1.YOK; } });
+Object.defineProperty(exports, "YOK_NULL", { enumerable: true, get: function () { return partial_js_1.YOK_NULL; } });
+Object.defineProperty(exports, "YOK_TRUE", { enumerable: true, get: function () { return partial_js_1.YOK_TRUE; } });
+Object.defineProperty(exports, "YOK_FALSE", { enumerable: true, get: function () { return partial_js_1.YOK_FALSE; } });
+var result_js_1 = require("./result.cjs");
+Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return result_js_1.ok; } });
+Object.defineProperty(exports, "err", { enumerable: true, get: function () { return result_js_1.err; } });
+Object.defineProperty(exports, "OK", { enumerable: true, get: function () { return result_js_1.OK; } });
+Object.defineProperty(exports, "OK_NULL", { enumerable: true, get: function () { return result_js_1.OK_NULL; } });
+Object.defineProperty(exports, "OK_TRUE", { enumerable: true, get: function () { return result_js_1.OK_TRUE; } });
+Object.defineProperty(exports, "OK_FALSE", { enumerable: true, get: function () { return result_js_1.OK_FALSE; } });
+var stringify_error_js_1 = require("./stringify-error.cjs");
+Object.defineProperty(exports, "stringifyError", { enumerable: true, get: function () { return stringify_error_js_1.stringifyError; } });
+var try_js_1 = require("./try.cjs");
+Object.defineProperty(exports, "xtry", { enumerable: true, get: function () { return try_js_1.xtrySync; } });

package/lib/cjs/sync.d.cts

@@ -0,0 +1,7 @@
+export { xdeferSync as xdefer } from './defer.cjs';
+export type { YResult, YSuccess, YFailure } from './partial.cjs';
+export { yok, yerr, yresSync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.cjs';
+export type { Success, Failure, Result } from './result.cjs';
+export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.cjs';
+export { stringifyError } from './stringify-error.cjs';
+export { xtrySync as xtry } from './try.cjs';

package/lib/cjs/try.cjs

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xtry = xtry;
+exports.xtrySync = xtrySync;
+exports.xtryAsync = xtryAsync;
+const result_js_1 = require("./result.cjs");
+const is_promise_like_js_1 = require("./utils/is-promise-like.cjs");
+function xtry(func, handler) {
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    const run = func instanceof Function ? func : () => func;
+    const handleError = (error) => {
+        if (handler) {
+            const newError = handler(error);
+            if (newError !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return (0, result_js_1.err)(newError);
+            }
+        }
+        return (0, result_js_1.err)(error);
+    };
+    const handleSuccess = (value) => (0, result_js_1.ok)(value);
+    try {
+        const value = run();
+        if ((0, is_promise_like_js_1.isPromiseLike)(value)) {
+            return Promise.resolve(value).then(handleSuccess, handleError);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return (0, result_js_1.ok)(value);
+    }
+    catch (error) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return handleError(error);
+    }
+}
+function xtrySync(func, handler) {
+    try {
+        const value = func();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return (0, result_js_1.ok)(value);
+    }
+    catch (error) {
+        if (handler) {
+            const newError = handler(error);
+            if (newError !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return (0, result_js_1.err)(newError);
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return (0, result_js_1.err)(error);
+    }
+}
+async function xtryAsync(func, handler) {
+    try {
+        const value = await (func instanceof Promise ? func : Promise.resolve().then(func));
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return (0, result_js_1.ok)(value);
+    }
+    catch (error) {
+        if (handler) {
+            const newError = handler(error);
+            if (newError !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return (0, result_js_1.err)(newError);
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return (0, result_js_1.err)(error);
+    }
+}

package/lib/cjs/try.d.cts

@@ -0,0 +1,9 @@
+import { type Result } from './result.cjs';
+import { type NonPromiseCallback, type PromiseCallback } from './utils/types.cjs';
+type ErrorHandler<T> = (error: unknown) => T | undefined;
+type VoidableResult<T, E> = E extends void ? Result<T, unknown> : Result<T, E>;
+export declare function xtry<T, E = unknown>(func: NonPromiseCallback<T>, handler?: ErrorHandler<E>): VoidableResult<T, E>;
+export declare function xtry<T, E = unknown>(func: PromiseCallback<T>, handler?: ErrorHandler<E>): Promise<VoidableResult<T, E>>;
+export declare function xtrySync<T, E = unknown>(func: NonPromiseCallback<T>, handler?: ErrorHandler<E>): VoidableResult<T, E>;
+export declare function xtryAsync<T, E = unknown>(func: PromiseCallback<T>, handler?: ErrorHandler<E>): Promise<VoidableResult<T, E>>;
+export {};

package/lib/cjs/utils/is-promise-like.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromiseLike = isPromiseLike;
+function isPromiseLike(value) {
+    return typeof value === 'object' && value !== null && typeof value.then === 'function';
+}

package/lib/cjs/utils/is-promise-like.d.cts

@@ -0,0 +1,3 @@
+type MaybePromise<T> = T | PromiseLike<T>;
+export declare function isPromiseLike<T>(value: MaybePromise<T>): value is PromiseLike<T>;
+export {};

package/lib/cjs/utils/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/utils/types.d.cts

@@ -0,0 +1,5 @@
+export type NotPromise<T> = Exclude<T, Promise<unknown>>;
+export type NonPromiseCallback<T> = () => NotPromise<T>;
+export type PromiseCallback<T> = (() => Promise<T>) | Promise<T>;
+export type Callback<T> = NonPromiseCallback<T> | PromiseCallback<T>;
+export type MaybePromise<T> = T | Promise<T>;

package/lib/esm/async.d.mts

@@ -0,0 +1,7 @@
+export { xdeferAsync as xdefer } from './defer.mjs';
+export type { YResult, YSuccess, YFailure } from './partial.mjs';
+export { yok, yerr, yresAsync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
+export type { Success, Failure, Result } from './result.mjs';
+export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.mjs';
+export { stringifyError } from './stringify-error.mjs';
+export { xtryAsync as xtry } from './try.mjs';

package/lib/esm/async.mjs

@@ -0,0 +1,5 @@
+export { xdeferAsync as xdefer } from './defer.mjs';
+export { yok, yerr, yresAsync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
+export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.mjs';
+export { stringifyError } from './stringify-error.mjs';
+export { xtryAsync as xtry } from './try.mjs';

package/lib/esm/defer.d.mts

@@ -0,0 +1,19 @@
+import { type Failure, type Result, type Success } from './result.mjs';
+import { type NonPromiseCallback, type PromiseCallback } from './utils/types.mjs';
+type DeferAsync<E> = {
+    (): Promise<Success<void>>;
+    <T>(result: Success<T>): Promise<Result<T, E>>;
+    <F>(result: Failure<F>): Promise<Failure<F>>;
+    <T, F>(result: Result<T, F>): Promise<Result<T, E | F>>;
+};
+type DeferSync<E> = {
+    (): Success<void>;
+    <T>(result: Success<T>): Result<T, E>;
+    <F>(result: Failure<F>): Failure<F>;
+    <T, F>(result: Result<T, F>): Result<T, E | F>;
+};
+export declare function xdefer<E>(callback: NonPromiseCallback<Result<unknown, E>>): DeferSync<E>;
+export declare function xdefer<E>(callback: PromiseCallback<Result<unknown, E>>): DeferAsync<E>;
+export declare function xdeferAsync<E>(callback: PromiseCallback<Result<unknown, E>>): DeferAsync<E>;
+export declare function xdeferSync<E>(callback: NonPromiseCallback<Result<unknown, E>>): DeferSync<E>;
+export {};

package/lib/esm/defer.mjs

@@ -0,0 +1,45 @@
+import { ok } from './result.mjs';
+import { isPromiseLike } from './utils/is-promise-like.mjs';
+export function xdefer(callback) {
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    return ((result) => {
+        const finalize = (deferResult) => {
+            if (deferResult.fails) {
+                if ((result)?.fails) {
+                    return result;
+                }
+                return deferResult;
+            }
+            return (result) ?? ok();
+        };
+        const deferredValue = callback instanceof Function ? callback() : callback;
+        if (isPromiseLike(deferredValue)) {
+            return Promise.resolve(deferredValue).then(finalize);
+        }
+        return finalize(deferredValue);
+    });
+}
+export function xdeferAsync(callback) {
+    return (async (result) => {
+        const deferResult = await (callback instanceof Promise ? callback : callback());
+        if (deferResult.fails) {
+            if (result?.fails) {
+                return result;
+            }
+            return deferResult;
+        }
+        return result ?? ok();
+    });
+}
+export function xdeferSync(callback) {
+    return ((result) => {
+        const deferResult = callback();
+        if (deferResult.fails) {
+            if (result?.fails) {
+                return result;
+            }
+            return deferResult;
+        }
+        return result ?? ok();
+    });
+}

package/lib/esm/index.d.mts

@@ -0,0 +1,7 @@
+export { xdefer, xdeferAsync, xdeferSync } from './defer.mjs';
+export type { YResult, YSuccess, YFailure } from './partial.mjs';
+export { yok, yerr, yres, yresAsync, yresSync, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
+export type { Success, Failure, Result } from './result.mjs';
+export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.mjs';
+export { stringifyError } from './stringify-error.mjs';
+export { xtry, xtryAsync, xtrySync } from './try.mjs';

package/lib/esm/index.mjs

@@ -0,0 +1,5 @@
+export { xdefer, xdeferAsync, xdeferSync } from './defer.mjs';
+export { yok, yerr, yres, yresAsync, yresSync, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
+export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.mjs';
+export { stringifyError } from './stringify-error.mjs';
+export { xtry, xtryAsync, xtrySync } from './try.mjs';

package/lib/esm/partial.d.mts

@@ -0,0 +1,27 @@
+import { type Result, type Failure, type Success } from './result.mjs';
+import { type NotPromise } from './utils/types.mjs';
+export type YResult<T, E, M> = Failure<E> | YSuccess<T> | YFailure<M>;
+export type YSuccess<T> = Success<T> & {
+    success: true;
+};
+export type YFailure<M> = {
+    fails: false;
+    success: false;
+    miscue: M;
+    value: undefined;
+    error: undefined;
+};
+export declare function yok(): YSuccess<void>;
+export declare function yok<T>(value: T): YSuccess<T>;
+export declare function yerr<M>(miscue: M): YFailure<M>;
+type YRResult<T, E> = Failure<E> | YSuccess<T>;
+export declare function yres<T, E>(result: NotPromise<Result<T, E>>): YRResult<T, E>;
+export declare function yres<T, E>(result: Promise<Result<T, E>>): Promise<YRResult<T, E>>;
+export declare function yresSync<T, E>(result: NotPromise<Result<T, E>>): YRResult<T, E>;
+export declare function yresAsync<T, E>(promise: Promise<Result<T, E>>): Promise<YRResult<T, E>>;
+export declare function yep<T>(result: Success<T>): YSuccess<T>;
+export declare const YOK: Readonly<YSuccess<void>>;
+export declare const YOK_NULL: Readonly<YSuccess<null>>;
+export declare const YOK_TRUE: Readonly<YSuccess<boolean>>;
+export declare const YOK_FALSE: Readonly<YSuccess<boolean>>;
+export {};