@zokugun/xtry 0.6.3 → 0.6.4

package/lib/cjs/sync.d.cts

@@ -1,6 +1,7 @@
-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 };
+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

@@ -1,51 +1,70 @@
-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
+"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) {
-	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);
-	}
+    // 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();
-		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);
-	}
+    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));
-		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);
-	}
+    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);
+    }
 }
-
-//#endregion
-exports.xtry = xtry;
-exports.xtryAsync = xtryAsync;
-exports.xtrySync = xtrySync;

package/lib/cjs/try.d.cts

@@ -1,12 +1,9 @@
-import { Result } from "./result.cjs";
-import { NonPromiseCallback, PromiseCallback } from "./utils/types.cjs";
-
-//#region src/try.d.ts
+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>;
-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 };
+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

@@ -1,8 +1,6 @@
-
-//#region src/utils/is-promise-like.ts
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromiseLike = isPromiseLike;
 function isPromiseLike(value) {
-	return typeof value === "object" && value !== null && typeof value.then === "function";
+    return typeof value === 'object' && value !== null && typeof value.then === 'function';
 }
-
-//#endregion
-exports.isPromiseLike = isPromiseLike;

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

@@ -1,6 +1,5 @@
-//#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 };
+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 {};

package/lib/esm/partial.mjs

@@ -0,0 +1,43 @@
+import { isPromiseLike } from './utils/is-promise-like.mjs';
+export function yok(value) {
+    return {
+        fails: false,
+        success: true,
+        value: value,
+        error: undefined,
+    };
+}
+export function yerr(miscue) {
+    return {
+        fails: false,
+        success: false,
+        miscue,
+        value: undefined,
+        error: undefined,
+    };
+}
+export 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);
+}
+export async function yresAsync(promise) {
+    return promise.then(yresSync);
+}
+export 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));

package/lib/esm/result.d.mts

@@ -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/esm/result.mjs

@@ -0,0 +1,18 @@
+export function ok(value) {
+    return {
+        fails: false,
+        value: value,
+        error: undefined,
+    };
+}
+export function err(error) {
+    return {
+        fails: true,
+        value: undefined,
+        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));

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

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

package/lib/esm/stringify-error.mjs

@@ -0,0 +1,18 @@
+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);
+}

package/lib/esm/sync.d.mts

@@ -0,0 +1,7 @@
+export { xdeferSync as xdefer } from './defer.mjs';
+export type { YResult, YSuccess, YFailure } from './partial.mjs';
+export { yok, yerr, yresSync 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 { xtrySync as xtry } from './try.mjs';

package/lib/esm/sync.mjs

@@ -0,0 +1,5 @@
+export { xdeferSync as xdefer } from './defer.mjs';
+export { yok, yerr, yresSync 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 { xtrySync as xtry } from './try.mjs';

package/lib/esm/try.d.mts

@@ -0,0 +1,9 @@
+import { type Result } from './result.mjs';
+import { type NonPromiseCallback, type PromiseCallback } from './utils/types.mjs';
+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/esm/try.mjs

@@ -0,0 +1,65 @@
+import { err, ok } from './result.mjs';
+import { isPromiseLike } from './utils/is-promise-like.mjs';
+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);
+    }
+}
+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);
+    }
+}
+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);
+    }
+}

package/lib/esm/utils/is-promise-like.d.mts

@@ -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/esm/utils/is-promise-like.mjs

@@ -0,0 +1,3 @@
+export function isPromiseLike(value) {
+    return typeof value === 'object' && value !== null && typeof value.then === 'function';
+}

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

@@ -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/utils/types.mjs

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

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@zokugun/xtry",
 	"description": "simple try/catch wrapper returning Result",
-	"version": "0.6.3",
+	"version": "0.6.4",
 	"author": {
 		"name": "Baptiste Augrain",
 		"email": "daiyam@zokugun.org"
@@ -18,42 +18,58 @@
 	"type": "module",
 	"exports": {
 		".": {
-			"import": "./lib/esm/index.js",
-			"require": "./lib/cjs/index.cjs",
-			"default": "./lib/esm/index.js"
+			"import": "./lib/esm/index.mjs",
+			"require": "./lib/cjs/index.cjs"
 		},
 		"./async": {
-			"import": "./lib/esm/async.js",
-			"require": "./lib/cjs/async.cjs",
-			"default": "./lib/esm/async.js"
+			"import": "./lib/esm/async.mjs",
+			"require": "./lib/cjs/async.cjs"
 		},
 		"./sync": {
-			"import": "./lib/esm/sync.js",
-			"require": "./lib/cjs/sync.cjs",
-			"default": "./lib/esm/sync.js"
+			"import": "./lib/esm/sync.mjs",
+			"require": "./lib/cjs/sync.cjs"
 		}
 	},
 	"main": "lib/cjs/index.cjs",
-	"module": "lib/esm/index.js",
+	"module": "lib/esm/index.mjs",
+	"typesVersions": {
+		"*": {
+			".": [
+				"./lib/cjs/index.d.cts"
+			],
+			"async": [
+				"./lib/cjs/async.d.cts"
+			],
+			"sync": [
+				"./lib/cjs/sync.d.cts"
+			]
+		}
+	},
 	"scripts": {
-		"build": "tsdown",
+		"build": "npm run clean && npm run build:lib",
+		"build:lib": "tsc-leda generate",
+		"build:package": "tsc-leda update-package",
 		"clean": "rimraf lib .test",
 		"commit": "cz",
-		"compile": "tsc -p src/tsconfig.json",
+		"compile:src": "tsc -p src",
+		"compile:test": "tsc -p test",
 		"lint": "xo",
 		"lint:fix": "xo --fix",
 		"prepack": "npm run build",
 		"prepare": "husky; fixpack || true",
 		"release": "release-it",
 		"test": "vitest run",
-		"watch:source": "tsc-watch -p src",
-		"watch:test": "vitest"
+		"test:watch": "vitest",
+		"watch:src": "tsc-watch -p src",
+		"watch:test": "tsc-watch -p test"
 	},
+	"dependencies": {},
 	"devDependencies": {
 		"@commitlint/cli": "^19.7.1",
 		"@commitlint/config-conventional": "^19.7.1",
 		"@types/fs-extra": "^11.0.4",
 		"@types/node": "^20.14.8",
+		"@zokugun/tsc-leda": "^0.1.0",
 		"commitizen": "^4.3.1",
 		"fixpack": "^4.0.0",
 		"fs-extra": "^11.3.3",
@@ -62,7 +78,6 @@
 		"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/async.d.ts

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