@zokugun/xtry 0.6.3 → 0.7.0

package/lib/esm/try.d.mts

@@ -0,0 +1,17 @@
+import { type Result } from './result.mjs';
+import { type MaybePromise, type NonPromiseCallback, type PromiseCallback } from './utils/types.mjs';
+type AsyncIterableCallback<T> = (() => AsyncIterable<T>) | AsyncIterable<T>;
+type AsyncIterableResult<T, E> = AsyncIterable<VoidableResult<T, E>>;
+type ErrorHandler<T> = (error: unknown) => T | undefined;
+type SyncIterableCallback<T> = (() => Iterable<T>) | Iterable<T>;
+type SyncIterableResult<T, E> = Iterable<VoidableResult<T, E>>;
+type VoidableResult<T, E> = E extends void ? Result<T, unknown> : Result<T, E>;
+export declare function xtry<T, E = unknown>(iterable: SyncIterableCallback<T>, handler?: ErrorHandler<E>): SyncIterableResult<T, E>;
+export declare function xtry<T, E = unknown>(iterable: AsyncIterableCallback<T>, handler?: ErrorHandler<E>): AsyncIterableResult<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 declare function xtrySyncIterable<T, E = unknown>(iterable: Iterable<T> | (() => Iterable<T>), handler?: ErrorHandler<E>): Iterable<VoidableResult<T, E>>;
+export declare function xtryAsyncIterable<T, E = unknown>(iterable: AsyncIterable<T> | Promise<AsyncIterable<T>> | (() => MaybePromise<AsyncIterable<T>>), handler?: ErrorHandler<E>): AsyncIterable<VoidableResult<T, E>>;
+export {};

package/lib/esm/try.mjs

@@ -0,0 +1,122 @@
+import { err, ok } from './result.mjs';
+import { isAsyncIterable } from './utils/is-async-iterable.mjs';
+import { isPromiseLike } from './utils/is-promise-like.mjs';
+import { isSyncIterable } from './utils/is-sync-iterable.mjs';
+function handleError(handler, error) {
+    if (handler) {
+        const newError = handler(error);
+        if (newError !== undefined) {
+            return err(newError);
+        }
+    }
+    return err(error);
+} // }}}
+export function xtry(func, handler) {
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    const run = func instanceof Function ? func : () => func;
+    try {
+        const value = run();
+        if (isPromiseLike(value)) {
+            return Promise.resolve(value).then(
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            (value) => ok(value), (error) => handleError(handler, error));
+        }
+        if (isAsyncIterable(value)) {
+            return xtryAsyncIterable(value, handler);
+        }
+        if (isSyncIterable(value)) {
+            return xtrySyncIterable(value, handler);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return ok(value);
+    }
+    catch (error) {
+        return handleError(handler, error);
+    }
+} // }}}
+export function xtrySync(func, handler) {
+    try {
+        const value = func();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return ok(value);
+    }
+    catch (error) {
+        return handleError(handler, 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) {
+        return handleError(handler, error);
+    }
+} // }}}
+export function xtrySyncIterable(iterable, handler) {
+    const generator = iterable instanceof Function ? iterable : () => iterable;
+    function* iterate() {
+        let source;
+        try {
+            source = generator();
+        }
+        catch (error) {
+            yield handleError(handler, error);
+            return;
+        }
+        if (!source || typeof source[Symbol.iterator] !== 'function') {
+            yield handleError(handler, new TypeError('xtryIterable expects an Iterable'));
+            return;
+        }
+        const iterator = source[Symbol.iterator]();
+        while (true) {
+            let step;
+            try {
+                step = iterator.next();
+            }
+            catch (error) {
+                yield handleError(handler, error);
+                return;
+            }
+            if (step.done) {
+                return;
+            }
+            yield ok(step.value);
+        }
+    }
+    return iterate();
+} // }}}
+export function xtryAsyncIterable(iterable, handler) {
+    const generator = iterable instanceof Function ? iterable : async () => iterable;
+    async function* iterate() {
+        let source;
+        try {
+            source = await Promise.resolve(generator());
+        }
+        catch (error) {
+            yield handleError(handler, error);
+            return;
+        }
+        if (!source || typeof source[Symbol.asyncIterator] !== 'function') {
+            yield handleError(handler, new TypeError('xtryAsyncIterable expects an AsyncIterable'));
+            return;
+        }
+        const iterator = source[Symbol.asyncIterator]();
+        while (true) {
+            let step;
+            try {
+                step = await iterator.next();
+            }
+            catch (error) {
+                yield handleError(handler, error);
+                return;
+            }
+            if (step.done) {
+                return;
+            }
+            yield ok(step.value);
+        }
+    }
+    return iterate();
+} // }}}

package/lib/esm/utils/is-async-iterable.d.mts

@@ -0,0 +1 @@
+export declare function isAsyncIterable<T>(item: unknown): item is AsyncIterableIterator<T>;

package/lib/esm/utils/is-async-iterable.mjs

@@ -0,0 +1,3 @@
+export function isAsyncIterable(item) {
+    return item !== null && typeof item === 'object' && typeof item[Symbol.asyncIterator] === 'function';
+}

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/is-sync-iterable.d.mts

@@ -0,0 +1 @@
+export declare function isSyncIterable<T>(item: unknown): item is IterableIterator<T>;

package/lib/esm/utils/is-sync-iterable.mjs

@@ -0,0 +1,3 @@
+export function isSyncIterable(item) {
+    return item !== null && typeof item === 'object' && typeof item[Symbol.iterator] === '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.7.0",
 	"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 };

package/lib/esm/defer.d.ts

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

@@ -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 { 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,7 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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,44 +0,0 @@
-import { isPromiseLike } from "./utils/is-promise-like.js";
-
-//#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 (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
-export { YOK, YOK_FALSE, YOK_NULL, YOK_TRUE, yep, yerr, yok, yres, yresAsync, yresSync };

package/lib/esm/result.d.ts

@@ -1,21 +0,0 @@
-//#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,22 +0,0 @@
-//#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
-export { OK, OK_FALSE, OK_NULL, OK_TRUE, err, ok };

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

@@ -1,4 +0,0 @@
-//#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,13 +0,0 @@
-//#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

@@ -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 { 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,7 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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,49 +0,0 @@
-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);
-	}
-}
-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);
-	}
-}
-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,7 +0,0 @@
-//#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

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