@zokugun/xtry 0.6.0 → 0.6.2

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/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 };

package/lib/esm/partial.js

@@ -1,43 +1,44 @@
-import { isPromiseLike } from './utils/is-promise-like.js';
-export function yok(value) {
-    return {
-        fails: false,
-        success: true,
-        value: value,
-        error: undefined,
-    };
+import { isPromiseLike } from "./utils/is-promise-like.js";
+
+//#region src/partial.ts
+function yok(value) {
+	return {
+		fails: false,
+		success: true,
+		value,
+		error: void 0
+	};
 }
-export function yerr(miscue) {
-    return {
-        fails: false,
-        success: false,
-        miscue,
-        value: undefined,
-        error: undefined,
-    };
+function yerr(miscue) {
+	return {
+		fails: false,
+		success: false,
+		miscue,
+		value: void 0,
+		error: void 0
+	};
 }
-export function yres(result) {
-    if (isPromiseLike(result)) {
-        return result.then(yresSync);
-    }
-    return yresSync(result);
+function yres(result) {
+	if (isPromiseLike(result)) return result.then(yresSync);
+	return yresSync(result);
 }
-export function yresSync(result) {
-    if (result.fails) {
-        return result;
-    }
-    return yep(result);
+function yresSync(result) {
+	if (result.fails) return result;
+	return yep(result);
 }
-export async function yresAsync(promise) {
-    return promise.then(yresSync);
+async function yresAsync(promise) {
+	return promise.then(yresSync);
 }
-export function yep(result) {
-    return {
-        ...result,
-        success: true,
-    };
+function yep(result) {
+	return {
+		...result,
+		success: true
+	};
 }
-export const YOK = Object.freeze(yok());
-export const YOK_NULL = Object.freeze(yok(null));
-export const YOK_TRUE = Object.freeze(yok(true));
-export const YOK_FALSE = Object.freeze(yok(false));
+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
+export { YOK, YOK_FALSE, YOK_NULL, YOK_TRUE, yep, yerr, yok, yres, yresAsync, yresSync };

package/lib/esm/result.d.ts

@@ -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 as OK$1, OK_FALSE as OK_FALSE$1, OK_NULL as OK_NULL$1, OK_TRUE as OK_TRUE$1, Result, Success, err as err$1, ok as ok$1 };

package/lib/esm/result.js

@@ -1,18 +1,22 @@
-export function ok(value) {
-    return {
-        fails: false,
-        value: value,
-        error: undefined,
-    };
+//#region src/result.ts
+function ok(value) {
+	return {
+		fails: false,
+		value,
+		error: void 0
+	};
 }
-export function err(error) {
-    return {
-        fails: true,
-        value: undefined,
-        error,
-    };
+function err(error) {
+	return {
+		fails: true,
+		value: void 0,
+		error
+	};
 }
-export const OK = Object.freeze(ok());
-export const OK_NULL = Object.freeze(ok(null));
-export const OK_TRUE = Object.freeze(ok(true));
-export const OK_FALSE = Object.freeze(ok(false));
+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
+export { OK, OK_FALSE, OK_NULL, OK_TRUE, err, ok };

package/lib/esm/stringify-error.d.ts

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

package/lib/esm/stringify-error.js

@@ -1,18 +1,13 @@
-export 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);
+//#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
+export { stringifyError };

package/lib/esm/sync.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 { 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, yresSync$1 as yresSync } from "./partial.js";
+import { stringifyError$1 as stringifyError } from "./stringify-error.js";
+import { 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, xdeferSync as xdefer, xtrySync as xtry, yep, yerr, yok, yresSync as yres };

package/lib/esm/sync.js

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

package/lib/esm/try.d.ts

@@ -0,0 +1,12 @@
+import { Result } from "./result.js";
+import { NonPromiseCallback, PromiseCallback } from "./utils/types.js";
+
+//#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 as xtry$1, xtryAsync as xtryAsync$1, xtrySync as xtrySync$1 };

package/lib/esm/try.js

@@ -1,65 +1,49 @@
-import { err, ok } from './result.js';
-import { isPromiseLike } from './utils/is-promise-like.js';
-export 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 err(newError);
-            }
-        }
-        return err(error);
-    };
-    const handleSuccess = (value) => ok(value);
-    try {
-        const value = run();
-        if (isPromiseLike(value)) {
-            return Promise.resolve(value).then(handleSuccess, handleError);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return ok(value);
-    }
-    catch (error) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return handleError(error);
-    }
+import { err, ok } from "./result.js";
+import { isPromiseLike } from "./utils/is-promise-like.js";
+
+//#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 err(newError);
+		}
+		return err(error);
+	};
+	const handleSuccess = (value) => ok(value);
+	try {
+		const value = run();
+		if (isPromiseLike(value)) return Promise.resolve(value).then(handleSuccess, handleError);
+		return ok(value);
+	} catch (error) {
+		return handleError(error);
+	}
 }
-export function xtrySync(func, handler) {
-    try {
-        const value = func();
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return ok(value);
-    }
-    catch (error) {
-        if (handler) {
-            const newError = handler(error);
-            if (newError !== undefined) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return err(newError);
-            }
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return err(error);
-    }
+function xtrySync(func, handler) {
+	try {
+		const value = func();
+		return ok(value);
+	} catch (error) {
+		if (handler) {
+			const newError = handler(error);
+			if (newError !== void 0) return err(newError);
+		}
+		return err(error);
+	}
 }
-export 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 ok(value);
-    }
-    catch (error) {
-        if (handler) {
-            const newError = handler(error);
-            if (newError !== undefined) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return err(newError);
-            }
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return err(error);
-    }
+async function xtryAsync(func, handler) {
+	try {
+		const value = await (func instanceof Promise ? func : Promise.resolve().then(func));
+		return ok(value);
+	} catch (error) {
+		if (handler) {
+			const newError = handler(error);
+			if (newError !== void 0) return err(newError);
+		}
+		return err(error);
+	}
 }
+
+//#endregion
+export { xtry, xtryAsync, xtrySync };

package/lib/esm/utils/is-promise-like.js

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

package/lib/esm/utils/types.d.ts

@@ -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/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@zokugun/xtry",
 	"description": "simple try/catch wrapper returning Result",
-	"version": "0.6.0",
+	"version": "0.6.2",
 	"author": {
 		"name": "Baptiste Augrain",
 		"email": "daiyam@zokugun.org"
@@ -18,54 +18,37 @@
 	"type": "module",
 	"exports": {
 		".": {
-			"types": "./lib/types/index.d.ts",
 			"import": "./lib/esm/index.js",
-			"require": "./lib/cjs/index.js",
+			"require": "./lib/cjs/index.cjs",
 			"default": "./lib/esm/index.js"
 		},
 		"./async": {
-			"types": "./lib/types/async.d.ts",
 			"import": "./lib/esm/async.js",
-			"require": "./lib/cjs/async.js",
+			"require": "./lib/cjs/async.cjs",
 			"default": "./lib/esm/async.js"
 		},
 		"./sync": {
-			"types": "./lib/types/sync.d.ts",
 			"import": "./lib/esm/sync.js",
-			"require": "./lib/cjs/sync.js",
+			"require": "./lib/cjs/sync.cjs",
 			"default": "./lib/esm/sync.js"
 		}
 	},
-	"main": "lib/cjs/index.js",
+	"main": "lib/cjs/index.cjs",
 	"module": "lib/esm/index.js",
-	"types": "lib/types/index.d.ts",
-	"typesVersions": {
-		"*": {
-			"async": [
-				"./lib/types/async.d.ts"
-			],
-			"sync": [
-				"./lib/types/sync.d.ts"
-			]
-		}
-	},
 	"scripts": {
-		"build": "npm run clean && npm run build:cjs && npm run build:esm",
-		"build:cjs": "tsc -p src/tsconfig.cjs.json",
-		"build:esm": "tsc -p src/tsconfig.json",
+		"build": "tsdown",
 		"clean": "rimraf lib .test",
 		"commit": "cz",
-		"compile": "tsc -p src",
+		"compile": "tsc -p src/tsconfig.json",
 		"lint": "xo",
 		"lint:fix": "xo --fix",
 		"prepare": "husky; fixpack || true",
-		"prepublishOnly": "npm run compile",
+		"prepublishOnly": "npm run build",
 		"release": "release-it",
 		"test": "vitest run",
 		"watch:source": "tsc-watch -p src",
 		"watch:test": "vitest"
 	},
-	"dependencies": {},
 	"devDependencies": {
 		"@commitlint/cli": "^19.7.1",
 		"@commitlint/config-conventional": "^19.7.1",
@@ -79,6 +62,7 @@
 		"lint-staged": "^16.1.4",
 		"release-it": "^18.1.2",
 		"tsc-watch": "^6.3.0",
+		"tsdown": "^0.12.9",
 		"typescript": "^5.7.3",
 		"vitest": "^4.0.16",
 		"xo": "0.60.0"

package/lib/esm/utils/types.js

@@ -1 +0,0 @@
-export {};

package/lib/types/async.d.ts

@@ -1,7 +0,0 @@
-export { xdeferAsync as xdefer } from './defer.js';
-export type { YResult, YSuccess, YFailure } from './partial.js';
-export { yok, yerr, yresAsync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.js';
-export type { Success, Failure, Result } from './result.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';

package/lib/types/defer.d.ts

@@ -1,16 +0,0 @@
-import { type Result, type Success } from './result.js';
-import { type NonPromiseCallback, type PromiseCallback } from './utils/types.js';
-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>;
-export declare function xdefer<E>(callback: NonPromiseCallback<UnknownResult<E>>): DeferSync<E>;
-export declare function xdefer<E>(callback: PromiseCallback<UnknownResult<E>>): DeferAsync<E>;
-export declare function xdeferAsync<E>(callback: PromiseCallback<UnknownResult<E>>): DeferAsync<E>;
-export declare function xdeferSync<E>(callback: NonPromiseCallback<UnknownResult<E>>): DeferSync<E>;
-export {};

package/lib/types/index.d.ts

@@ -1,7 +0,0 @@
-export { xdefer, xdeferAsync, xdeferSync } from './defer.js';
-export type { YResult, YSuccess, YFailure } from './partial.js';
-export { yok, yerr, yres, yresAsync, yresSync, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.js';
-export type { Success, Failure, Result } from './result.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';

package/lib/types/partial.d.ts

@@ -1,27 +0,0 @@
-import { type Result, type Failure, type Success } from './result.js';
-import { type NotPromise } from './utils/types.js';
-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/types/result.d.ts

@@ -1,18 +0,0 @@
-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/types/stringify-error.d.ts

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

package/lib/types/sync.d.ts

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

package/lib/types/try.d.ts

@@ -1,9 +0,0 @@
-import { type Result } from './result.js';
-import { type NonPromiseCallback, type PromiseCallback } from './utils/types.js';
-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/types/utils/is-promise-like.d.ts

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

package/lib/types/utils/types.d.ts

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