@zokugun/xtry 0.6.1 → 0.6.3

package/lib/cjs/async.cjs

@@ -0,0 +1,23 @@
+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.xdeferAsync;
+exports.xtry = require__home_runner_work_node_xtry_node_xtry_src_try.xtryAsync;
+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.yresAsync;

package/lib/cjs/async.d.cts

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

package/lib/cjs/defer.cjs

@@ -0,0 +1,43 @@
+const require__home_runner_work_node_xtry_node_xtry_src_result = require('./result.cjs');
+const require__home_runner_work_node_xtry_node_xtry_src_utils_is_promise_like = require('./utils/is-promise-like.cjs');
+
+//#region src/defer.ts
+function xdefer(callback) {
+	return (result) => {
+		const finalize = (deferResult) => {
+			if (deferResult.fails) {
+				if (result?.fails) return result;
+				return deferResult;
+			}
+			return result ?? require__home_runner_work_node_xtry_node_xtry_src_result.ok();
+		};
+		const deferredValue = callback instanceof Function ? callback() : callback;
+		if (require__home_runner_work_node_xtry_node_xtry_src_utils_is_promise_like.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 ?? require__home_runner_work_node_xtry_node_xtry_src_result.ok();
+	};
+}
+function xdeferSync(callback) {
+	return (result) => {
+		const deferResult = callback();
+		if (deferResult.fails) {
+			if (result?.fails) return result;
+			return deferResult;
+		}
+		return result ?? require__home_runner_work_node_xtry_node_xtry_src_result.ok();
+	};
+}
+
+//#endregion
+exports.xdefer = xdefer;
+exports.xdeferAsync = xdeferAsync;
+exports.xdeferSync = xdeferSync;

package/lib/cjs/defer.d.cts

@@ -0,0 +1,19 @@
+import { Result, Success } from "./result.cjs";
+import { NonPromiseCallback, PromiseCallback } from "./utils/types.cjs";
+
+//#region src/defer.d.ts
+type DeferAsync<E> = {
+  (): Promise<Success<void>>;
+  (result: UnknownResult<E>): Promise<UnknownResult<E>>;
+};
+type DeferSync<E> = {
+  (): Success<void>;
+  (result: UnknownResult<E>): UnknownResult<E>;
+};
+type UnknownResult<E> = Result<unknown, E>;
+declare function xdefer<E>(callback: NonPromiseCallback<UnknownResult<E>>): DeferSync<E>;
+declare function xdefer<E>(callback: PromiseCallback<UnknownResult<E>>): DeferAsync<E>;
+declare function xdeferAsync<E>(callback: PromiseCallback<UnknownResult<E>>): DeferAsync<E>;
+declare function xdeferSync<E>(callback: NonPromiseCallback<UnknownResult<E>>): DeferSync<E>;
+//#endregion
+export { xdefer, xdeferAsync, xdeferSync };

package/lib/cjs/index.cjs

@@ -0,0 +1,29 @@
+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;

package/lib/cjs/index.d.cts

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

package/lib/cjs/partial.cjs

@@ -0,0 +1,53 @@
+const require__home_runner_work_node_xtry_node_xtry_src_utils_is_promise_like = require('./utils/is-promise-like.cjs');
+
+//#region src/partial.ts
+function yok(value) {
+	return {
+		fails: false,
+		success: true,
+		value,
+		error: void 0
+	};
+}
+function yerr(miscue) {
+	return {
+		fails: false,
+		success: false,
+		miscue,
+		value: void 0,
+		error: void 0
+	};
+}
+function yres(result) {
+	if (require__home_runner_work_node_xtry_node_xtry_src_utils_is_promise_like.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
+	};
+}
+const YOK = Object.freeze(yok());
+const YOK_NULL = Object.freeze(yok(null));
+const YOK_TRUE = Object.freeze(yok(true));
+const YOK_FALSE = Object.freeze(yok(false));
+
+//#endregion
+exports.YOK = YOK;
+exports.YOK_FALSE = YOK_FALSE;
+exports.YOK_NULL = YOK_NULL;
+exports.YOK_TRUE = YOK_TRUE;
+exports.yep = yep;
+exports.yerr = yerr;
+exports.yok = yok;
+exports.yres = yres;
+exports.yresAsync = yresAsync;
+exports.yresSync = yresSync;

package/lib/cjs/partial.d.cts

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

package/lib/cjs/result.cjs

@@ -0,0 +1,28 @@
+
+//#region src/result.ts
+function ok(value) {
+	return {
+		fails: false,
+		value,
+		error: void 0
+	};
+}
+function err(error) {
+	return {
+		fails: true,
+		value: void 0,
+		error
+	};
+}
+const OK = Object.freeze(ok());
+const OK_NULL = Object.freeze(ok(null));
+const OK_TRUE = Object.freeze(ok(true));
+const OK_FALSE = Object.freeze(ok(false));
+
+//#endregion
+exports.OK = OK;
+exports.OK_FALSE = OK_FALSE;
+exports.OK_NULL = OK_NULL;
+exports.OK_TRUE = OK_TRUE;
+exports.err = err;
+exports.ok = ok;

package/lib/cjs/result.d.cts

@@ -0,0 +1,21 @@
+//#region src/result.d.ts
+type Success<T> = {
+  fails: false;
+  value: T;
+  error: undefined;
+};
+type Failure<E> = {
+  fails: true;
+  value: undefined;
+  error: E;
+};
+type Result<T, E> = Success<T> | Failure<E>;
+declare function ok(): Success<void>;
+declare function ok<T>(value: T): Success<T>;
+declare function err<E>(error: E): Failure<E>;
+declare const OK: Readonly<Success<void>>;
+declare const OK_NULL: Readonly<Success<any>>;
+declare const OK_TRUE: Readonly<Success<boolean>>;
+declare const OK_FALSE: Readonly<Success<boolean>>;
+//#endregion
+export { Failure, OK, OK_FALSE, OK_NULL, OK_TRUE, Result, Success, err, ok };

package/lib/cjs/stringify-error.cjs

@@ -0,0 +1,14 @@
+
+//#region src/stringify-error.ts
+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 {}
+	return String(error);
+}
+
+//#endregion
+exports.stringifyError = stringifyError;

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

@@ -0,0 +1,4 @@
+//#region src/stringify-error.d.ts
+declare function stringifyError(error: unknown): string;
+//#endregion
+export { stringifyError };

package/lib/cjs/sync.cjs

@@ -0,0 +1,23 @@
+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.xdeferSync;
+exports.xtry = 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.yresSync;

package/lib/cjs/sync.d.cts

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

package/lib/cjs/try.cjs

@@ -0,0 +1,51 @@
+const require__home_runner_work_node_xtry_node_xtry_src_result = require('./result.cjs');
+const require__home_runner_work_node_xtry_node_xtry_src_utils_is_promise_like = require('./utils/is-promise-like.cjs');
+
+//#region src/try.ts
+function xtry(func, handler) {
+	const run = func instanceof Function ? func : () => func;
+	const handleError = (error) => {
+		if (handler) {
+			const newError = handler(error);
+			if (newError !== void 0) return require__home_runner_work_node_xtry_node_xtry_src_result.err(newError);
+		}
+		return require__home_runner_work_node_xtry_node_xtry_src_result.err(error);
+	};
+	const handleSuccess = (value) => require__home_runner_work_node_xtry_node_xtry_src_result.ok(value);
+	try {
+		const value = run();
+		if (require__home_runner_work_node_xtry_node_xtry_src_utils_is_promise_like.isPromiseLike(value)) return Promise.resolve(value).then(handleSuccess, handleError);
+		return require__home_runner_work_node_xtry_node_xtry_src_result.ok(value);
+	} catch (error) {
+		return handleError(error);
+	}
+}
+function xtrySync(func, handler) {
+	try {
+		const value = func();
+		return require__home_runner_work_node_xtry_node_xtry_src_result.ok(value);
+	} catch (error) {
+		if (handler) {
+			const newError = handler(error);
+			if (newError !== void 0) return require__home_runner_work_node_xtry_node_xtry_src_result.err(newError);
+		}
+		return require__home_runner_work_node_xtry_node_xtry_src_result.err(error);
+	}
+}
+async function xtryAsync(func, handler) {
+	try {
+		const value = await (func instanceof Promise ? func : Promise.resolve().then(func));
+		return require__home_runner_work_node_xtry_node_xtry_src_result.ok(value);
+	} catch (error) {
+		if (handler) {
+			const newError = handler(error);
+			if (newError !== void 0) return require__home_runner_work_node_xtry_node_xtry_src_result.err(newError);
+		}
+		return require__home_runner_work_node_xtry_node_xtry_src_result.err(error);
+	}
+}
+
+//#endregion
+exports.xtry = xtry;
+exports.xtryAsync = xtryAsync;
+exports.xtrySync = xtrySync;

package/lib/cjs/try.d.cts

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

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

@@ -0,0 +1,8 @@
+
+//#region src/utils/is-promise-like.ts
+function isPromiseLike(value) {
+	return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+
+//#endregion
+exports.isPromiseLike = isPromiseLike;

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

@@ -0,0 +1,6 @@
+//#region src/utils/types.d.ts
+type NotPromise<T> = Exclude<T, Promise<unknown>>;
+type NonPromiseCallback<T> = () => NotPromise<T>;
+type PromiseCallback<T> = (() => Promise<T>) | Promise<T>;
+//#endregion
+export { NonPromiseCallback, NotPromise, PromiseCallback };

package/lib/esm/async.d.ts

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

package/lib/esm/async.js

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

package/lib/esm/defer.d.ts

@@ -0,0 +1,19 @@
+import { Result, Success } from "./result.js";
+import { NonPromiseCallback, PromiseCallback } from "./utils/types.js";
+
+//#region src/defer.d.ts
+type DeferAsync<E> = {
+  (): Promise<Success<void>>;
+  (result: UnknownResult<E>): Promise<UnknownResult<E>>;
+};
+type DeferSync<E> = {
+  (): Success<void>;
+  (result: UnknownResult<E>): UnknownResult<E>;
+};
+type UnknownResult<E> = Result<unknown, E>;
+declare function xdefer<E>(callback: NonPromiseCallback<UnknownResult<E>>): DeferSync<E>;
+declare function xdefer<E>(callback: PromiseCallback<UnknownResult<E>>): DeferAsync<E>;
+declare function xdeferAsync<E>(callback: PromiseCallback<UnknownResult<E>>): DeferAsync<E>;
+declare function xdeferSync<E>(callback: NonPromiseCallback<UnknownResult<E>>): DeferSync<E>;
+//#endregion
+export { xdefer as xdefer$1, xdeferAsync as xdeferAsync$1, xdeferSync as xdeferSync$1 };

package/lib/esm/defer.js

@@ -1,45 +1,41 @@
-import { ok } from './result.js';
-import { isPromiseLike } from './utils/is-promise-like.js';
-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);
-    });
+import { ok } from "./result.js";
+import { isPromiseLike } from "./utils/is-promise-like.js";
+
+//#region src/defer.ts
+function xdefer(callback) {
+	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();
-    });
+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();
-    });
+function xdeferSync(callback) {
+	return (result) => {
+		const deferResult = callback();
+		if (deferResult.fails) {
+			if (result?.fails) return result;
+			return deferResult;
+		}
+		return result ?? ok();
+	};
 }
+
+//#endregion
+export { xdefer, xdeferAsync, xdeferSync };

package/lib/esm/index.d.ts

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

package/lib/esm/index.js

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

package/lib/esm/partial.d.ts

@@ -0,0 +1,30 @@
+import { Failure, Result, Success } from "./result.js";
+import { NotPromise } from "./utils/types.js";
+
+//#region src/partial.d.ts
+type YResult<T, E, M> = Failure<E> | YSuccess<T> | YFailure<M>;
+type YSuccess<T> = Success<T> & {
+  success: true;
+};
+type YFailure<M> = {
+  fails: false;
+  success: false;
+  miscue: M;
+  value: undefined;
+  error: undefined;
+};
+declare function yok(): YSuccess<void>;
+declare function yok<T>(value: T): YSuccess<T>;
+declare function yerr<M>(miscue: M): YFailure<M>;
+type YRResult<T, E> = Failure<E> | YSuccess<T>;
+declare function yres<T, E>(result: NotPromise<Result<T, E>>): YRResult<T, E>;
+declare function yres<T, E>(result: Promise<Result<T, E>>): Promise<YRResult<T, E>>;
+declare function yresSync<T, E>(result: NotPromise<Result<T, E>>): YRResult<T, E>;
+declare function yresAsync<T, E>(promise: Promise<Result<T, E>>): Promise<YRResult<T, E>>;
+declare function yep<T>(result: Success<T>): YSuccess<T>;
+declare const YOK: Readonly<YSuccess<void>>;
+declare const YOK_NULL: Readonly<YSuccess<any>>;
+declare const YOK_TRUE: Readonly<YSuccess<boolean>>;
+declare const YOK_FALSE: Readonly<YSuccess<boolean>>;
+//#endregion
+export { YFailure, YOK as YOK$1, YOK_FALSE as YOK_FALSE$1, YOK_NULL as YOK_NULL$1, YOK_TRUE as YOK_TRUE$1, YResult, YSuccess, yep as yep$1, yerr as yerr$1, yok as yok$1, yres as yres$1, yresAsync as yresAsync$1, yresSync as yresSync$1 };