ts-data-forge 3.3.1 → 4.1.0

package/dist/functional/optional.d.mts

@@ -1,482 +0,0 @@
-/** @internal String literal tag to identify the 'Some' variant of Optional. */
-declare const SomeTypeTagName = "ts-data-forge::Optional.some";
-/** @internal String literal tag to identify the 'None' variant of Optional. */
-declare const NoneTypeTagName = "ts-data-forge::Optional.none";
-/**
- * @template S The type of the contained value.
- * @internal
- * Represents the 'Some' variant of an Optional, containing a value.
- */
-type Some_<S> = Readonly<{
-    /**
-     * @internal
-     * Discriminant property for the 'Some' type.
-     */
-    $$tag: typeof SomeTypeTagName;
-    /** The contained value. */
-    value: S;
-}>;
-/**
- * @internal
- * Represents the 'None' variant of an Optional, indicating the absence of a value.
- */
-type None_ = Readonly<{
-    /**
-     * @internal
-     * Discriminant property for the 'None' type.
-     */
-    $$tag: typeof NoneTypeTagName;
-}>;
-/**
- * Represents an optional value that can either be 'Some' (containing a value)
- * or 'None' (empty).
- *
- * @template S The type of the value that might be present.
- */
-export type Optional<S> = None_ | Some_<S>;
-/**
- * Namespace for the {@link Optional} type and related functions. Provides
- * utilities to handle values that might be absent, similar to Option types in
- * other languages.
- */
-export declare namespace Optional {
-    /**
-     * Checks if the given value is an {@link Optional}.
-     *
-     * @example
-     *
-     * ```ts
-     * const maybeOptional = Optional.some('value');
-     * const notOptional = { $$tag: 'ts-data-forge::Optional.some' };
-     *
-     * assert.ok(Optional.isOptional(maybeOptional));
-     * assert.notOk(Optional.isOptional(notOptional));
-     * ```
-     *
-     * @param maybeOptional The value to check.
-     * @returns `true` if the value is an {@link Optional}, otherwise `false`.
-     */
-    const isOptional: (maybeOptional: unknown) => maybeOptional is Optional<unknown>;
-    /**
-     * Represents an {@link Optional} that contains a value.
-     *
-     * @template S The type of the contained value.
-     */
-    type Some<S> = Some_<S>;
-    /** Represents an {@link Optional} that does not contain a value (is empty). */
-    type None = None_;
-    /**
-     * Base type for any {@link Optional}, used for generic constraints. Represents
-     * an {@link Optional} with an unknown value type.
-     */
-    type Base = Optional<unknown>;
-    /**
-     * Extracts the value type `S` from an {@link Optional.Some}<S>. If the
-     * {@link Optional} is {@link Optional.None}, resolves to `never`.
-     *
-     * @template O The {@link Optional.Base} type to unwrap.
-     */
-    type Unwrap<O extends Base> = O extends Some<infer S> ? S : never;
-    /**
-     * Narrows an {@link Optional.Base} type to {@link Optional.Some}<S> if it is a
-     * {@link Optional.Some}. If the {@link Optional} is {@link Optional.None},
-     * resolves to `never`.
-     *
-     * @template O The {@link Optional.Base} type to narrow.
-     */
-    type NarrowToSome<O extends Base> = O extends None ? never : O;
-    /**
-     * Narrows an {@link Optional.Base} type to {@link Optional.None} if it is a
-     * {@link Optional.None}. If the {@link Optional} is {@link Optional.Some}<S>,
-     * resolves to `never`.
-     *
-     * @template O The {@link Optional.Base} type to narrow.
-     */
-    type NarrowToNone<O extends Base> = O extends None ? O : never;
-    /**
-     * Creates an {@link Optional.Some} containing the given value.
-     *
-     * @example
-     *
-     * ```ts
-     * const someValue = Optional.some({ id: 1 });
-     * const noneValue = Optional.none;
-     *
-     * assert.ok(Optional.isSome(someValue));
-     * assert.ok(Optional.isNone(noneValue));
-     * ```
-     *
-     * @template S The type of the value.
-     * @param value The value to wrap in an {@link Optional.Some}.
-     * @returns An {@link Optional.Some}<S> containing the value.
-     */
-    const some: <S>(value: S) => Some<S>;
-    /**
-     * The singleton instance representing {@link Optional.None} (an empty
-     * Optional).
-     *
-     * @example
-     *
-     * ```ts
-     * const someValue = Optional.some({ id: 1 });
-     * const noneValue = Optional.none;
-     *
-     * assert.ok(Optional.isSome(someValue));
-     * assert.ok(Optional.isNone(noneValue));
-     * ```
-     */
-    const none: None;
-    /**
-     * Checks if an {@link Optional} is {@link Optional.Some}. Acts as a type guard.
-     *
-     * @example
-     *
-     * ```ts
-     * const optionalNumber = Optional.some(42);
-     *
-     * if (Optional.isSome(optionalNumber)) {
-     *   const value: number = optionalNumber.value;
-     *   assert(value === 42);
-     * }
-     * ```
-     *
-     * @template O The {@link Optional.Base} type to check.
-     * @param optional The {@link Optional} to check.
-     * @returns `true` if the {@link Optional} is {@link Optional.Some}, `false`
-     *   otherwise.
-     */
-    const isSome: <O extends Base>(optional: O) => optional is NarrowToSome<O>;
-    /**
-     * Checks if an {@link Optional} is {@link Optional.None}. Acts as a type guard.
-     *
-     * @example
-     *
-     * ```ts
-     * const optionalValue = Optional.none as Optional<number>;
-     *
-     * if (Optional.isNone(optionalValue)) {
-     *   // Type narrowed to None
-     *   assert.ok(true); // optionalValue is None
-     * }
-     * ```
-     *
-     * @template O The {@link Optional.Base} type to check.
-     * @param optional The {@link Optional} to check.
-     * @returns `true` if the {@link Optional} is {@link Optional.None}, `false`
-     *   otherwise.
-     */
-    const isNone: <O extends Base>(optional: O) => optional is NarrowToNone<O>;
-    /**
-     * Unwraps an `Optional`, returning the contained value. Throws an error if
-     * the `Optional` is `Optional.None`.
-     *
-     * This is a safer alternative to direct value access when you know the
-     * Optional should contain a value. Use this method when an empty Optional
-     * represents a programming error or unexpected condition.
-     *
-     * @example
-     *
-     * ```ts
-     * const present = Optional.some('available');
-     *
-     * assert(Optional.unwrapThrow(present) === 'available');
-     * assert.throws(
-     *   () => Optional.unwrapThrow(Optional.none),
-     *   /has failed because it is `None`/u,
-     * );
-     * ```
-     *
-     * @template O The `Optional.Base` type to unwrap.
-     * @param optional The `Optional` to unwrap.
-     * @returns The contained value if `Optional.Some`.
-     * @throws {Error} Error with message "`unwrapThrow()` has failed because it
-     *   is `None`" if the `Optional` is `Optional.None`.
-     */
-    const unwrapThrow: <O extends Base>(optional: O) => Unwrap<O>;
-    /**
-     * Unwraps an `Optional`, returning the contained value or `undefined` if
-     * empty.
-     *
-     * This function provides a safe way to extract values from Optionals without
-     * throwing exceptions. It has overloaded behavior based on the type:
-     *
-     * - For `Optional.Some<T>`: Always returns `T` (guaranteed by type system)
-     * - For general `Optional<T>`: Returns `T | undefined`
-     *
-     * @example
-     *
-     * ```ts
-     * const someString = Optional.some('text');
-     * const noneString = Optional.none as Optional<string>;
-     *
-     * assert(Optional.unwrap(someString) === 'text');
-     * assert(Optional.unwrap(noneString) === undefined);
-     * ```
-     *
-     * @template O The `Optional.Base` type to unwrap.
-     * @param optional The `Optional` to unwrap.
-     * @returns The contained value if `Optional.Some`, otherwise `undefined`.
-     */
-    function unwrap<O extends Some<unknown>>(optional: O): Unwrap<O>;
-    function unwrap<O extends Base>(optional: O): Unwrap<O> | undefined;
-    /**
-     * Unwraps an `Optional`, returning the contained value or a default value if
-     * it's `Optional.None`.
-     *
-     * Supports both direct usage and curried form for functional composition.
-     * This is often preferred over `unwrap()` when you have a sensible fallback
-     * value.
-     *
-     * @example
-     *
-     * ```ts
-     * const withValue = Optional.some(5);
-     * const withoutValue = Optional.none as Optional<number>;
-     *
-     * assert(Optional.unwrapOr(withValue, 0) === 5);
-     * assert(Optional.unwrapOr(withoutValue, 0) === 0);
-     *
-     * const unwrapWithDefault = Optional.unwrapOr(10);
-     *
-     * assert(unwrapWithDefault(Optional.some(3)) === 3);
-     * assert(unwrapWithDefault(Optional.none) === 10);
-     * ```
-     *
-     * @template O The `Optional.Base` type to unwrap.
-     * @template D The type of the default value.
-     * @param optional The `Optional` to unwrap.
-     * @param defaultValue The value to return if `optional` is `Optional.None`.
-     * @returns The contained value if `Optional.Some`, otherwise `defaultValue`.
-     */
-    function unwrapOr<O extends Base, D>(optional: O, defaultValue: D): D | Unwrap<O>;
-    function unwrapOr<S, D>(defaultValue: D): (optional: Optional<S>) => D | S;
-    /**
-     * Returns the `Optional` if it is `Some`, otherwise returns the alternative.
-     *
-     * Provides a way to chain Optional operations with fallback values. This is
-     * particularly useful for implementing default behavior or cascading lookups.
-     * Supports both direct usage and curried form for functional composition.
-     *
-     * @example
-     *
-     * ```ts
-     * const preferred = Optional.some('primary');
-     * const fallback = Optional.some('secondary');
-     * const noneValue = Optional.none as Optional<string>;
-     *
-     * assert.deepStrictEqual(Optional.orElse(preferred, fallback), preferred);
-     * assert.deepStrictEqual(Optional.orElse(noneValue, fallback), fallback);
-     *
-     * const orElseFallback = Optional.orElse(Optional.some('default'));
-     *
-     * assert.deepStrictEqual(orElseFallback(Optional.none), Optional.some('default'));
-     * assert.deepStrictEqual(
-     *   orElseFallback(Optional.some('value')),
-     *   Optional.some('value'),
-     * );
-     * ```
-     *
-     * @template O The input `Optional.Base` type.
-     * @param optional The `Optional` to check.
-     * @param alternative The alternative `Optional` to return if the first is
-     *   `None`.
-     * @returns The first `Optional` if `Some`, otherwise the alternative.
-     */
-    function orElse<O extends Base, const O2 extends Base>(optional: O, alternative: O2): O | O2;
-    function orElse<S, S2>(alternative: Optional<S2>): (optional: Optional<S>) => Optional<S> | Optional<S2>;
-    /**
-     * Maps an {@link Optional}<S> to {@link Optional}<S2> by applying a function to
-     * a contained value. If the {@link Optional} is {@link Optional.None}, it
-     * returns {@link Optional.none}. Otherwise, it applies the `mapFn` to the
-     * value in `Optional.Some` and returns a new `Optional.Some` with the
-     * result.
-     *
-     * @example
-     *
-     * ```ts
-     * const numberOptional = Optional.some(21);
-     * const mapped = Optional.map(numberOptional, (value) => value * 2);
-     *
-     * assert.deepStrictEqual(mapped, Optional.some(42));
-     *
-     * const mapToLength = Optional.map((text: string) => text.length);
-     *
-     * assert.deepStrictEqual(mapToLength(Optional.some('abc')), Optional.some(3));
-     * assert.deepStrictEqual(mapToLength(Optional.none), Optional.none);
-     * ```
-     *
-     * @template O The input `Optional.Base` type.
-     * @template S2 The type of the value returned by the mapping function.
-     * @param optional The `Optional` to map.
-     * @param mapFn The function to apply to the value if it exists.
-     * @returns A new `Optional<S2>` resulting from the mapping, or
-     *   `Optional.None` if the input was `Optional.None`.
-     */
-    function map<O extends Base, S2>(optional: O, mapFn: (value: Unwrap<O>) => S2): Optional<S2>;
-    function map<S, S2>(mapFn: (value: S) => S2): (optional: Optional<S>) => Optional<S2>;
-    /**
-     * Applies a function that returns an `Optional` to the value in an
-     * `Optional.Some`. If the input is `Optional.None`, returns `Optional.None`.
-     * This is the monadic bind operation for `Optional`.
-     *
-     * @example
-     *
-     * ```ts
-     * const parseNumber = (input: string): Optional<number> => {
-     *   const num = Number.parseInt(input, 10);
-     *   return Number.isNaN(num) ? Optional.none : Optional.some(num);
-     * };
-     *
-     * const parsed = Optional.flatMap(Optional.some('10'), parseNumber);
-     *
-     * assert.deepStrictEqual(parsed, Optional.some(10));
-     *
-     * const flatMapParse = Optional.flatMap(parseNumber);
-     *
-     * assert.deepStrictEqual(flatMapParse(Optional.some('5')), Optional.some(5));
-     * assert.deepStrictEqual(flatMapParse(Optional.some('invalid')), Optional.none);
-     * ```
-     *
-     * @template O The input `Optional.Base` type.
-     * @template S2 The value type of the `Optional` returned by the function.
-     * @param optional The `Optional` to flat map.
-     * @param flatMapFn The function to apply that returns an `Optional`.
-     * @returns The result of applying the function, or `Optional.None`.
-     */
-    function flatMap<O extends Base, S2>(optional: O, flatMapFn: (value: Unwrap<O>) => Optional<S2>): Optional<S2>;
-    function flatMap<S, S2>(flatMapFn: (value: S) => Optional<S2>): (optional: Optional<S>) => Optional<S2>;
-    /**
-     * Filters an `Optional` based on a predicate. If the `Optional` is `Some` and
-     * the predicate returns true, returns the original `Optional`. Otherwise
-     * returns `None`.
-     *
-     * @example
-     *
-     * ```ts
-     * const even = Optional.filter(Optional.some(4), (value) => value % 2 === 0);
-     * const odd = Optional.filter(Optional.some(3), (value) => value % 2 === 0);
-     *
-     * assert.deepStrictEqual(even, Optional.some(4));
-     * assert.deepStrictEqual(odd, Optional.none);
-     *
-     * const filterEven = Optional.filter((value: number) => value % 2 === 0);
-     *
-     * assert.deepStrictEqual(filterEven(Optional.some(6)), Optional.some(6));
-     * assert.deepStrictEqual(filterEven(Optional.some(5)), Optional.none);
-     * ```
-     *
-     * @template O The input `Optional.Base` type.
-     * @param optional The `Optional` to filter.
-     * @param predicate The predicate function.
-     * @returns The filtered `Optional`.
-     */
-    function filter<O extends Base>(optional: O, predicate: (value: Unwrap<O>) => boolean): Optional<Unwrap<O>>;
-    function filter<S>(predicate: (value: S) => boolean): (optional: Optional<S>) => Optional<S>;
-    /**
-     * Unwraps an `Optional`, returning the contained value or throwing an error
-     * with the provided message.
-     *
-     * @example
-     *
-     * ```ts
-     * const optionalValue = Optional.some('data');
-     *
-     * assert(Optional.expectToBe(optionalValue, 'value expected') === 'data');
-     *
-     * const expectValue = Optional.expectToBe<string>('missing optional');
-     *
-     * assert.throws(() => expectValue(Optional.none), /missing optional/u);
-     * assert(expectValue(Optional.some('present')) === 'present');
-     * ```
-     *
-     * @template O The `Optional.Base` type to unwrap.
-     * @param optional The `Optional` to unwrap.
-     * @param message The error message to throw if the `Optional` is
-     *   `Optional.None`.
-     * @returns The contained value if `Optional.Some`.
-     * @throws Error with the provided message if the `Optional` is
-     *   `Optional.None`.
-     */
-    function expectToBe<O extends Base>(optional: O, message: string): Unwrap<O>;
-    function expectToBe<S>(message: string): (optional: Optional<S>) => S;
-    /**
-     * Combines two `Optional` values into a single `Optional` containing a tuple.
-     * If either `Optional` is `None`, returns `None`.
-     *
-     * @example
-     *
-     * ```ts
-     * const zipped = Optional.zip(Optional.some('left'), Optional.some(1));
-     *
-     * assert.ok(Optional.isSome(zipped));
-     * if (Optional.isSome(zipped)) {
-     *   const expected: readonly [string, number] = ['left', 1];
-     *   assert.deepStrictEqual(zipped.value, expected);
-     * }
-     *
-     * const missing = Optional.zip(
-     *   Optional.some('value'),
-     *   Optional.none as Optional<number>,
-     * );
-     *
-     * assert.deepStrictEqual(missing, Optional.none);
-     * ```
-     *
-     * @template A The value type of the first `Optional`.
-     * @template B The value type of the second `Optional`.
-     * @param optionalA The first `Optional`.
-     * @param optionalB The second `Optional`.
-     * @returns An `Optional` containing a tuple of both values, or `None`.
-     */
-    const zip: <A, const B>(optionalA: Optional<A>, optionalB: Optional<B>) => Optional<readonly [A, B]>;
-    /**
-     * Converts a nullable value to an `Optional`.
-     *
-     * This is the primary way to lift nullable values (null or undefined) into
-     * the Optional type system. The function treats both `null` and `undefined`
-     * as empty values, converting them to `Optional.None`.
-     *
-     * @example
-     *
-     * ```ts
-     * const present = Optional.fromNullable('hello');
-     * const absent = Optional.fromNullable<string | null>(null);
-     *
-     * assert.deepStrictEqual(present, Optional.some('hello'));
-     * assert.deepStrictEqual(absent, Optional.none);
-     * ```
-     *
-     * @template T The type of the nullable value.
-     * @param value The nullable value to convert.
-     * @returns `Optional.Some<NonNullable<T>>` if the value is not null or
-     *   undefined, otherwise `Optional.None`.
-     */
-    const fromNullable: <T>(value: T | null | undefined) => Optional<NonNullable<T>>;
-    /**
-     * Converts an `Optional` to a nullable value.
-     *
-     * This function extracts the value from an Optional, returning `undefined`
-     * for empty Optionals. This is useful when interfacing with APIs or systems
-     * that expect nullable values rather than Optional types.
-     *
-     * Note: This returns `undefined` (not `null`) for consistency with
-     * JavaScript's undefined semantics and TypeScript's optional properties.
-     *
-     * @example
-     *
-     * ```ts
-     * const someNumber = Optional.some(42);
-     * const noneNumber = Optional.none as Optional<number>;
-     *
-     * assert(Optional.toNullable(someNumber) === 42);
-     * assert(Optional.toNullable(noneNumber) === undefined);
-     * ```
-     *
-     * @template O The `Optional.Base` type to convert.
-     * @param optional The `Optional` to convert.
-     * @returns The contained value if `Some`, otherwise `undefined`.
-     */
-    const toNullable: <O extends Base>(optional: O) => Unwrap<O> | undefined;
-}
-export {};
-//# sourceMappingURL=optional.d.mts.map

package/dist/functional/optional.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"optional.d.mts","sourceRoot":"","sources":["../../src/functional/optional.mts"],"names":[],"mappings":"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"}