@shirudo/ddd-kit 1.0.0-rc.1 → 1.0.0-rc.2

package/dist/result-jCwPSjFa.d.ts

@@ -1,352 +0,0 @@
-type Ok<T> = {
-    ok: true;
-    value: T;
-};
-type Err<E> = {
-    ok: false;
-    error: E;
-};
-type Result<T, E> = Ok<T> | Err<E>;
-/**
- * Creates an Ok result with a value.
- *
- * @param value - The success value
- * @returns An Ok result containing the value
- *
- * @example
- * ```typescript
- * const result = ok(42);
- * // result is Ok<number>
- * ```
- */
-declare function ok<T>(value: T): Ok<T>;
-/**
- * Creates an Ok result with void (no value).
- *
- * @returns An Ok<void> result
- *
- * @example
- * ```typescript
- * const result = ok();
- * // result is Ok<void>
- * ```
- */
-declare function ok(): Ok<void>;
-/**
- * Creates an Err result with an error.
- *
- * @param error - The error value
- * @returns An Err result containing the error
- *
- * @example
- * ```typescript
- * const result = err("Something went wrong");
- * // result is Err<string>
- * ```
- */
-declare function err<E>(error: E): Err<E>;
-/**
- * Creates an Err result with void (no error value).
- *
- * @returns An Err<void> result
- *
- * @example
- * ```typescript
- * const result = err();
- * // result is Err<void>
- * ```
- */
-declare function err(): Err<void>;
-/**
- * Type guard to check if a Result is Ok.
- * Narrows the type to Ok<T> when returning true.
- *
- * @param result - The result to check
- * @returns true if the result is Ok, false otherwise
- *
- * @example
- * ```typescript
- * const result = voWithValidation(data, validator);
- * if (isOk(result)) {
- *   // TypeScript knows result is Ok<VO<T>>
- *   console.log(result.value);
- * }
- * ```
- */
-declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
-/**
- * Type guard to check if a Result is Err.
- * Narrows the type to Err<E> when returning true.
- *
- * @param result - The result to check
- * @returns true if the result is Err, false otherwise
- *
- * @example
- * ```typescript
- * const result = voWithValidation(data, validator);
- * if (isErr(result)) {
- *   // TypeScript knows result is Err<string>
- *   console.error(result.error);
- * }
- * ```
- */
-declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
-/**
- * Chains Result operations (flatMap/bind).
- * If the result is Ok, applies the function to the value.
- * If Err, returns the error unchanged.
- *
- * @param result - The result to chain
- * @param fn - Function that takes the Ok value and returns a new Result
- * @returns A new Result
- *
- * @example
- * ```typescript
- * const result = validateUserId("123")
- *   .andThen(userId => validateEmail("test@example.com")
- *     .map(email => ({ id: userId, email }))
- *   );
- * ```
- */
-declare function andThen<T, E, U>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
-/**
- * Transforms the Ok value using a function.
- * If the result is Err, returns the error unchanged.
- *
- * @param result - The result to transform
- * @param fn - Function to transform the Ok value
- * @returns A new Result with transformed value
- *
- * @example
- * ```typescript
- * const result = ok(5);
- * const doubled = map(result, x => x * 2); // Ok<10>
- * ```
- */
-declare function map<T, E, U>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
-/**
- * Transforms the Err value using a function.
- * If the result is Ok, returns the value unchanged.
- *
- * @param result - The result to transform
- * @param fn - Function to transform the Err value
- * @returns A new Result with transformed error
- *
- * @example
- * ```typescript
- * const result = err("not found");
- * const mapped = mapErr(result, e => `Error: ${e}`); // Err<"Error: not found">
- * ```
- */
-declare function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
-/**
- * Returns the value if Ok, otherwise returns the default value.
- *
- * @param result - The result to unwrap
- * @param defaultValue - Default value to return if Err
- * @returns The Ok value or the default value
- *
- * @example
- * ```typescript
- * const result = validateUserId("123");
- * const userId = unwrapOr(result, "default-id");
- * ```
- */
-declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
-/**
- * Returns the value if Ok, otherwise computes default from error.
- *
- * @param result - The result to unwrap
- * @param fn - Function to compute default from error
- * @returns The Ok value or computed default
- *
- * @example
- * ```typescript
- * const result = validateUserId("");
- * const userId = unwrapOrElse(result, err => `fallback-${Date.now()}`);
- * ```
- */
-declare function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T;
-/**
- * Pattern matching for Result.
- * Applies one function if Ok, another if Err.
- *
- * @param result - The result to match
- * @param onOk - Function to apply if Ok
- * @param onErr - Function to apply if Err
- * @returns The result of applying the appropriate function
- *
- * @example
- * ```typescript
- * const message = match(result,
- *   value => `Success: ${value}`,
- *   error => `Error: ${error}`
- * );
- * ```
- *
- * @example Using object syntax
- * ```typescript
- * const message = match(result, {
- *   ok: value => `Success: ${value}`,
- *   err: error => `Error: ${error}`
- * });
- * ```
- */
-declare function match<T, E, R>(result: Result<T, E>, onOk: (value: T) => R, onErr: (error: E) => R): R;
-declare function match<T, E, R>(result: Result<T, E>, handlers: {
-    ok: (value: T) => R;
-    err: (error: E) => R;
-}): R;
-/**
- * Async pattern matching for Result.
- * Applies one async function if Ok, another if Err.
- * Both handlers must return Promises.
- *
- * @param result - The result to match
- * @param onOk - Async function to apply if Ok
- * @param onErr - Async function to apply if Err
- * @returns Promise resolving to the result of applying the appropriate function
- *
- * @example
- * ```typescript
- * const message = await matchAsync(result,
- *   async (value) => `Success: ${value}`,
- *   async (error) => `Error: ${error}`
- * );
- * ```
- *
- * @example Using object syntax
- * ```typescript
- * const message = await matchAsync(result, {
- *   ok: async (value) => `Success: ${value}`,
- *   err: async (error) => `Error: ${error}`
- * });
- * ```
- */
-declare function matchAsync<T, E, R>(result: Result<T, E>, onOk: (value: T) => Promise<R>, onErr: (error: E) => Promise<R>): Promise<R>;
-declare function matchAsync<T, E, R>(result: Result<T, E>, handlers: {
-    ok: (value: T) => Promise<R>;
-    err: (error: E) => Promise<R>;
-}): Promise<R>;
-/**
- * Pattern matching for Result that returns a Result.
- * Both handlers must return a Result, allowing you to transform
- * both the success and error cases while staying in Result context.
- *
- * @param result - The result to match
- * @param handlers - Object with ok and err handlers, both returning Result
- * @returns A new Result from the appropriate handler
- *
- * @example
- * ```typescript
- * const result = await fetchUser(id);
- * return matchResult(result, {
- *   ok: (user) => ok(transformUser(user)),
- *   err: (error) => err(mapToAppError(error))
- * });
- * ```
- */
-declare function matchResult<T, E, U, F>(result: Result<T, E>, handlers: {
-    ok: (value: T) => Result<U, F>;
-    err: (error: E) => Result<U, F>;
-}): Result<U, F>;
-declare function matchResult<T, E, U, F>(result: Result<T, E>, onOk: (value: T) => Result<U, F>, onErr: (error: E) => Result<U, F>): Result<U, F>;
-/**
- * Pipes a Result through multiple operations.
- * Each function receives the previous Result and returns a new Result.
- * Stops on first error.
- *
- * @param initial - The initial Result value
- * @param fns - Array of functions that take the previous Result and return a new Result
- * @returns The final Result after all operations
- *
- * @example
- * ```typescript
- * // Instead of nested andThen calls:
- * andThen(
- *   updateCountryCode(code),
- *   () => andThen(updateCurrencyCode(currency), () => updateLanguageCode(lang))
- * )
- *
- * // Use pipe (cleaner and more readable):
- * pipe(
- *   updateCountryCode(code),
- *   () => updateCurrencyCode(currency),
- *   () => updateLanguageCode(lang)
- * )
- * ```
- *
- * @example With void results
- * ```typescript
- * setInitialData(initialData: JobConfigProps["initialData"]): Result<void, JobDomainError> {
- *   return pipe(
- *     this.updateCountryCode(initialData.countryCode),
- *     () => this.updateCurrencyCode(initialData.currencyCode),
- *     () => this.updateLanguageCode(initialData.languageCode)
- *   );
- * }
- * ```
- */
-declare function pipe<T, E>(initial: Result<T, E>, ...fns: Array<(prev: Result<T, E>) => Result<T, E>>): Result<T, E>;
-/**
- * Wraps a function that may throw exceptions into a Result type.
- * Catches any thrown exceptions and converts them to Err results.
- *
- * @param fn - Function that may throw exceptions
- * @param errorMapper - Optional function to transform the caught error
- * @returns A Result containing the function's return value or error
- *
- * @example
- * ```typescript
- * function riskyOperation(): string {
- *   if (Math.random() > 0.5) {
- *     throw new Error("Something went wrong");
- *   }
- *   return "success";
- * }
- *
- * const result = tryCatch(() => riskyOperation());
- * if (result.ok) {
- *   console.log(result.value); // "success"
- * } else {
- *   console.error(result.error.message); // "Something went wrong"
- * }
- * ```
- *
- * @example With custom error mapper
- * ```typescript
- * const result = tryCatch(
- *   () => riskyOperation(),
- *   (error) => `Custom: ${error instanceof Error ? error.message : String(error)}`
- * );
- * ```
- */
-declare function tryCatch<T, E = Error>(fn: () => T, errorMapper?: (error: unknown) => E): Result<T, E>;
-/**
- * Wraps an async function that may throw exceptions into a Promise<Result>.
- * Catches any thrown exceptions and converts them to Err results.
- *
- * @param fn - Async function that may throw exceptions
- * @param errorMapper - Optional function to transform the caught error
- * @returns A Promise resolving to a Result containing the function's return value or error
- *
- * @example
- * ```typescript
- * async function riskyAsyncOperation(): Promise<string> {
- *   if (Math.random() > 0.5) {
- *     throw new Error("Something went wrong");
- *   }
- *   return "success";
- * }
- *
- * const result = await tryCatchAsync(() => riskyAsyncOperation());
- * if (result.ok) {
- *   console.log(result.value); // "success"
- * } else {
- *   console.error(result.error.message); // "Something went wrong"
- * }
- * ```
- */
-declare function tryCatchAsync<T, E = Error>(fn: () => Promise<T>, errorMapper?: (error: unknown) => E): Promise<Result<T, E>>;
-
-export { type Err as E, type Ok as O, type Result as R, andThen as a, isOk as b, mapErr as c, match as d, err as e, matchAsync as f, matchResult as g, tryCatchAsync as h, isErr as i, unwrapOrElse as j, map as m, ok as o, pipe as p, tryCatch as t, unwrapOr as u };

package/dist/result.d.ts

@@ -1,204 +0,0 @@
-import { R as Result } from './result-jCwPSjFa.js';
-export { E as Err, O as Ok, a as andThen, e as err, i as isErr, b as isOk, m as map, c as mapErr, d as match, f as matchAsync, g as matchResult, o as ok, p as pipe, t as tryCatch, h as tryCatchAsync, u as unwrapOr, j as unwrapOrElse } from './result-jCwPSjFa.js';
-
-/**
- * Base class for Result with method chaining support.
- * Provides common methods for both Ok and Err classes.
- */
-declare abstract class ResultBase<T, E> {
-    protected readonly _result: Result<T, E>;
-    protected constructor(result: Result<T, E>);
-    /**
-     * Returns the value if Ok, otherwise throws an error.
-     * If error is an Error instance, throws it directly.
-     * Otherwise, wraps the error in a new Error.
-     *
-     * @throws Error if the result is Err
-     */
-    unwrap(): T;
-    /**
-     * Returns the value if Ok, otherwise returns the default value.
-     */
-    unwrapOr(defaultValue: T): T;
-    /**
-     * Returns the value if Ok, otherwise computes default from error.
-     */
-    unwrapOrElse(fn: (error: E) => T): T;
-    /**
-     * Pattern matching for Result.
-     * Applies one function if Ok, another if Err.
-     *
-     * @example
-     * ```typescript
-     * outcome.match(
-     *   value => `Success: ${value}`,
-     *   error => `Error: ${error}`
-     * );
-     * ```
-     *
-     * @example Using object syntax
-     * ```typescript
-     * outcome.match({
-     *   ok: value => `Success: ${value}`,
-     *   err: error => `Error: ${error}`
-     * });
-     * ```
-     */
-    match<R>(onOk: (value: T) => R, onErr: (error: E) => R): R;
-    match<R>(handlers: {
-        ok: (value: T) => R;
-        err: (error: E) => R;
-    }): R;
-    /**
-     * Async pattern matching for Result.
-     * Applies one async function if Ok, another if Err.
-     *
-     * @example
-     * ```typescript
-     * await outcome.matchAsync(
-     *   async (value) => `Success: ${value}`,
-     *   async (error) => `Error: ${error}`
-     * );
-     * ```
-     *
-     * @example Using object syntax
-     * ```typescript
-     * await outcome.matchAsync({
-     *   ok: async (value) => `Success: ${value}`,
-     *   err: async (error) => `Error: ${error}`
-     * });
-     * ```
-     */
-    matchAsync<R>(onOk: (value: T) => Promise<R>, onErr: (error: E) => Promise<R>): Promise<R>;
-    matchAsync<R>(handlers: {
-        ok: (value: T) => Promise<R>;
-        err: (error: E) => Promise<R>;
-    }): Promise<R>;
-    /**
-     * Type guard to check if the result is Ok.
-     */
-    isOk(): this is Success<T>;
-    /**
-     * Type guard to check if the result is Err.
-     */
-    isErr(): this is Erroneous<E>;
-    /**
-     * Gets the underlying Result value.
-     */
-    get result(): Result<T, E>;
-}
-/**
- * Class representing a successful result with method chaining support.
- * Use this for class-based API with method chaining.
- *
- * @example
- * ```typescript
- * const okResult = Ok(1);
- * const doubled = okResult.map(x => x * 2).unwrap(); // 2
- *
- * const chained = Ok(5)
- *   .andThen(x => Ok(x * 2))
- *   .map(x => x + 1)
- *   .unwrap(); // 11
- * ```
- */
-declare class Success<T> extends ResultBase<T, never> {
-    constructor(value: T);
-    /**
-     * Factory function to create an Ok instance.
-     * Can be called with or without `new`.
-     */
-    static of<T>(value: T): Success<T>;
-    /**
-     * Chains Result operations (flatMap/bind).
-     * If the result is Ok, applies the function to the value.
-     * If Err, returns the error unchanged.
-     */
-    andThen<U, E>(fn: (value: T) => Result<U, E>): Success<U> | Erroneous<E>;
-    /**
-     * Transforms the Ok value using a function.
-     * If the result is Err, returns the error unchanged.
-     */
-    map<U>(fn: (value: T) => U): Success<U>;
-    /**
-     * Transforms the Err value using a function.
-     * If the result is Ok, returns the value unchanged.
-     */
-    mapErr<F>(_fn: (error: never) => F): Success<T>;
-}
-
-/**
- * Class representing an erroneous result with method chaining support.
- * Use this for class-based API with method chaining.
- *
- * @example
- * ```typescript
- * const errResult = Err(new Error("error"));
- * errResult.map(x => x * 2).unwrap(); // throws Error("error")
- *
- * const mapped = Err("original")
- *   .mapErr(e => `Error: ${e}`)
- *   .unwrap(); // throws Error("Error: original")
- * ```
- */
-declare class Erroneous<E> extends ResultBase<never, E> {
-    constructor(error: E);
-    /**
-     * Factory function to create an Err instance.
-     * Can be called with or without `new`.
-     */
-    static of<E>(error: E): Erroneous<E>;
-    /**
-     * Chains Result operations (flatMap/bind).
-     * If the result is Ok, applies the function to the value.
-     * If Err, returns the error unchanged.
-     */
-    andThen<U>(_fn: (value: never) => Result<U, E>): Erroneous<E>;
-    /**
-     * Transforms the Ok value using a function.
-     * If the result is Err, returns the error unchanged.
-     */
-    map<U>(_fn: (value: never) => U): Erroneous<E>;
-    /**
-     * Transforms the Err value using a function.
-     * If the result is Ok, returns the value unchanged.
-     */
-    mapErr<F>(fn: (error: E) => F): Erroneous<F>;
-}
-
-/**
- * Class-based API for Result with method chaining support.
- * Provides an object-oriented alternative to the functional Result type.
- * Use `Outcome.from()` to wrap an existing Result, or `Outcome.ok()` / `Outcome.err()` to create new instances.
- *
- * @example
- * ```typescript
- * // Wrap an existing Result
- * const result = Outcome.from(ok(1));
- * const doubled = result.map(x => x * 2).unwrap(); // 2
- *
- * // Create directly
- * const outcome = Outcome.ok(42);
- * const value = outcome.map(x => x + 1).unwrap(); // 43
- * ```
- */
-declare class Outcome<T, E> extends ResultBase<T, E> {
-    private constructor();
-    /**
-     * Creates an Outcome from an Ok value.
-     */
-    static ok<T>(value: T): Success<T>;
-    /**
-     * Creates an Outcome from an Err value.
-     */
-    static err<E>(error: E): Erroneous<E>;
-    /**
-     * Creates an Outcome from a Result.
-     */
-    static from<T, E>(result: Result<T, E>): Outcome<T, E>;
-    andThen<U>(fn: (value: T) => Result<U, E>): Outcome<U, E>;
-    map<U>(fn: (value: T) => U): Outcome<U, E>;
-    mapErr<F>(fn: (error: E) => F): Outcome<T, F>;
-}
-
-export { Erroneous, Outcome, Result, Success };