go-go-try 4.1.2 → 6.0.0

package/LICENSE

@@ -1,6 +1,7 @@
 MIT License
 
-Copyright (c) 2022 Alisson Cavalcante Agiani thelinuxlich@gmail.com https://astoilkov.com
+Copyright (c) 2025 Alisson Cavalcante Agiani thelinuxlich@gmail.com
+Copyright (c) 2022 Antonio Stoilkov hello@astoilkov.com https://astoilkov.com
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -4,12 +4,11 @@
 
 ## Why
 
-Why not [`nice-try`](https://github.com/electerious/nice-try) with it's 70+ million downloads per month?
-
--   `go-go-try` supports async functions.
--   `go-go-try` allows you to capture the thrown error.
--   `go-go-try` is written in TypeScript. The types are written in a way that reduce developer errors.
--   `go-go-try` is inspired by Golang error catching.
+-   Supports sync/async functions.
+-   Allows you to capture the thrown error.
+-   Written in TypeScript. The types are written in a way that reduce developer errors.
+-   Inspired by Golang error catching.
+-   Zero dependencies.
 
 Why not just `try`/`catch`?
 
@@ -34,7 +33,7 @@ npm install go-go-try
 ## Usage
 
 ```ts
-import { goTry, goExpect, goTryRaw } from 'go-go-try'
+import { goTry, goTryRaw } from 'go-go-try'
 
 // tries to parse todos, returns empty array if it fails
 const [_, value = []] = goTry(() => JSON.parse(todos))
@@ -43,25 +42,26 @@ const [_, value = []] = goTry(() => JSON.parse(todos))
 const [_, todos = []] = await goTry(fetchTodos())
 
 // fetch todos, fallback to empty array, send error to your error tracking service
-const [err, todos = []] = await goTry(fetchTodos())
-sentToErrorTrackingService(err)
+const [err, todos = []] = await goTry(fetchTodos()) // err is string | undefined
+if (err) sendToErrorTrackingService(err)
 
-// if you still want the task to throw but with a optional custom message
-const value = await goExpect(() => JSON.parse('{/}', (err) => `Malformed JSON!`)) // value will be always T
+// goTry extracts the error message from the error object, if you want the raw error object, use goTryRaw
+const [err, value] = goTryRaw<Error>(() => JSON.parse('{/}')) // err will be unknown, value will be always T and you can add a Error type as the first generic argument to avoid checking `instanceof Error`
 
-// goTry and goExpect extract the error message from the error object, if you want the raw error object, use goTryRaw
-const [err, value] = await goTryRaw(() => JSON.parse('{/}')) // err will be unknown, value will be always T
+// fetch todos, fallback to empty array, send error to your error tracking service
+const [err, todos = []] = await goTryRaw<SomeErrorType>(fetchTodos()) // err is SomeErrorType | undefined
+if (err) sendToErrorTrackingService(err)
 ```
 
 ## API
 
 **First parameter** accepts:
 
--   synchronous function `goTry(() => JSON.parse(value))`
--   asynchronous function / Promise
+-   synchronous/asynchronous function / Promise
 
 **Returns** a tuple with the possible error and result (Golang style)
 
+
 If you use TypeScript, the types are well defined and won't let you make a mistake.
 
 ## Inspiration

package/dist/index.cjs

@@ -1,67 +1,57 @@
 'use strict';
 
-var pIsPromise = require('p-is-promise');
-
-function isErrorWithMessage(error) {
-  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+function isSuccess(result) {
+  return result[0] === void 0;
+}
+function isFailure(result) {
+  return result[0] !== void 0;
+}
+function success(value) {
+  return [void 0, value];
 }
-function toErrorWithMessage(maybeError) {
-  if (isErrorWithMessage(maybeError)) {
-    return maybeError;
+function failure(error) {
+  return [error, void 0];
+}
+function getErrorMessage(error) {
+  if (typeof error === "string") return error;
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
   }
   try {
-    return new Error(JSON.stringify(maybeError));
+    return JSON.stringify(error);
   } catch {
-    return new Error(String(maybeError));
+    return String(error);
   }
 }
-function getErrorMessage(error) {
-  return toErrorWithMessage(error).message;
-}
-function isPromise(p) {
-  return pIsPromise(p);
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
 }
 function goTry(value) {
-  let unwrappedValue;
+  if (isPromiseLike(value)) {
+    return Promise.resolve(value).then((value2) => success(value2)).catch((err) => failure(getErrorMessage(err)));
+  }
   try {
-    unwrappedValue = typeof value === "function" ? value() : value;
-    if (isPromise(unwrappedValue)) {
-      return Promise.resolve(unwrappedValue).then((value2) => [void 0, value2]).catch((err) => [getErrorMessage(err), void 0]);
-    }
-    return [void 0, unwrappedValue];
+    const result = typeof value === "function" ? value() : value;
+    return success(result);
   } catch (err) {
-    return [getErrorMessage(err), void 0];
+    return failure(getErrorMessage(err));
   }
 }
 function goTryRaw(value) {
-  let unwrappedValue;
-  try {
-    unwrappedValue = typeof value === "function" ? value() : value;
-    if (isPromise(unwrappedValue)) {
-      return Promise.resolve(unwrappedValue).then((value2) => [void 0, value2]).catch((err) => [err, void 0]);
-    }
-    return [void 0, unwrappedValue];
-  } catch (err) {
-    return [err, void 0];
+  if (isPromiseLike(value)) {
+    return Promise.resolve(value).then((value2) => success(value2)).catch((err) => failure(err));
   }
-}
-async function goExpect(value, error) {
-  const _error = error ?? ((e) => e);
   try {
-    const unwrappedValue = typeof value === "function" ? value() : value;
-    if (isPromise(unwrappedValue)) {
-      const [err, res] = await goTry(unwrappedValue);
-      if (err !== void 0) {
-        throw new Error(err);
-      }
-      return res;
-    }
-    return unwrappedValue;
+    const result = typeof value === "function" ? value() : value;
+    return success(result);
   } catch (err) {
-    throw new Error(_error(getErrorMessage(err)));
+    return failure(err);
   }
 }
 
-exports.goExpect = goExpect;
+exports.failure = failure;
 exports.goTry = goTry;
 exports.goTryRaw = goTryRaw;
+exports.isFailure = isFailure;
+exports.isSuccess = isSuccess;
+exports.success = success;

package/dist/index.d.cts

@@ -1,9 +1,54 @@
-type ResultTuple<T> = readonly [undefined, T] | readonly [string, undefined];
-type RawResultTuple<T, E = unknown> = readonly [undefined, T] | readonly [E, undefined];
-declare function goTry<T>(value: PromiseLike<T>): PromiseLike<ResultTuple<T>>;
-declare function goTry<T>(value: () => T): ResultTuple<T>;
-declare function goTryRaw<T, E = unknown>(value: PromiseLike<T>): PromiseLike<RawResultTuple<T, E>>;
-declare function goTryRaw<T, E = unknown>(value: () => T): RawResultTuple<T, E>;
-declare function goExpect<T>(value: (() => T) | PromiseLike<T>, error?: (err: string) => string): Promise<T>;
+/**
+ * Type for a successful result
+ */
+type Success<T> = readonly [undefined, T];
+/**
+ * Type for an error result
+ */
+type Failure<E> = readonly [E, undefined];
+/**
+ * Type for a result that can be either success or failure
+ */
+type Result<E, T> = Success<T> | Failure<E>;
+/**
+ * Type guard to check if a result is a success
+ */
+declare function isSuccess<E, T>(result: Result<E, T>): result is Success<T>;
+/**
+ * Type guard to check if a result is a failure
+ */
+declare function isFailure<E, T>(result: Result<E, T>): result is Failure<E>;
+/**
+ * Helper to create a success result
+ */
+declare function success<T>(value: T): Success<T>;
+/**
+ * Helper to create a failure result
+ */
+declare function failure<E>(error: E): Failure<E>;
+/**
+ * Executes a synchronous function and returns a Result
+ */
+declare function goTry<T>(fn: () => T): Result<string, T>;
+/**
+ * Handles a value directly and returns a Result
+ */
+declare function goTry<T>(value: T): Result<string, T>;
+/**
+ * Handles a promise and returns a Promise<Result>
+ */
+declare function goTry<T>(promise: PromiseLike<T>): Promise<Result<string, T>>;
+/**
+ * Executes a synchronous function and returns a Result with the raw error
+ */
+declare function goTryRaw<E = unknown, T = unknown>(fn: () => T): Result<E, T>;
+/**
+ * Handles a value directly and returns a Result
+ */
+declare function goTryRaw<E = unknown, T = unknown>(value: T): Result<E, T>;
+/**
+ * Handles a promise and returns a Promise<Result> with the raw error
+ */
+declare function goTryRaw<E = unknown, T = unknown>(promise: PromiseLike<T>): Promise<Result<E, T>>;
 
-export { goExpect, goTry, goTryRaw };
+export { type Failure, type Result, type Success, failure, goTry, goTryRaw, isFailure, isSuccess, success };

package/dist/index.d.mts

@@ -1,9 +1,54 @@
-type ResultTuple<T> = readonly [undefined, T] | readonly [string, undefined];
-type RawResultTuple<T, E = unknown> = readonly [undefined, T] | readonly [E, undefined];
-declare function goTry<T>(value: PromiseLike<T>): PromiseLike<ResultTuple<T>>;
-declare function goTry<T>(value: () => T): ResultTuple<T>;
-declare function goTryRaw<T, E = unknown>(value: PromiseLike<T>): PromiseLike<RawResultTuple<T, E>>;
-declare function goTryRaw<T, E = unknown>(value: () => T): RawResultTuple<T, E>;
-declare function goExpect<T>(value: (() => T) | PromiseLike<T>, error?: (err: string) => string): Promise<T>;
+/**
+ * Type for a successful result
+ */
+type Success<T> = readonly [undefined, T];
+/**
+ * Type for an error result
+ */
+type Failure<E> = readonly [E, undefined];
+/**
+ * Type for a result that can be either success or failure
+ */
+type Result<E, T> = Success<T> | Failure<E>;
+/**
+ * Type guard to check if a result is a success
+ */
+declare function isSuccess<E, T>(result: Result<E, T>): result is Success<T>;
+/**
+ * Type guard to check if a result is a failure
+ */
+declare function isFailure<E, T>(result: Result<E, T>): result is Failure<E>;
+/**
+ * Helper to create a success result
+ */
+declare function success<T>(value: T): Success<T>;
+/**
+ * Helper to create a failure result
+ */
+declare function failure<E>(error: E): Failure<E>;
+/**
+ * Executes a synchronous function and returns a Result
+ */
+declare function goTry<T>(fn: () => T): Result<string, T>;
+/**
+ * Handles a value directly and returns a Result
+ */
+declare function goTry<T>(value: T): Result<string, T>;
+/**
+ * Handles a promise and returns a Promise<Result>
+ */
+declare function goTry<T>(promise: PromiseLike<T>): Promise<Result<string, T>>;
+/**
+ * Executes a synchronous function and returns a Result with the raw error
+ */
+declare function goTryRaw<E = unknown, T = unknown>(fn: () => T): Result<E, T>;
+/**
+ * Handles a value directly and returns a Result
+ */
+declare function goTryRaw<E = unknown, T = unknown>(value: T): Result<E, T>;
+/**
+ * Handles a promise and returns a Promise<Result> with the raw error
+ */
+declare function goTryRaw<E = unknown, T = unknown>(promise: PromiseLike<T>): Promise<Result<E, T>>;
 
-export { goExpect, goTry, goTryRaw };
+export { type Failure, type Result, type Success, failure, goTry, goTryRaw, isFailure, isSuccess, success };

package/dist/index.mjs

@@ -1,63 +1,50 @@
-import pIsPromise from 'p-is-promise';
-
-function isErrorWithMessage(error) {
-  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+function isSuccess(result) {
+  return result[0] === void 0;
+}
+function isFailure(result) {
+  return result[0] !== void 0;
+}
+function success(value) {
+  return [void 0, value];
 }
-function toErrorWithMessage(maybeError) {
-  if (isErrorWithMessage(maybeError)) {
-    return maybeError;
+function failure(error) {
+  return [error, void 0];
+}
+function getErrorMessage(error) {
+  if (typeof error === "string") return error;
+  if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+    return error.message;
   }
   try {
-    return new Error(JSON.stringify(maybeError));
+    return JSON.stringify(error);
   } catch {
-    return new Error(String(maybeError));
+    return String(error);
   }
 }
-function getErrorMessage(error) {
-  return toErrorWithMessage(error).message;
-}
-function isPromise(p) {
-  return pIsPromise(p);
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
 }
 function goTry(value) {
-  let unwrappedValue;
+  if (isPromiseLike(value)) {
+    return Promise.resolve(value).then((value2) => success(value2)).catch((err) => failure(getErrorMessage(err)));
+  }
   try {
-    unwrappedValue = typeof value === "function" ? value() : value;
-    if (isPromise(unwrappedValue)) {
-      return Promise.resolve(unwrappedValue).then((value2) => [void 0, value2]).catch((err) => [getErrorMessage(err), void 0]);
-    }
-    return [void 0, unwrappedValue];
+    const result = typeof value === "function" ? value() : value;
+    return success(result);
   } catch (err) {
-    return [getErrorMessage(err), void 0];
+    return failure(getErrorMessage(err));
   }
 }
 function goTryRaw(value) {
-  let unwrappedValue;
-  try {
-    unwrappedValue = typeof value === "function" ? value() : value;
-    if (isPromise(unwrappedValue)) {
-      return Promise.resolve(unwrappedValue).then((value2) => [void 0, value2]).catch((err) => [err, void 0]);
-    }
-    return [void 0, unwrappedValue];
-  } catch (err) {
-    return [err, void 0];
+  if (isPromiseLike(value)) {
+    return Promise.resolve(value).then((value2) => success(value2)).catch((err) => failure(err));
   }
-}
-async function goExpect(value, error) {
-  const _error = error ?? ((e) => e);
   try {
-    const unwrappedValue = typeof value === "function" ? value() : value;
-    if (isPromise(unwrappedValue)) {
-      const [err, res] = await goTry(unwrappedValue);
-      if (err !== void 0) {
-        throw new Error(err);
-      }
-      return res;
-    }
-    return unwrappedValue;
+    const result = typeof value === "function" ? value() : value;
+    return success(result);
   } catch (err) {
-    throw new Error(_error(getErrorMessage(err)));
+    return failure(err);
   }
 }
 
-export { goExpect, goTry, goTryRaw };
+export { failure, goTry, goTryRaw, isFailure, isSuccess, success };

package/package.json

@@ -1,59 +1,50 @@
 {
-	"name": "go-go-try",
-	"version": "4.1.2",
-	"description": "Tries to execute a sync/async function, returns a result tuple",
-	"license": "MIT",
-	"repository": "thelinuxlich/go-go-try",
-	"author": {
-		"name": "Alisson Cavalcante Agiani",
-		"email": "thelinuxlich@gmail.com"
-	},
-	"type": "module",
-	"main": "./dist/index.cjs",
-	"module": "./dist/index.mjs",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		"require": {
-			"types": "./dist/index.d.cts",
-			"default": "./dist/index.cjs"
-		},
-		"import": {
-			"types": "./dist/index.d.mts",
-			"default": "./dist/index.mjs"
-		}
-	},
-	"sideEffects": false,
-	"engines": {
-		"node": ">=12"
-	},
-	"scripts": {
-		"build": "npx pkgroll",
-		"lint": "biome lint --apply src/*.ts",
-		"test": "yarn run build && yarn run lint && NODE_OPTIONS=--experimental-vm-modules jest --coverage --coverageReporters=text"
-	},
-	"keywords": [
-		"errors",
-		"try",
-		"catch",
-		"error handling",
-		"nice-try",
-		"good-try",
-		"go-go-try",
-		"gotry",
-		"go-try"
-	],
-	"devDependencies": {
-		"@biomejs/biome": "^1.7.0",
-		"@types/jest": "^28.1.1",
-		"confusing-browser-globals": "^1.0.11",
-		"jest": "^28.1.1",
-		"jest-environment-jsdom": "^28.1.1",
-		"np": "^7.6.1",
-		"ts-jest": "^28.0.4",
-		"ts-node": "^10.8.2",
-		"typescript": "^5.4.5"
-	},
-	"dependencies": {
-		"p-is-promise": "^4.0.0"
-	}
-}
+  "name": "go-go-try",
+  "version": "6.0.0",
+  "description": "Tries to execute a sync/async function, returns a result tuple",
+  "license": "MIT",
+  "repository": "thelinuxlich/go-go-try",
+  "author": {
+    "name": "Alisson Cavalcante Agiani",
+    "email": "thelinuxlich@gmail.com"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    "require": {
+      "types": "./dist/index.d.cts",
+      "default": "./dist/index.cjs"
+    },
+    "import": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "scripts": {
+    "build": "pkgroll",
+    "lint": "biome lint --write src/*.ts",
+    "test": "npm run build && npm run lint && tsx test.ts"
+  },
+  "keywords": [
+    "errors",
+    "try",
+    "catch",
+    "error handling",
+    "nice-try",
+    "good-try",
+    "go-go-try",
+    "gotry",
+    "go-try"
+  ],
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "pkgroll": "^2.12.1",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.3"
+  }
+}

package/src/index.ts

@@ -1,102 +1,90 @@
-import pIsPromise from 'p-is-promise'
-type ResultTuple<T> = readonly [undefined, T] | readonly [string, undefined]
-type RawResultTuple<T, E = unknown> =
-	| readonly [undefined, T]
-	| readonly [E, undefined]
+export type Success<T> = readonly [undefined, T]
 
-type ErrorWithMessage = {
-	message: string
+export type Failure<E> = readonly [E, undefined]
+
+export type Result<E, T> = Success<T> | Failure<E>
+
+export function isSuccess<E, T>(result: Result<E, T>): result is Success<T> {
+  return result[0] === undefined
 }
 
-function isErrorWithMessage(error: unknown): error is ErrorWithMessage {
-	return (
-		typeof error === 'object' &&
-		error !== null &&
-		'message' in error &&
-		typeof (error as Record<string, unknown>).message === 'string'
-	)
+export function isFailure<E, T>(result: Result<E, T>): result is Failure<E> {
+  return result[0] !== undefined
 }
 
-function toErrorWithMessage(maybeError: unknown): ErrorWithMessage {
-	if (isErrorWithMessage(maybeError)) {
-		return maybeError
-	}
+export function success<T>(value: T): Success<T> {
+  return [undefined, value] as const
+}
 
-	try {
-		return new Error(JSON.stringify(maybeError))
-	} catch {
-		// fallback in case there's an error stringifying the maybeError
-		//  with circular references for example.
-		return new Error(String(maybeError))
-	}
+export function failure<E>(error: E): Failure<E> {
+  return [error, undefined] as const
 }
 
 function getErrorMessage(error: unknown): string {
-	return toErrorWithMessage(error).message
-}
+  if (typeof error === 'string') return error
 
-function isPromise<T>(p: T | PromiseLike<T>): p is PromiseLike<T> {
-	return pIsPromise(p)
-}
+  if (
+    typeof error === 'object' &&
+    error !== null &&
+    'message' in error &&
+    typeof (error as Record<string, unknown>).message === 'string'
+  ) {
+    return (error as { message: string }).message
+  }
 
-function goTry<T>(value: PromiseLike<T>): PromiseLike<ResultTuple<T>>
-function goTry<T>(value: () => T): ResultTuple<T>
-function goTry<T>(
-	value: (() => T) | PromiseLike<T>,
-): ResultTuple<T> | PromiseLike<ResultTuple<T>> {
-	let unwrappedValue: T | PromiseLike<T>
-	try {
-		unwrappedValue = typeof value === 'function' ? value() : value
-		if (isPromise(unwrappedValue)) {
-			return Promise.resolve(unwrappedValue)
-				.then((value) => [undefined, value] as const)
-				.catch((err) => [getErrorMessage(err), undefined] as const)
-		}
-		return [undefined, unwrappedValue] as const
-	} catch (err) {
-		return [getErrorMessage(err), undefined] as const
-	}
+  try {
+    return JSON.stringify(error)
+  } catch {
+    return String(error)
+  }
 }
 
-function goTryRaw<T, E = unknown>(
-	value: PromiseLike<T>,
-): PromiseLike<RawResultTuple<T, E>>
-function goTryRaw<T, E = unknown>(value: () => T): RawResultTuple<T, E>
-function goTryRaw<T, E = unknown>(
-	value: PromiseLike<T> | (() => T),
-): RawResultTuple<T, E> | PromiseLike<RawResultTuple<T, E>> {
-	let unwrappedValue: T | PromiseLike<T>
-	try {
-		unwrappedValue = typeof value === 'function' ? value() : value
-		if (isPromise(unwrappedValue)) {
-			return Promise.resolve(unwrappedValue)
-				.then((value) => [undefined, value] as const)
-				.catch((err) => [err, undefined] as const)
-		}
-		return [undefined, unwrappedValue] as const
-	} catch (err) {
-		return [err, undefined] as const as RawResultTuple<T, E>
-	}
+function isPromiseLike<T>(value: unknown): value is PromiseLike<T> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'then' in value &&
+    typeof (value as { then: unknown }).then === 'function'
+  )
 }
+export function goTry<T>(fn: () => T): Result<string, T>
+export function goTry<T>(value: T): Result<string, T>
+export function goTry<T>(promise: PromiseLike<T>): Promise<Result<string, T>>
+
+export function goTry<T>(
+  value: T | (() => T) | PromiseLike<T>,
+): Result<string, T> | Promise<Result<string, T>> {
+  if (isPromiseLike<T>(value)) {
+    return Promise.resolve(value)
+      .then((value) => success(value))
+      .catch((err) => failure(getErrorMessage(err)))
+  }
 
-async function goExpect<T>(
-	value: (() => T) | PromiseLike<T>,
-	error?: (err: string) => string,
-): Promise<T> {
-	const _error = error ?? ((e: string): string => e)
-	try {
-		const unwrappedValue = typeof value === 'function' ? value() : value
-		if (isPromise(unwrappedValue)) {
-			const [err, res] = await goTry(unwrappedValue)
-			if (err !== undefined) {
-				throw new Error(err)
-			}
-			return res
-		}
-		return unwrappedValue
-	} catch (err) {
-		throw new Error(_error(getErrorMessage(err)))
-	}
+  try {
+    const result = typeof value === 'function' ? (value as () => T)() : value
+    return success(result)
+  } catch (err) {
+    return failure(getErrorMessage(err))
+  }
 }
+export function goTryRaw<E = unknown, T = unknown>(fn: () => T): Result<E, T>
+export function goTryRaw<E = unknown, T = unknown>(value: T): Result<E, T>
+export function goTryRaw<E = unknown, T = unknown>(
+  promise: PromiseLike<T>,
+): Promise<Result<E, T>>
 
-export { goTry, goExpect, goTryRaw }
+export function goTryRaw<E = unknown, T = unknown>(
+  value: T | (() => T) | PromiseLike<T>,
+): Result<E, T> | Promise<Result<E, T>> {
+  if (isPromiseLike<T>(value)) {
+    return Promise.resolve(value)
+      .then((value) => success<T>(value))
+      .catch((err) => failure<E>(err as E))
+  }
+  try {
+    const result = typeof value === 'function' ? (value as () => T)() : value
+    return success<T>(result)
+  } catch (err) {
+    return failure<E>(err as E)
+  }
+}

package/test.ts

@@ -1,87 +1,119 @@
-import { goExpect, goTry, goTryRaw } from './src/index'
-
-describe('go-go-try', () => {
-	it(`value returned by callback is used when callback doesn't throw`, async () => {
-		const fn = () => 'value'
-		const [err1, value] = goTry(fn)
-		let value2
-		try {
-			value2 = await goExpect(fn)
-		} catch (err) {
-			// this won't throw
-		}
-		const [err2, value3] = goTryRaw(fn)
-		expect(value).toBe('value')
-		expect(value2).toBe('value')
-		expect(value3).toBe('value')
-		expect(err1).toBeUndefined()
-		expect(err2).toBeUndefined()
-	})
-
-	it('if callback throws, value should be undefined and err should contain the error message', async () => {
-		const fn = () => {
-			return JSON.parse('{/')
-		}
-		const [err1, value] = goTry(fn)
-		let value2
-		let err2
-		try {
-			value2 = await goExpect(fn)
-		} catch (err) {
-			if (err instanceof Error) {
-				err2 = err.message
-			}
-		}
-		const [err3, value3] = goTryRaw(fn)
-
-		expect(value).toBeUndefined()
-		expect(value2).toBeUndefined()
-		expect(value3).toBeUndefined()
-		expect(typeof err1).toBe('string')
-		expect(typeof err2).toBe('string')
-		expect(typeof err3).toBe('object')
-		expect(typeof (err3 as { message: string }).message).toBe('string')
-	})
-
-	it('first parameter accepts promises and makes the function async', async () => {
-		const fn = Promise.resolve('value')
-		const [err1, value] = await goTry(fn)
-		let value2
-		let err2
-		try {
-			value2 = await goExpect(fn)
-		} catch (err) {
-			err2 = err
-		}
-		const [err3, value3] = await goTryRaw(fn)
-		expect(value).toBe('value')
-		expect(value2).toBe('value')
-		expect(value3).toBe('value')
-		expect(err1).toBeUndefined()
-		expect(err2).toBeUndefined()
-		expect(err3).toBeUndefined()
-	})
-
-	it('if async callback throws, value should be undefined and err should contain the error message', async () => {
-		const fn = Promise.reject(new Error('error'))
-		const [err, value] = await goTry(fn)
-		let value2
-		let err2
-		try {
-			value2 = await goExpect(fn, (e) => `custom ${e}`)
-		} catch (err) {
-			if (err instanceof Error) {
-				err2 = err.message
-				console.log(err)
-			}
-		}
-		const [err3, value3] = await goTryRaw(fn)
-		expect(value).toBeUndefined()
-		expect(value2).toBeUndefined()
-		expect(value3).toBeUndefined()
-		expect(err).toBe('error')
-		expect(err2).toBe('custom error')
-		expect(typeof err3).toBe('object')
-		expect((err3 as { message: string }).message).toEqual('error')
-	})
+import * as assert from 'node:assert'
+import { test } from 'node:test'
+import { goTry, goTryRaw, isFailure, isSuccess } from './src/index.js'
+
+test(`value returned by callback is used when callback doesn't throw`, async () => {
+  const fn = () => 'value'
+
+  // Test with function
+  const result1 = goTry(fn)
+  const result2 = goTryRaw(fn)
+
+  // Test destructuring
+  const [err1, value] = result1
+  const [err2, value2] = result2
+
+  // Test type guards
+  assert.equal(isSuccess(result1), true)
+  assert.equal(isSuccess(result2), true)
+  assert.equal(isFailure(result1), false)
+  assert.equal(isFailure(result2), false)
+
+  // Test values
+  assert.equal(value, 'value')
+  assert.equal(value2, 'value')
+  assert.equal(err1, undefined)
+  assert.equal(err2, undefined)
+})
+
+test('if callback throws, value should be undefined and err should contain the error message', async () => {
+  const fn = () => {
+    return JSON.parse('{/') as string
+  }
+
+  // Test with function that throws
+  const result1 = goTry(fn)
+  const result2 = goTryRaw<Error>(fn)
+
+  // Test destructuring
+  const [err1, value] = result1
+  const [err2, value2] = result2
+
+  // Test type guards
+  assert.equal(isSuccess(result1), false)
+  assert.equal(isSuccess(result2), false)
+  assert.equal(isFailure(result1), true)
+  assert.equal(isFailure(result2), true)
+
+  // Test values
+  assert.equal(value, undefined)
+  assert.equal(value2, undefined)
+  assert.equal(typeof err1, 'string')
+  assert.equal(typeof err2, 'object')
+  assert.equal(typeof err2?.message, 'string')
+})
+
+test('first parameter accepts promises and makes the function async', async () => {
+  const promise = Promise.resolve('value')
+
+  // Test with promise
+  const result1 = await goTry(promise)
+  const result2 = await goTryRaw(promise)
+
+  // Test destructuring
+  const [err1, value] = result1
+  const [err2, value2] = result2
+
+  // Test type guards
+  assert.equal(isSuccess(result1), true)
+  assert.equal(isSuccess(result2), true)
+  assert.equal(isFailure(result1), false)
+  assert.equal(isFailure(result2), false)
+
+  // Test values
+  assert.equal(value, 'value')
+  assert.equal(value2, 'value')
+  assert.equal(err1, undefined)
+  assert.equal(err2, undefined)
+})
+
+test('if async callback throws, value should be undefined and err should contain the error message', async () => {
+  const promise = Promise.reject(new Error('error'))
+
+  // Test with promise that rejects
+  const result1 = await goTry(promise)
+  const result2 = await goTryRaw<Error>(promise)
+
+  // Test destructuring
+  const [err, value] = result1
+  const [err2, value2] = result2
+
+  // Test type guards
+  assert.equal(isSuccess(result1), false)
+  assert.equal(isSuccess(result2), false)
+  assert.equal(isFailure(result1), true)
+  assert.equal(isFailure(result2), true)
+
+  // Test values
+  assert.equal(value, undefined)
+  assert.equal(value2, undefined)
+  assert.equal(err, 'error')
+  assert.equal(typeof err2, 'object')
+  assert.equal(err2?.message, 'error')
+})
+
+test('direct values work too', () => {
+  // Test with direct value
+  const result1 = goTry('value')
+  const result2 = goTryRaw('value')
+
+  // Test destructuring
+  const [err1, value] = result1
+  const [err2, value2] = result2
+
+  // Test values
+  assert.equal(value, 'value')
+  assert.equal(value2, 'value')
+  assert.equal(err1, undefined)
+  assert.equal(err2, undefined)
 })

package/tsconfig.json

@@ -1,24 +1,11 @@
 {
     "compilerOptions": {
         "target": "ES2020",
-        // previously "CommonJS", we now use "ES2015" to transpile TypeScript to "export default"
-        // instead of "exports.default ="
         "module": "ES2015",
         "esModuleInterop": true,
-        // From what I understand while reading the docs "classic" was introduced first and "classic" is by
-        // default(except when "module": "commonjs") because of backwards compatibility.
-        //
-        // From the docs: "node module resolution is the most-commonly used in the TypeScript community and is
-        // recommended for most projects."
         "moduleResolution": "node",
-        // the npm package include ".js" files only so we need ".d.ts" files to be generated
         "declaration": true,
-        // - ℹ️ https://www.typescriptlang.org/tsconfig#isolatedModules
-        // - 😃 Deno requires "isolatedModules" to be set to `true`
-        // - 😃 the stricter version - I always prefer the stricter version
-        // - 😃 probably the future
         "isolatedModules": true,
-        // strict options ensuring more stable code
         "strict": true,
         "noUnusedLocals": true,
         "noUnusedParameters": true,
@@ -26,8 +13,5 @@
         "noUncheckedIndexedAccess": true,
         "noFallthroughCasesInSwitch": true,
         "forceConsistentCasingInFileNames": true
-    },
-    "include": [
-        "src/index.ts"
-    ]
+    }
 }

package/jest.config.ts

@@ -1,36 +0,0 @@
-import type { Config } from '@jest/types'
-
-const config: Config.InitialOptions = {
-	// adds support for tests written in TypeScript
-	preset: 'ts-jest',
-
-	// adds jsdom (https://github.com/jsdom/jsdom) APIs to tests
-	testEnvironment: 'jsdom',
-
-	// run tests on root and in /test folder with .ts and .tsx extensions
-	testMatch: ['<rootDir>/test.ts?(x)', '<rootDir>/test/**.ts?(x)'],
-
-	// ESM support
-	// https://kulshekhar.github.io/ts-jest/docs/guides/esm-support/
-	globals: {
-		'ts-jest': {
-			useESM: true,
-		},
-	},
-	extensionsToTreatAsEsm: ['.ts', '.tsx'],
-
-	// restores original implementation (after each test is finished) when calling `jest.spyOn()`
-	// inside of a test:
-	// - https://jestjs.io/docs/configuration#restoremocks-boolean
-	// - https://jestjs.io/docs/mock-function-api#mockfnmockrestore
-	restoreMocks: true,
-
-	// 🐛 fix "having test.js and test.ts runs the test.js file"
-	// what about: ts-node CLI option:
-	// --prefer-ts-exts Re-order file extensions so that TypeScript imports are preferred (TS_NODE_PREFER_TS_EXTS, default: false)
-	moduleNameMapper: {
-		'^(\\..*)$': ['$1/index.ts', '$1.ts', '$1'],
-	},
-}
-
-export default config