wellcrafted 0.16.1 → 0.18.0

package/README.md

@@ -208,11 +208,13 @@ Every `TaggedError` contains four essential properties that work together to cre
 type TaggedError<T extends string> = {
   readonly name: T;                    // 1. The discriminant
   message: string;                     // 2. Human-readable description  
-  context: Record<string, unknown>;    // 3. Debugging data
-  cause?: unknown;                     // 4. Root cause (optional)
+  context?: Record<string, unknown>;    // 3. Function inputs & debugging data (optional)
+  cause: unknown;                     // 4. Root cause
 };
 ```
 
+> The `context` property should include the function's input parameters and any relevant variables in the closure. If there are none, then it can be omitted. This creates a complete picture of what data led to the error, making debugging straightforward.
+
 #### 1. **`name`** - The Discriminant (Tagged Field)
 
 This is your error's unique identifier and the key to pattern matching. Use it in `if` statements and `switch` statements to handle different error types:
@@ -253,9 +255,9 @@ return Err({
 });
 ```
 
-#### 3. **`context`** - Debugging Data
+#### 3. **`context`** - Function Inputs & Debugging Data
 
-Include function inputs and any data that would help debug the issue. This is invaluable for logging and troubleshooting:
+The primary purpose of `context` is to capture the function's input parameters, relevant variables in the closure, and additional context.
 
 ```ts
 function processUser(id: number, options: UserOptions): Result<User, ProcessError> {

package/dist/error/index.d.ts

@@ -1,4 +1,7 @@
+import { Err } from "../result-Bi5hwqKw.js";
+
 //#region src/error/types.d.ts
+
 /**
  * Base error structure for all errors in the Result system.
  *
@@ -18,7 +21,7 @@
 type BaseError = Readonly<{
   name: string;
   message: string;
-  context: Record<string, unknown>;
+  context?: Record<string, unknown>;
   cause: unknown;
 }>;
 /**
@@ -54,6 +57,18 @@ type BaseError = Readonly<{
  *   }
  *   return Ok(input);
  * }
+ *
+ * // Context is optional - omit when not needed:
+ * function checkAuth(): Result<User, AuthError> {
+ *   if (!isAuthenticated) {
+ *     return Err({
+ *       name: "AuthError",
+ *       message: "User not authenticated",
+ *       cause: null,
+ *     });
+ *   }
+ *   return Ok(currentUser);
+ * }
  * ```
  */
 type TaggedError<T extends string> = BaseError & {
@@ -98,7 +113,72 @@ type TaggedError<T extends string> = BaseError & {
  * ```
  */
 declare function extractErrorMessage(error: unknown): string;
-//# sourceMappingURL=utils.d.ts.map
+/**
+ * Input type for creating a tagged error (everything except the name)
+ */
+type TaggedErrorWithoutName<T extends string> = Omit<TaggedError<T>, "name">;
+/**
+ * Replaces the "Error" suffix with "Err" suffix in error type names.
+ *
+ * This utility type is used to create companion function names for error constructors
+ * that return Err-wrapped results, maintaining consistent naming conventions.
+ *
+ * @template T - An error type name that must end with "Error"
+ * @returns The type name with "Error" replaced by "Err"
+ *
+ * @example
+ * ```ts
+ * type NetworkErr = ReplaceErrorWithErr<"NetworkError">; // "NetworkErr"
+ * type ValidationErr = ReplaceErrorWithErr<"ValidationError">; // "ValidationErr"
+ * type AuthErr = ReplaceErrorWithErr<"AuthError">; // "AuthErr"
+ * ```
+ */
+type ReplaceErrorWithErr<T extends `${string}Error`> = T extends `${infer TBase}Error` ? `${TBase}Err` : never;
+/**
+ * Return type for createTaggedError - contains both factory functions.
+ *
+ * Provides two factory functions:
+ * - One that creates plain TaggedError objects (named with "Error" suffix)
+ * - One that creates Err-wrapped TaggedError objects (named with "Err" suffix)
+ */
+type TaggedErrorFactories<TErrorName extends `${string}Error`> = { [K in TErrorName]: (input: TaggedErrorWithoutName<K>) => TaggedError<K> } & { [K in ReplaceErrorWithErr<TErrorName>]: (input: TaggedErrorWithoutName<TErrorName>) => Err<TaggedError<TErrorName>> };
+/**
+ * Returns two different factory functions for tagged errors.
+ *
+ * Given an error name like "NetworkError", this returns:
+ * - `NetworkError`: Creates a plain TaggedError object
+ * - `NetworkErr`: Creates a TaggedError object wrapped in an Err result
+ *
+ * The naming pattern automatically replaces the "Error" suffix with "Err" suffix
+ * for the Result-wrapped version.
+ *
+ * @param name - The name of the error type (must end with "Error")
+ * @returns An object with two factory functions:
+ *   - [name]: Function that creates plain TaggedError objects
+ *   - [name with "Error" replaced by "Err"]: Function that creates Err-wrapped TaggedError objects
+ *
+ * @example
+ * ```ts
+ * const { NetworkError, NetworkErr } = createTaggedError('NetworkError');
+ *
+ * // NetworkError: Creates just the error object
+ * const error = NetworkError({
+ *   message: 'Connection failed',
+ *   context: { url: 'https://api.example.com' },
+ *   cause: undefined
+ * });
+ * // Returns: { name: 'NetworkError', message: 'Connection failed', ... }
+ *
+ * // NetworkErr: Creates error and wraps in Err result
+ * return NetworkErr({
+ *   message: 'Connection failed',
+ *   context: { url: 'https://api.example.com' },
+ *   cause: undefined
+ * });
+ * // Returns: Err({ name: 'NetworkError', message: 'Connection failed', ... })
+ * ```
+ */
+declare function createTaggedError<TErrorName extends `${string}Error`>(name: TErrorName): TaggedErrorFactories<TErrorName>;
 //#endregion
-export { BaseError, TaggedError, extractErrorMessage };
+export { BaseError, TaggedError, createTaggedError, extractErrorMessage };
 //# sourceMappingURL=index.d.ts.map

package/dist/error/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/error/types.ts","../../src/error/utils.ts"],"sourcesContent":[],"mappings":";;AAgBA;;;;AAAgC;AA0ChC;;;;AACiB;;;;ACxBjB;;KDnBY,SAAA,GAAY;;;WAGd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAuCE,gCAAgC;iBAC5B;;;;;;AA3ChB;;;;AAAgC;AA0ChC;;;;AACiB;;;;ACxBjB;;;;;;;;;;;;;;;;;;;;;iBAAgB,mBAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/error/types.ts","../../src/error/utils.ts"],"sourcesContent":[],"mappings":";;;;;;;AAgBA;;;;AAAgC;AAsDhC;;;;AACiB;;;;ACjCD,KDtBJ,SAAA,GAAY,QCsBW,CAAA;EAoC9B,IAAA,EAAA,MAAA;EAAsB,OAAA,EAAA,MAAA;EAAA,OAAsC,CAAA,EDvDtD,MCuDsD,CAAA,MAAA,EAAA,OAAA,CAAA;EAAC,KAAb,EAAA,OAAA;CAAW,CAAA;AAAZ;AAAA;;;;AAmBT;AAAA;;;;;;;;;;;;;;AAclC;AAuCT;;;;;AAEuB;;;;;;;;;;;;;;;;;;;;;KD9EX,gCAAgC;iBAC5B;;;;;;AAvDhB;;;;AAAgC;AAsDhC;;;;AACiB;;;;ACjCjB;AA+BC;;;;;AAKmD;AAAA;;;;AAmBT;AAAA;;;;;;;;;AAaX,iBApEhB,mBAAA,CAoEgB,KAAA,EAAA,OAAA,CAAA,EAAA,MAAA;;;;KAhC3B,sBAiCC,CAAA,UAAA,MAAA,CAAA,GAjC0C,IAiC1C,CAjC+C,WAiC/C,CAjC2D,CAiC3D,CAAA,EAAA,MAAA,CAAA;AAAG;AAuCT;;;;;AAEuB;;;;;;;;;;KAxDlB,kDACJ,qCAAqC;;;;;;;;KASjC,oEACE,qBAAqB,uBAAuB,OAAO,YAAY,eAE/D,oBAAoB,sBAClB,uBAAuB,gBAC1B,IAAI,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCN,6DACT,aACJ,qBAAqB"}

package/dist/error/index.js

@@ -1,3 +1,5 @@
+import { Err } from "../result-DxmXBFi5.js";
+
 //#region src/error/utils.ts
 /**
 * Extracts a readable error message from an unknown error value
@@ -50,7 +52,55 @@ function extractErrorMessage(error) {
 	}
 	return String(error);
 }
+/**
+* Returns two different factory functions for tagged errors.
+*
+* Given an error name like "NetworkError", this returns:
+* - `NetworkError`: Creates a plain TaggedError object
+* - `NetworkErr`: Creates a TaggedError object wrapped in an Err result
+*
+* The naming pattern automatically replaces the "Error" suffix with "Err" suffix
+* for the Result-wrapped version.
+*
+* @param name - The name of the error type (must end with "Error")
+* @returns An object with two factory functions:
+*   - [name]: Function that creates plain TaggedError objects
+*   - [name with "Error" replaced by "Err"]: Function that creates Err-wrapped TaggedError objects
+*
+* @example
+* ```ts
+* const { NetworkError, NetworkErr } = createTaggedError('NetworkError');
+*
+* // NetworkError: Creates just the error object
+* const error = NetworkError({
+*   message: 'Connection failed',
+*   context: { url: 'https://api.example.com' },
+*   cause: undefined
+* });
+* // Returns: { name: 'NetworkError', message: 'Connection failed', ... }
+*
+* // NetworkErr: Creates error and wraps in Err result
+* return NetworkErr({
+*   message: 'Connection failed',
+*   context: { url: 'https://api.example.com' },
+*   cause: undefined
+* });
+* // Returns: Err({ name: 'NetworkError', message: 'Connection failed', ... })
+* ```
+*/
+function createTaggedError(name) {
+	const errorConstructor = (error) => ({
+		...error,
+		name
+	});
+	const errName = name.replace(/Error$/, "Err");
+	const errConstructor = (error) => Err(errorConstructor(error));
+	return {
+		[name]: errorConstructor,
+		[errName]: errConstructor
+	};
+}
 
 //#endregion
-export { extractErrorMessage };
+export { createTaggedError, extractErrorMessage };
 //# sourceMappingURL=index.js.map

package/dist/error/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["error: unknown"],"sources":["../../src/error/utils.ts"],"sourcesContent":["/**\n * Extracts a readable error message from an unknown error value\n *\n * This utility is commonly used in mapError functions when converting\n * unknown errors to typed error objects in the Result system.\n *\n * @param error - The unknown error to extract a message from\n * @returns A string representation of the error\n *\n * @example\n * ```ts\n * // With native Error\n * const error = new Error(\"Something went wrong\");\n * const message = extractErrorMessage(error); // \"Something went wrong\"\n *\n * // With string error\n * const stringError = \"String error\";\n * const message2 = extractErrorMessage(stringError); // \"String error\"\n *\n * // With object error\n * const unknownError = { code: 500, details: \"Server error\" };\n * const message3 = extractErrorMessage(unknownError); // '{\"code\":500,\"details\":\"Server error\"}'\n *\n * // Used in mapError function\n * const result = await tryAsync({\n *   try: () => riskyOperation(),\n *   mapError: (error): NetworkError => ({\n *     name: \"NetworkError\",\n *     message: extractErrorMessage(error),\n *     context: { operation: \"riskyOperation\" },\n *     cause: error,\n *   }),\n * });\n * ```\n */\nexport function extractErrorMessage(error: unknown): string {\n\tif (error instanceof Error) {\n\t\treturn error.message;\n\t}\n\n\tif (typeof error === \"string\") {\n\t\treturn error;\n\t}\n\n\tif (typeof error === \"object\" && error !== null) {\n\t\t// Check for common error properties\n\t\tconst errorObj = error as Record<string, unknown>;\n\t\tif (typeof errorObj.message === \"string\") {\n\t\t\treturn errorObj.message;\n\t\t}\n\t\tif (typeof errorObj.error === \"string\") {\n\t\t\treturn errorObj.error;\n\t\t}\n\t\tif (typeof errorObj.description === \"string\") {\n\t\t\treturn errorObj.description;\n\t\t}\n\n\t\t// Fallback to JSON stringification\n\t\ttry {\n\t\t\treturn JSON.stringify(error);\n\t\t} catch {\n\t\t\treturn String(error);\n\t\t}\n\t}\n\n\treturn String(error);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,oBAAoBA,OAAwB;AAC3D,KAAI,iBAAiB,MACpB,QAAO,MAAM;AAGd,YAAW,UAAU,SACpB,QAAO;AAGR,YAAW,UAAU,YAAY,UAAU,MAAM;EAEhD,MAAM,WAAW;AACjB,aAAW,SAAS,YAAY,SAC/B,QAAO,SAAS;AAEjB,aAAW,SAAS,UAAU,SAC7B,QAAO,SAAS;AAEjB,aAAW,SAAS,gBAAgB,SACnC,QAAO,SAAS;AAIjB,MAAI;AACH,UAAO,KAAK,UAAU,MAAM;EAC5B,QAAO;AACP,UAAO,OAAO,MAAM;EACpB;CACD;AAED,QAAO,OAAO,MAAM;AACpB"}
+{"version":3,"file":"index.js","names":["error: unknown","name: TErrorName","error: TaggedErrorWithoutName<TErrorName>"],"sources":["../../src/error/utils.ts"],"sourcesContent":["import type { TaggedError } from \"./types.js\";\nimport { Err } from \"../result/result.js\";\n\n/**\n * Extracts a readable error message from an unknown error value\n *\n * This utility is commonly used in mapError functions when converting\n * unknown errors to typed error objects in the Result system.\n *\n * @param error - The unknown error to extract a message from\n * @returns A string representation of the error\n *\n * @example\n * ```ts\n * // With native Error\n * const error = new Error(\"Something went wrong\");\n * const message = extractErrorMessage(error); // \"Something went wrong\"\n *\n * // With string error\n * const stringError = \"String error\";\n * const message2 = extractErrorMessage(stringError); // \"String error\"\n *\n * // With object error\n * const unknownError = { code: 500, details: \"Server error\" };\n * const message3 = extractErrorMessage(unknownError); // '{\"code\":500,\"details\":\"Server error\"}'\n *\n * // Used in mapError function\n * const result = await tryAsync({\n *   try: () => riskyOperation(),\n *   mapError: (error): NetworkError => ({\n *     name: \"NetworkError\",\n *     message: extractErrorMessage(error),\n *     context: { operation: \"riskyOperation\" },\n *     cause: error,\n *   }),\n * });\n * ```\n */\nexport function extractErrorMessage(error: unknown): string {\n\tif (error instanceof Error) {\n\t\treturn error.message;\n\t}\n\n\tif (typeof error === \"string\") {\n\t\treturn error;\n\t}\n\n\tif (typeof error === \"object\" && error !== null) {\n\t\t// Check for common error properties\n\t\tconst errorObj = error as Record<string, unknown>;\n\t\tif (typeof errorObj.message === \"string\") {\n\t\t\treturn errorObj.message;\n\t\t}\n\t\tif (typeof errorObj.error === \"string\") {\n\t\t\treturn errorObj.error;\n\t\t}\n\t\tif (typeof errorObj.description === \"string\") {\n\t\t\treturn errorObj.description;\n\t\t}\n\n\t\t// Fallback to JSON stringification\n\t\ttry {\n\t\t\treturn JSON.stringify(error);\n\t\t} catch {\n\t\t\treturn String(error);\n\t\t}\n\t}\n\n\treturn String(error);\n}\n\n/**\n * Input type for creating a tagged error (everything except the name)\n */\ntype TaggedErrorWithoutName<T extends string> = Omit<TaggedError<T>, \"name\">;\n\n/**\n * Replaces the \"Error\" suffix with \"Err\" suffix in error type names.\n *\n * This utility type is used to create companion function names for error constructors\n * that return Err-wrapped results, maintaining consistent naming conventions.\n *\n * @template T - An error type name that must end with \"Error\"\n * @returns The type name with \"Error\" replaced by \"Err\"\n *\n * @example\n * ```ts\n * type NetworkErr = ReplaceErrorWithErr<\"NetworkError\">; // \"NetworkErr\"\n * type ValidationErr = ReplaceErrorWithErr<\"ValidationError\">; // \"ValidationErr\"\n * type AuthErr = ReplaceErrorWithErr<\"AuthError\">; // \"AuthErr\"\n * ```\n */\ntype ReplaceErrorWithErr<T extends `${string}Error`> =\n\tT extends `${infer TBase}Error` ? `${TBase}Err` : never;\n\n/**\n * Return type for createTaggedError - contains both factory functions.\n *\n * Provides two factory functions:\n * - One that creates plain TaggedError objects (named with \"Error\" suffix)\n * - One that creates Err-wrapped TaggedError objects (named with \"Err\" suffix)\n */\ntype TaggedErrorFactories<TErrorName extends `${string}Error`> = {\n\t[K in TErrorName]: (input: TaggedErrorWithoutName<K>) => TaggedError<K>;\n} & {\n\t[K in ReplaceErrorWithErr<TErrorName>]: (\n\t\tinput: TaggedErrorWithoutName<TErrorName>,\n\t) => Err<TaggedError<TErrorName>>;\n};\n\n/**\n * Returns two different factory functions for tagged errors.\n *\n * Given an error name like \"NetworkError\", this returns:\n * - `NetworkError`: Creates a plain TaggedError object\n * - `NetworkErr`: Creates a TaggedError object wrapped in an Err result\n *\n * The naming pattern automatically replaces the \"Error\" suffix with \"Err\" suffix\n * for the Result-wrapped version.\n *\n * @param name - The name of the error type (must end with \"Error\")\n * @returns An object with two factory functions:\n *   - [name]: Function that creates plain TaggedError objects\n *   - [name with \"Error\" replaced by \"Err\"]: Function that creates Err-wrapped TaggedError objects\n *\n * @example\n * ```ts\n * const { NetworkError, NetworkErr } = createTaggedError('NetworkError');\n *\n * // NetworkError: Creates just the error object\n * const error = NetworkError({\n *   message: 'Connection failed',\n *   context: { url: 'https://api.example.com' },\n *   cause: undefined\n * });\n * // Returns: { name: 'NetworkError', message: 'Connection failed', ... }\n *\n * // NetworkErr: Creates error and wraps in Err result\n * return NetworkErr({\n *   message: 'Connection failed',\n *   context: { url: 'https://api.example.com' },\n *   cause: undefined\n * });\n * // Returns: Err({ name: 'NetworkError', message: 'Connection failed', ... })\n * ```\n */\nexport function createTaggedError<TErrorName extends `${string}Error`>(\n\tname: TErrorName,\n): TaggedErrorFactories<TErrorName> {\n\tconst errorConstructor = (\n\t\terror: TaggedErrorWithoutName<TErrorName>,\n\t): TaggedError<TErrorName> => ({ ...error, name }) as TaggedError<TErrorName>;\n\n\tconst errName = name.replace(\n\t\t/Error$/,\n\t\t\"Err\",\n\t) as ReplaceErrorWithErr<TErrorName>;\n\tconst errConstructor = (error: TaggedErrorWithoutName<TErrorName>) =>\n\t\tErr(errorConstructor(error));\n\n\treturn {\n\t\t[name]: errorConstructor,\n\t\t[errName]: errConstructor,\n\t} as TaggedErrorFactories<TErrorName>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,oBAAoBA,OAAwB;AAC3D,KAAI,iBAAiB,MACpB,QAAO,MAAM;AAGd,YAAW,UAAU,SACpB,QAAO;AAGR,YAAW,UAAU,YAAY,UAAU,MAAM;EAEhD,MAAM,WAAW;AACjB,aAAW,SAAS,YAAY,SAC/B,QAAO,SAAS;AAEjB,aAAW,SAAS,UAAU,SAC7B,QAAO,SAAS;AAEjB,aAAW,SAAS,gBAAgB,SACnC,QAAO,SAAS;AAIjB,MAAI;AACH,UAAO,KAAK,UAAU,MAAM;EAC5B,QAAO;AACP,UAAO,OAAO,MAAM;EACpB;CACD;AAED,QAAO,OAAO,MAAM;AACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6ED,SAAgB,kBACfC,MACmC;CACnC,MAAM,mBAAmB,CACxBC,WAC8B;EAAE,GAAG;EAAO;CAAM;CAEjD,MAAM,UAAU,KAAK,QACpB,UACA,MACA;CACD,MAAM,iBAAiB,CAACA,UACvB,IAAI,iBAAiB,MAAM,CAAC;AAE7B,QAAO;GACL,OAAO;GACP,UAAU;CACX;AACD"}

package/dist/result/index.d.ts

@@ -1,433 +1,7 @@
-//#region src/result/result.d.ts
-/**
- * Represents the successful outcome of an operation, encapsulating the success value.
- *
- * This is the 'Ok' variant of the `Result` type. It holds a `data` property
- * of type `T` (the success value) and an `error` property explicitly set to `null`,
- * signifying no error occurred.
- *
- * Use this type in conjunction with `Err<E>` and `Result<T, E>`.
- *
- * @template T - The type of the success value contained within.
- */
-type Ok<T> = {
-  data: T;
-  error: null;
-};
-/**
- * Represents the failure outcome of an operation, encapsulating the error value.
- *
- * This is the 'Err' variant of the `Result` type. It holds an `error` property
- * of type `E` (the error value) and a `data` property explicitly set to `null`,
- * signifying that no success value is present due to the failure.
- *
- * Use this type in conjunction with `Ok<T>` and `Result<T, E>`.
- *
- * @template E - The type of the error value contained within.
- */
-type Err<E> = {
-  error: E;
-  data: null;
-};
-/**
- * A type that represents the outcome of an operation that can either succeed or fail.
- *
- * `Result<T, E>` is a discriminated union type with two possible variants:
- * - `Ok<T>`: Represents a successful outcome, containing a `data` field with the success value of type `T`.
- *            In this case, the `error` field is `null`.
- * - `Err<E>`: Represents a failure outcome, containing an `error` field with the error value of type `E`.
- *            In this case, the `data` field is `null`.
- *
- * This type promotes explicit error handling by requiring developers to check
- * the variant of the `Result` before accessing its potential value or error.
- * It helps avoid runtime errors often associated with implicit error handling (e.g., relying on `try-catch` for all errors).
- *
- * @template T - The type of the success value if the operation is successful (held in `Ok<T>`).
- * @template E - The type of the error value if the operation fails (held in `Err<E>`).
- * @example
- * ```ts
- * function divide(numerator: number, denominator: number): Result<number, string> {
- *   if (denominator === 0) {
- *     return Err("Cannot divide by zero");
- *   }
- *   return Ok(numerator / denominator);
- * }
- *
- * const result1 = divide(10, 2);
- * if (isOk(result1)) {
- *   console.log("Success:", result1.data); // Output: Success: 5
- * }
- *
- * const result2 = divide(10, 0);
- * if (isErr(result2)) {
- *   console.error("Failure:", result2.error); // Output: Failure: Cannot divide by zero
- * }
- * ```
- */
-type Result<T, E> = Ok<T> | Err<E>;
-/**
- * Constructs an `Ok<T>` variant, representing a successful outcome.
- *
- * This factory function creates the success variant of a `Result`.
- * It wraps the provided `data` (the success value) and ensures the `error` property is `null`.
- *
- * @template T - The type of the success value.
- * @param data - The success value to be wrapped in the `Ok` variant.
- * @returns An `Ok<T>` object with the provided data and `error` set to `null`.
- * @example
- * ```ts
- * const successfulResult = Ok("Operation completed successfully");
- * // successfulResult is { data: "Operation completed successfully", error: null }
- * ```
- */
-declare const Ok: <T>(data: T) => Ok<T>;
-/**
- * Constructs an `Err<E>` variant, representing a failure outcome.
- *
- * This factory function creates the error variant of a `Result`.
- * It wraps the provided `error` (the error value) and ensures the `data` property is `null`.
- *
- * @template E - The type of the error value.
- * @param error - The error value to be wrapped in the `Err` variant. This value represents the specific error that occurred.
- * @returns An `Err<E>` object with the provided error and `data` set to `null`.
- * @example
- * ```ts
- * const failedResult = Err(new TypeError("Invalid input"));
- * // failedResult is { error: TypeError("Invalid input"), data: null }
- * ```
- */
-declare const Err: <E>(error: E) => Err<E>;
-/**
- * Utility type to extract the `Ok<T>` variant from a `Result<T, E>` union type.
- *
- * If `R` is a `Result` type (e.g., `Result<string, Error>`), this type will resolve
- * to `Ok<string>`. This can be useful in generic contexts or for type narrowing.
- *
- * @template R - The `Result<T, E>` union type from which to extract the `Ok<T>` variant.
- *             Must extend `Result<unknown, unknown>`.
- */
-type ExtractOkFromResult<R extends Result<unknown, unknown>> = Extract<R, {
-  error: null;
-}>;
-/**
- * Utility type to extract the `Err<E>` variant from a `Result<T, E>` union type.
- *
- * If `R` is a `Result` type (e.g., `Result<string, Error>`), this type will resolve
- * to `Err<Error>`. This can be useful in generic contexts or for type narrowing.
- *
- * @template R - The `Result<T, E>` union type from which to extract the `Err<E>` variant.
- *             Must extend `Result<unknown, unknown>`.
- */
-type ExtractErrFromResult<R extends Result<unknown, unknown>> = Extract<R, {
-  data: null;
-}>;
-/**
- * Utility type to extract the success value's type `T` from a `Result<T, E>` type.
- *
- * If `R` is an `Ok<T>` variant (or a `Result<T, E>` that could be an `Ok<T>`),
- * this type resolves to `T`. If `R` can only be an `Err<E>` variant, it resolves to `never`.
- * This is useful for obtaining the type of the `data` field when you know you have a success.
- *
- * @template R - The `Result<T, E>` type from which to extract the success value's type.
- *             Must extend `Result<unknown, unknown>`.
- * @example
- * ```ts
- * type MyResult = Result<number, string>;
- * type SuccessValueType = UnwrapOk<MyResult>; // SuccessValueType is number
- *
- * type MyErrorResult = Err<string>;
- * type ErrorValueType = UnwrapOk<MyErrorResult>; // ErrorValueType is never
- * ```
- */
-type UnwrapOk<R extends Result<unknown, unknown>> = R extends Ok<infer U> ? U : never;
-/**
- * Utility type to extract the error value's type `E` from a `Result<T, E>` type.
- *
- * If `R` is an `Err<E>` variant (or a `Result<T, E>` that could be an `Err<E>`),
- * this type resolves to `E`. If `R` can only be an `Ok<T>` variant, it resolves to `never`.
- * This is useful for obtaining the type of the `error` field when you know you have a failure.
- *
- * @template R - The `Result<T, E>` type from which to extract the error value's type.
- *             Must extend `Result<unknown, unknown>`.
- * @example
- * ```ts
- * type MyResult = Result<number, string>;
- * type ErrorValueType = UnwrapErr<MyResult>; // ErrorValueType is string
- *
- * type MySuccessResult = Ok<number>;
- * type SuccessValueType = UnwrapErr<MySuccessResult>; // SuccessValueType is never
- * ```
- */
-type UnwrapErr<R extends Result<unknown, unknown>> = R extends Err<infer E> ? E : never;
-/**
- * Type guard to runtime check if an unknown value is a valid `Result<T, E>`.
- *
- * A value is considered a valid `Result` if:
- * 1. It is a non-null object.
- * 2. It has both `data` and `error` properties.
- * 3. Exactly one of `data` or `error` is `null`. The other must be non-`null`.
- *
- * This function does not validate the types of `data` or `error` beyond `null` checks.
- *
- * @template T - The expected type of the success value if the value is an `Ok` variant (defaults to `unknown`).
- * @template E - The expected type of the error value if the value is an `Err` variant (defaults to `unknown`).
- * @param value - The value to check.
- * @returns `true` if the value conforms to the `Result` structure, `false` otherwise.
- *          If `true`, TypeScript's type system will narrow `value` to `Result<T, E>`.
- * @example
- * ```ts
- * declare const someValue: unknown;
- *
- * if (isResult<string, Error>(someValue)) {
- *   // someValue is now typed as Result<string, Error>
- *   if (isOk(someValue)) {
- *     console.log(someValue.data); // string
- *   } else {
- *     console.error(someValue.error); // Error
- *   }
- * }
- * ```
- */
-declare function isResult<T = unknown, E = unknown>(value: unknown): value is Result<T, E>;
-/**
- * Type guard to runtime check if a `Result<T, E>` is an `Ok<T>` variant.
- *
- * This function narrows the type of a `Result` to `Ok<T>` if it represents a successful outcome.
- * An `Ok<T>` variant is identified by its `error` property being `null`.
- *
- * @template T - The success value type.
- * @template E - The error value type.
- * @param result - The `Result<T, E>` to check.
- * @returns `true` if the `result` is an `Ok<T>` variant, `false` otherwise.
- *          If `true`, TypeScript's type system will narrow `result` to `Ok<T>`.
- * @example
- * ```ts
- * declare const myResult: Result<number, string>;
- *
- * if (isOk(myResult)) {
- *   // myResult is now typed as Ok<number>
- *   console.log("Success value:", myResult.data); // myResult.data is number
- * }
- * ```
- */
-declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
-/**
- * Type guard to runtime check if a `Result<T, E>` is an `Err<E>` variant.
- *
- * This function narrows the type of a `Result` to `Err<E>` if it represents a failure outcome.
- * An `Err<E>` variant is identified by its `error` property being non-`null` (and thus `data` being `null`).
- *
- * @template T - The success value type.
- * @template E - The error value type.
- * @param result - The `Result<T, E>` to check.
- * @returns `true` if the `result` is an `Err<E>` variant, `false` otherwise.
- *          If `true`, TypeScript's type system will narrow `result` to `Err<E>`.
- * @example
- * ```ts
- * declare const myResult: Result<number, string>;
- *
- * if (isErr(myResult)) {
- *   // myResult is now typed as Err<string>
- *   console.error("Error value:", myResult.error); // myResult.error is string
- * }
- * ```
- */
-declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
-/**
- * Executes a synchronous operation and wraps its outcome (success or failure) in a `Result<T, E>`.
- *
- * This function attempts to execute the `operation`.
- * - If `operation` completes successfully, its return value is wrapped in an `Ok<T>` variant.
- * - If `operation` throws an exception, the caught exception (of type `unknown`) is passed to
- *   the `mapError` function. `mapError` is responsible for transforming this `unknown`
- *   exception into a well-typed error value of type `E`. This error value is then wrapped
- *   in an `Err<E>` variant.
- *
- * @template T - The type of the success value returned by the `operation` if it succeeds.
- * @template E - The type of the error value produced by `mapError` if the `operation` fails.
- * @param options - An object containing the operation and error mapping function.
- * @param options.try - The synchronous operation to execute. This function is expected to return a value of type `T`.
- * @param options.mapError - A function that takes the `unknown` exception caught from `options.try`
- *                         and transforms it into a specific error value of type `E`. This function
- *                         is crucial for creating a well-typed error for the `Err<E>` variant.
- * @returns A `Result<T, E>`: `Ok<T>` if `options.try` succeeds, or `Err<E>` if it throws and `options.mapError` provides an error value.
- * @example
- * ```ts
- * function parseJson(jsonString: string): Result<object, SyntaxError> {
- *   return trySync({
- *     try: () => JSON.parse(jsonString),
- *     mapError: (err: unknown) => {
- *       if (err instanceof SyntaxError) return err;
- *       return new SyntaxError("Unknown parsing error");
- *     }
- *   });
- * }
- *
- * const validResult = parseJson('{"name":"Result"}'); // Ok<{name: string}>
- * const invalidResult = parseJson('invalid json');    // Err<SyntaxError>
- *
- * if (isOk(validResult)) console.log(validResult.data);
- * if (isErr(invalidResult)) console.error(invalidResult.error.message);
- * ```
- */
-declare function trySync<T, E>({
-  try: operation,
-  mapError
-}: {
-  try: () => T;
-  mapError: (error: unknown) => E;
-}): Result<T, E>;
-/**
- * Executes an asynchronous operation (returning a `Promise`) and wraps its outcome in a `Promise<Result<T, E>>`.
- *
- * This function attempts to execute the asynchronous `operation`.
- * - If the `Promise` returned by `operation` resolves successfully, its resolved value is wrapped in an `Ok<T>` variant.
- * - If the `Promise` returned by `operation` rejects, or if `operation` itself throws an exception synchronously,
- *   the caught exception/rejection reason (of type `unknown`) is passed to the `mapError` function.
- *   `mapError` is responsible for transforming this `unknown` error into a well-typed error value of type `E`.
- *   This error value is then wrapped in an `Err<E>` variant.
- *
- * The entire outcome (`Ok<T>` or `Err<E>`) is wrapped in a `Promise`.
- *
- * @template T - The type of the success value the `Promise` from `operation` resolves to.
- * @template E - The type of the error value produced by `mapError` if the `operation` fails or rejects.
- * @param options - An object containing the asynchronous operation and error mapping function.
- * @param options.try - The asynchronous operation to execute. This function must return a `Promise<T>`.
- * @param options.mapError - A function that takes the `unknown` exception/rejection reason caught from `options.try`
- *                         and transforms it into a specific error value of type `E`. This function
- *                         is crucial for creating a well-typed error for the `Err<E>` variant.
- * @returns A `Promise` that resolves to a `Result<T, E>`: `Ok<T>` if `options.try`'s `Promise` resolves,
- *          or `Err<E>` if it rejects/throws and `options.mapError` provides an error value.
- * @example
- * ```ts
- * async function fetchData(url: string): Promise<Result<Response, Error>> {
- *   return tryAsync({
- *     try: async () => fetch(url),
- *     mapError: (err: unknown) => {
- *       if (err instanceof Error) return err;
- *       return new Error("Network request failed");
- *     }
- *   });
- * }
- *
- * async function processData() {
- *   const result = await fetchData("/api/data");
- *   if (isOk(result)) {
- *     const response = result.data;
- *     console.log("Data fetched:", await response.json());
- *   } else {
- *     console.error("Fetch error:", result.error.message);
- *   }
- * }
- * processData();
- * ```
- */
-declare function tryAsync<T, E>({
-  try: operation,
-  mapError
-}: {
-  try: () => Promise<T>;
-  mapError: (error: unknown) => E;
-}): Promise<Result<T, E>>;
-/**
- * Resolves a value that may or may not be wrapped in a `Result`, returning the final value.
- *
- * This function handles the common pattern where a value might be a `Result<T, E>` or a plain `T`:
- * - If `value` is an `Ok<T>` variant, returns the contained success value.
- * - If `value` is an `Err<E>` variant, throws the contained error value.
- * - If `value` is not a `Result` (i.e., it's already a plain value of type `T`),
- *   returns it as-is.
- *
- * This is useful when working with APIs that might return either direct values or Results,
- * allowing you to normalize them to the actual value or propagate errors via throwing.
- *
- * Use `resolve` when the input might or might not be a Result.
- * Use `unwrap` when you know the input is definitely a Result.
- *
- * @template T - The type of the success value (if `value` is `Ok<T>`) or the type of the plain value.
- * @template E - The type of the error value (if `value` is `Err<E>`).
- * @param value - The value to resolve. Can be a `Result<T, E>` or a plain value of type `T`.
- * @returns The final value of type `T` if `value` is `Ok<T>` or if `value` is already a plain `T`.
- * @throws The error value `E` if `value` is an `Err<E>` variant.
- *
- * @example
- * ```ts
- * // Example with an Ok variant
- * const okResult = Ok("success data");
- * const resolved = resolve(okResult); // "success data"
- *
- * // Example with an Err variant
- * const errResult = Err(new Error("failure"));
- * try {
- *   resolve(errResult);
- * } catch (e) {
- *   console.error(e.message); // "failure"
- * }
- *
- * // Example with a plain value
- * const plainValue = "plain data";
- * const resolved = resolve(plainValue); // "plain data"
- *
- * // Example with a function that might return Result or plain value
- * declare function mightReturnResult(): string | Result<string, Error>;
- * const outcome = mightReturnResult();
- * try {
- *  const finalValue = resolve(outcome); // handles both cases
- *  console.log("Final value:", finalValue);
- * } catch (e) {
- *  console.error("Operation failed:", e);
- * }
- * ```
- */
-/**
- * Unwraps a `Result<T, E>`, returning the success value or throwing the error.
- *
- * This function extracts the data from a `Result`:
- * - If the `Result` is an `Ok<T>` variant, returns the contained success value of type `T`.
- * - If the `Result` is an `Err<E>` variant, throws the contained error value of type `E`.
- *
- * Unlike `resolve`, this function expects the input to always be a `Result` type,
- * making it more direct for cases where you know you're working with a `Result`.
- *
- * @template T - The type of the success value contained in the `Ok<T>` variant.
- * @template E - The type of the error value contained in the `Err<E>` variant.
- * @param result - The `Result<T, E>` to unwrap.
- * @returns The success value of type `T` if the `Result` is `Ok<T>`.
- * @throws The error value of type `E` if the `Result` is `Err<E>`.
- *
- * @example
- * ```ts
- * // Example with an Ok variant
- * const okResult = Ok("success data");
- * const value = unwrap(okResult); // "success data"
- *
- * // Example with an Err variant
- * const errResult = Err(new Error("something went wrong"));
- * try {
- *   unwrap(errResult);
- * } catch (error) {
- *   console.error(error.message); // "something went wrong"
- * }
- *
- * // Usage in a function that returns Result
- * function divide(a: number, b: number): Result<number, string> {
- *   if (b === 0) return Err("Division by zero");
- *   return Ok(a / b);
- * }
- *
- * try {
- *   const result = unwrap(divide(10, 2)); // 5
- *   console.log("Result:", result);
- * } catch (error) {
- *   console.error("Division failed:", error);
- * }
- * ```
- */
-declare function unwrap<T, E>(result: Result<T, E>): T;
-declare function resolve<T, E>(value: T | Result<T, E>): T;
-//# sourceMappingURL=result.d.ts.map
-//#endregion
+import { Err, ExtractErrFromResult, ExtractOkFromResult, Ok, Result, UnwrapErr, UnwrapOk, isErr, isOk, isResult, resolve, tryAsync, trySync, unwrap } from "../result-Bi5hwqKw.js";
+
 //#region src/result/utils.d.ts
+
 /**
  * Partitions an array of Result objects into two separate arrays based on their status.
  *
@@ -449,7 +23,6 @@ declare function partitionResults<T, E>(results: Result<T, E>[]): {
   errs: Err<E>[];
 };
 //# sourceMappingURL=utils.d.ts.map
-
 //#endregion
 export { Err, ExtractErrFromResult, ExtractOkFromResult, Ok, Result, UnwrapErr, UnwrapOk, isErr, isOk, isResult, partitionResults, resolve, tryAsync, trySync, unwrap };
 //# sourceMappingURL=index.d.ts.map