wellcrafted 0.15.0

package/dist/index.d.ts

@@ -0,0 +1,509 @@
+//#region src/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>>;
+/**
+ * Unwraps a value if it is a `Result`, otherwise returns the value itself.
+ *
+ * - If `value` is an `Ok<T>` variant, its `data` (the success value) is returned.
+ * - If `value` is an `Err<E>` variant, its `error` (the error value) is thrown.
+ * - If `value` is not a `Result` (i.e., it's already a plain value of type `T`),
+ *   it is returned as-is.
+ *
+ * This function is useful for situations where an operation might return either a
+ * direct value or a `Result` wrapping a value/error, and you want to
+ * uniformly access the value or propagate the error via throwing.
+ *
+ * @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 unwrap. It can be a `Result<T, E>` or a plain value of type `T`.
+ * @returns The success value of type `T` if `value` is `Ok<T>` or if `value` is 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 unwrappedOk = unwrapIfResult(okResult); // "success data"
+ *
+ * // Example with an Err variant
+ * const errResult = Err(new Error("failure"));
+ * try {
+ *   unwrapIfResult(errResult);
+ * } catch (e) {
+ *   console.error(e.message); // "failure"
+ * }
+ *
+ * // Example with a plain value
+ * const plainValue = "plain data";
+ * const unwrappedPlain = unwrapIfResult(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 = unwrapIfResult(outcome); // handles both cases
+ *  console.log("Final value:", finalValue);
+ * } catch (e) {
+ *  console.error("Operation failed:", e);
+ * }
+ * ```
+ */
+declare function unwrapIfResult<T, E>(value: T | Result<T, E>): T;
+//# sourceMappingURL=result.d.ts.map
+//#endregion
+//#region src/utils.d.ts
+/**
+ * Partitions an array of Result objects into two separate arrays based on their status.
+ *
+ * @template T - The success type
+ * @template E - The error type
+ * @param results - An array of Result objects to partition
+ * @returns An object containing two arrays:
+ *   - `oks`: Array of successful Result objects (Ok<T>[])
+ *   - `errs`: Array of error Result objects (Err<E>[])
+ *
+ * @example
+ * const results = [Ok(1), Err("error"), Ok(2)];
+ * const { oks, errs } = partitionResults(results);
+ * // oks = [Ok(1), Ok(2)]
+ * // errs = [Err("error")]
+ */
+declare function partitionResults<T, E>(results: Result<T, E>[]): {
+  oks: Ok<T>[];
+  errs: Err<E>[];
+};
+//# sourceMappingURL=utils.d.ts.map
+//#endregion
+//#region src/error/types.d.ts
+type BaseError = Readonly<{
+  name: string;
+  message: string;
+  context: Record<string, unknown>;
+  cause: unknown;
+}>;
+/**
+ * Creates a tagged error type for type-safe error handling.
+ * Uses the `name` property as a discriminator for tagged unions.
+ *
+ * Error types should follow the convention of ending with "Error" suffix.
+ * The Err data structure wraps these error types in the Result system.
+ *
+ * @example
+ * ```ts
+ * type ValidationError = TaggedError<"ValidationError">
+ * type NetworkError = TaggedError<"NetworkError">
+ *
+ * function handleError(error: ValidationError | NetworkError) {
+ *   switch (error.name) {
+ *     case "ValidationError": // TypeScript knows this is ValidationError
+ *       break;
+ *     case "NetworkError": // TypeScript knows this is NetworkError
+ *       break;
+ *   }
+ * }
+ *
+ * // Used in Result types:
+ * function validate(input: string): Result<string, ValidationError> {
+ *   if (!input) {
+ *     return Err({
+ *       name: "ValidationError",
+ *       message: "Input is required",
+ *       context: { input },
+ *       cause: null,
+ *     });
+ *   }
+ *   return Ok(input);
+ * }
+ * ```
+ */
+type TaggedError<T extends string> = BaseError & {
+  readonly name: T;
+};
+declare function createTryFns<TName extends string>(name: TName): {
+  trySync: <T>({
+    try: operation,
+    mapErr
+  }: {
+    try: () => T;
+    mapErr: (error: unknown) => Omit<TaggedError<TName>, "name">;
+  }) => Result<T, TaggedError<TName>>;
+  tryAsync: <T>({
+    try: operation,
+    mapErr
+  }: {
+    try: () => Promise<T>;
+    mapErr: (error: unknown) => Omit<TaggedError<TName>, "name">;
+  }) => Promise<Result<T, TaggedError<TName>>>;
+};
+//# sourceMappingURL=types.d.ts.map
+//#endregion
+//#region src/error/utils.d.ts
+/**
+ * Extracts a readable error message from an unknown error value
+ *
+ * This utility is commonly used in mapError functions when converting
+ * unknown errors to typed error objects in the Result system.
+ *
+ * @param error - The unknown error to extract a message from
+ * @returns A string representation of the error
+ *
+ * @example
+ * ```ts
+ * // With native Error
+ * const error = new Error("Something went wrong");
+ * const message = extractErrorMessage(error); // "Something went wrong"
+ *
+ * // With string error
+ * const stringError = "String error";
+ * const message2 = extractErrorMessage(stringError); // "String error"
+ *
+ * // With object error
+ * const unknownError = { code: 500, details: "Server error" };
+ * const message3 = extractErrorMessage(unknownError); // '{"code":500,"details":"Server error"}'
+ *
+ * // Used in mapError function
+ * const result = await tryAsync({
+ *   try: () => riskyOperation(),
+ *   mapError: (error): NetworkError => ({
+ *     name: "NetworkError",
+ *     message: extractErrorMessage(error),
+ *     context: { operation: "riskyOperation" },
+ *     cause: error,
+ *   }),
+ * });
+ * ```
+ */
+declare function extractErrorMessage(error: unknown): string;
+//# sourceMappingURL=utils.d.ts.map
+
+//#endregion
+export { BaseError, Err, ExtractErrFromResult, ExtractOkFromResult, Ok, Result, TaggedError, UnwrapErr, UnwrapOk, createTryFns, extractErrorMessage, isErr, isOk, isResult, partitionResults, tryAsync, trySync, unwrapIfResult };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/result.ts","../src/utils.ts","../src/error/types.ts","../src/error/utils.ts"],"sourcesContent":[],"mappings":"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"}