ts-data-forge 1.0.0 → 1.0.2

package/dist/functional/optional.mjs

@@ -0,0 +1,532 @@
+import { isRecord } from '../guard/is-record.mjs';
+import { pipe } from './pipe.mjs';
+
+/* eslint-disable @typescript-eslint/no-unsafe-type-assertion */
+/** @internal Symbol to identify the 'Some' variant of Optional. */
+const SomeTypeSymbol = Symbol('Optional.some');
+/** @internal Symbol to identify the 'None' variant of Optional. */
+const NoneTypeSymbol = Symbol('Optional.none');
+/**
+ * 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.
+ */
+var Optional;
+(function (Optional) {
+    /**
+     * Checks if the given value is an {@link Optional}.
+     * @param maybeOptional The value to check.
+     * @returns `true` if the value is an {@link Optional}, otherwise `false`.
+     */
+    Optional.isOptional = (maybeOptional) => isRecord(maybeOptional) &&
+        Object.hasOwn(maybeOptional, 'type') &&
+        ((maybeOptional['type'] === SomeTypeSymbol &&
+            Object.hasOwn(maybeOptional, 'value')) ||
+            maybeOptional['type'] === NoneTypeSymbol);
+    /**
+     * Creates an {@link Optional.Some} containing the given value.
+     * @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.
+     * @example
+     * ```typescript
+     * const someValue = Optional.some(42);
+     * const someString = Optional.some("hello");
+     * const someObject = Optional.some({ name: "Alice", age: 30 });
+     *
+     * console.log(Optional.isSome(someValue)); // true
+     * console.log(Optional.unwrap(someValue)); // 42
+     * ```
+     */
+    Optional.some = (value) => ({
+        type: SomeTypeSymbol,
+        value,
+    });
+    /**
+     * The singleton instance representing {@link Optional.None} (an empty Optional).
+     * @example
+     * ```typescript
+     * const emptyValue = Optional.none;
+     *
+     * console.log(Optional.isNone(emptyValue)); // true
+     * console.log(Optional.unwrap(emptyValue)); // undefined
+     * console.log(Optional.unwrapOr(emptyValue, "default")); // "default"
+     * ```
+     */
+    Optional.none = { type: NoneTypeSymbol };
+    /**
+     * Checks if an {@link Optional} is {@link Optional.Some}.
+     * Acts as a type guard.
+     * @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.
+     */
+    Optional.isSome = (optional) => optional.type === SomeTypeSymbol;
+    /**
+     * Checks if an {@link Optional} is {@link Optional.None}.
+     * Acts as a type guard.
+     * @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.
+     */
+    Optional.isNone = (optional) => optional.type === NoneTypeSymbol;
+    /**
+     * 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.
+     *
+     * @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`.
+     * @example
+     * ```typescript
+     * // Safe unwrapping when you know the value exists
+     * const config = loadConfig(); // returns Optional<Config>
+     * if (Optional.isSome(config)) {
+     *   const value = Optional.unwrapThrow(config); // Safe to unwrap
+     *   console.log(value); // Config object
+     * }
+     *
+     * // Unsafe unwrapping - will throw if empty
+     * const userInput = Optional.some(42);
+     * console.log(Optional.unwrapThrow(userInput)); // 42
+     *
+     * const empty = Optional.none;
+     * try {
+     *   Optional.unwrapThrow(empty); // throws Error
+     * } catch (error) {
+     *   console.log(error.message); // "`unwrapThrow()` has failed because it is `None`"
+     * }
+     * ```
+     */
+    Optional.unwrapThrow = (optional) => {
+        if (Optional.isSome(optional)) {
+            return optional.value;
+        }
+        throw new Error('`unwrapThrow()` has failed because it is `None`');
+    };
+    /**
+     * 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`
+     *
+     * @template O The `Optional.Base` type to unwrap.
+     * @param optional The `Optional` to unwrap.
+     * @returns The contained value if `Optional.Some`, otherwise `undefined`.
+     * @example
+     * ```typescript
+     * // With Some - guaranteed to return value
+     * const some = Optional.some(42);
+     * const value = Optional.unwrap(some); // Type: number, Value: 42
+     *
+     * // With general Optional - may return undefined
+     * const maybeValue: Optional<string> = getOptionalString();
+     * const result = Optional.unwrap(maybeValue); // Type: string | undefined
+     *
+     * // Safe pattern for handling both cases
+     * const optional = Optional.some("hello");
+     * const unwrapped = Optional.unwrap(optional);
+     * if (unwrapped !== undefined) {
+     *   console.log(unwrapped.toUpperCase()); // "HELLO"
+     * }
+     * ```
+     */
+    Optional.unwrap = ((optional) => Optional.isNone(optional)
+        ? undefined
+        : optional.value);
+    /**
+     * 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.
+     *
+     * @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`.
+     * @example
+     * ```typescript
+     * // Direct usage - most common pattern
+     * const userAge = Optional.fromNullable(user.age);
+     * const displayAge = Optional.unwrapOr(userAge, "Unknown");
+     * console.log(`Age: ${displayAge}`); // "Age: 25" or "Age: Unknown"
+     *
+     * // With different Optional types
+     * const some = Optional.some(42);
+     * const value1 = Optional.unwrapOr(some, 0);
+     * console.log(value1); // 42
+     *
+     * const none = Optional.none;
+     * const value2 = Optional.unwrapOr(none, 0);
+     * console.log(value2); // 0
+     *
+     * // Curried usage for functional composition
+     * const unwrapWithDefault = Optional.unwrapOr("default");
+     * const result = pipe(Optional.some("hello"))
+     *   .map(unwrapWithDefault)
+     *   .value;
+     * console.log(result); // "hello"
+     *
+     * // Chaining with other Optional operations
+     * const processValue = (input: string) =>
+     *   pipe(Optional.fromNullable(input))
+     *     .map(Optional.map(s => s.toUpperCase()))
+     *     .map(Optional.unwrapOr("NO INPUT"))
+     *     .value;
+     * ```
+     */
+    Optional.unwrapOr = ((...args) => {
+        switch (args.length) {
+            case 2: {
+                const [optional, defaultValue] = args;
+                return Optional.isNone(optional)
+                    ? defaultValue
+                    : optional.value;
+            }
+            case 1: {
+                // Curried version: first argument is default value
+                const [defaultValue] = args;
+                return (optional) => Optional.unwrapOr(optional, defaultValue);
+            }
+        }
+    });
+    /**
+     * 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.
+     *
+     * @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.
+     * @example
+     * ```typescript
+     * // Direct usage - cascading lookups
+     * const primaryConfig = loadPrimaryConfig(); // Optional<Config>
+     * const fallbackConfig = loadFallbackConfig(); // Optional<Config>
+     * const config = Optional.orElse(primaryConfig, fallbackConfig);
+     *
+     * // Multiple fallbacks
+     * const userPreference = getUserPreference(); // Optional<string>
+     * const systemDefault = Optional.some("default-theme");
+     * const theme = Optional.orElse(userPreference, systemDefault);
+     * console.log(Optional.unwrap(theme)); // User's preference or "default-theme"
+     *
+     * // Regular usage example
+     * const primary = Optional.none;
+     * const fallback = Optional.some("default");
+     * const result = Optional.orElse(primary, fallback);
+     * console.log(Optional.unwrap(result)); // "default"
+     *
+     * // Curried usage for functional composition
+     * const withFallback = Optional.orElse(Optional.some("fallback"));
+     * const result2 = pipe(Optional.none)
+     *   .map(withFallback)
+     *   .value;
+     * console.log(Optional.unwrap(result2)); // "fallback"
+     *
+     * // Chaining multiple orElse operations
+     * const finalResult = pipe(Optional.none)
+     *   .map(Optional.orElse(Optional.none)) // Still none
+     *   .map(Optional.orElse(Optional.some("last resort")))
+     *   .value;
+     * ```
+     */
+    Optional.orElse = ((...args) => {
+        switch (args.length) {
+            case 2: {
+                const [optional, alternative] = args;
+                return Optional.isNone(optional) ? alternative : optional;
+            }
+            case 1: {
+                const [alternative] = args;
+                return (optional) => Optional.orElse(optional, alternative);
+            }
+        }
+    });
+    /**
+     * 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.
+     * @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`.
+     * @example
+     * ```typescript
+     * const someNumber = Optional.some(5);
+     * const mapped = Optional.map(someNumber, x => x * 2);
+     * console.log(Optional.unwrap(mapped)); // 10
+     *
+     * const noneValue = Optional.none;
+     * const mappedNone = Optional.map(noneValue, x => x * 2);
+     * console.log(Optional.isNone(mappedNone)); // true
+     *
+     * // Chaining maps
+     * const result = Optional.map(
+     *   Optional.map(Optional.some("hello"), s => s.toUpperCase()),
+     *   s => s.length
+     * );
+     * console.log(Optional.unwrap(result)); // 5
+     *
+     * // Curried version for use with pipe
+     * const doubler = Optional.map((x: number) => x * 2);
+     * const result2 = pipe(Optional.some(5)).map(doubler).value;
+     * console.log(Optional.unwrap(result2)); // 10
+     * ```
+     */
+    Optional.map = ((...args) => {
+        switch (args.length) {
+            case 2: {
+                const [optional, mapFn] = args;
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                return Optional.isSome(optional) ? Optional.some(mapFn(Optional.unwrap(optional))) : Optional.none;
+            }
+            case 1: {
+                // Curried version: first argument is mapping function
+                const [mapFn] = args;
+                return (optional) => Optional.map(optional, mapFn);
+            }
+        }
+    });
+    /**
+     * 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`.
+     * @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`.
+     * @example
+     * ```typescript
+     * // Regular usage
+     * const parseNumber = (s: string): Optional<number> => {
+     *   const n = Number(s);
+     *   return isNaN(n) ? Optional.none : Optional.some(n);
+     * };
+     *
+     * const result = Optional.flatMap(Optional.some("42"), parseNumber);
+     * console.log(Optional.unwrap(result)); // 42
+     *
+     * // Curried usage for pipe composition
+     * const parser = Optional.flatMap(parseNumber);
+     * const result2 = pipe(Optional.some("42")).map(parser).value;
+     * console.log(Optional.unwrap(result2)); // 42
+     * ```
+     */
+    Optional.flatMap = ((...args) => {
+        switch (args.length) {
+            case 2: {
+                const [optional, flatMapFn] = args;
+                return Optional.isSome(optional) ? flatMapFn(Optional.unwrap(optional)) : Optional.none;
+            }
+            case 1: {
+                const [flatMapFn] = args;
+                return (optional) => Optional.flatMap(optional, flatMapFn);
+            }
+        }
+    });
+    /**
+     * Filters an `Optional` based on a predicate.
+     * If the `Optional` is `Some` and the predicate returns true, returns the original `Optional`.
+     * Otherwise returns `None`.
+     * @template O The input `Optional.Base` type.
+     * @param optional The `Optional` to filter.
+     * @param predicate The predicate function.
+     * @returns The filtered `Optional`.
+     * @example
+     * ```typescript
+     * // Regular usage
+     * const someEven = Optional.some(4);
+     * const filtered = Optional.filter(someEven, x => x % 2 === 0);
+     * console.log(Optional.unwrap(filtered)); // 4
+     *
+     * // Curried usage for pipe composition
+     * const evenFilter = Optional.filter((x: number) => x % 2 === 0);
+     * const result = pipe(Optional.some(4)).map(evenFilter).value;
+     * console.log(Optional.unwrap(result)); // 4
+     * ```
+     */
+    Optional.filter = ((...args) => {
+        switch (args.length) {
+            case 2: {
+                const [optional, predicate] = args;
+                return Optional.isSome(optional)
+                    ? pipe(Optional.unwrap(optional)).map((value) => predicate(value) ? Optional.some(value) : Optional.none).value
+                    : Optional.none;
+            }
+            case 1: {
+                // Curried version: first argument is predicate function
+                const [predicate] = args;
+                return (optional) => Optional.filter(optional, predicate);
+            }
+        }
+    });
+    /**
+     * Unwraps an `Optional`, returning the contained value or throwing an error with the provided message.
+     * @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`.
+     * @example
+     * ```typescript
+     * // Regular usage
+     * const some = Optional.some(42);
+     * const value = Optional.expectToBe(some, "Value must exist");
+     * console.log(value); // 42
+     *
+     * // Curried usage for pipe composition
+     * const getValue = Optional.expectToBe("Value must exist");
+     * const value2 = pipe(Optional.some(42)).map(getValue).value;
+     * console.log(value2); // 42
+     * ```
+     */
+    Optional.expectToBe = ((...args) => {
+        switch (args.length) {
+            case 2: {
+                const [optional, message] = args;
+                if (Optional.isSome(optional)) {
+                    return Optional.unwrap(optional);
+                }
+                throw new Error(message);
+            }
+            case 1: {
+                // Curried version: first argument is message
+                const [message] = args;
+                return (optional) => Optional.expectToBe(optional, message);
+            }
+        }
+    });
+    /**
+     * Combines two `Optional` values into a single `Optional` containing a tuple.
+     * If either `Optional` is `None`, returns `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`.
+     * @example
+     * ```typescript
+     * const a = Optional.some(1);
+     * const b = Optional.some("hello");
+     * const zipped = Optional.zip(a, b);
+     * console.log(Optional.unwrap(zipped)); // [1, "hello"]
+     *
+     * const withNone = Optional.zip(a, Optional.none);
+     * console.log(Optional.isNone(withNone)); // true
+     * ```
+     */
+    Optional.zip = (optionalA, optionalB) => Optional.isSome(optionalA) && Optional.isSome(optionalB)
+        ? Optional.some([optionalA.value, optionalB.value])
+        : Optional.none;
+    /**
+     * 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`.
+     *
+     * @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`.
+     * @example
+     * ```typescript
+     * // Basic nullable conversion
+     * const value: string | null = "hello";
+     * const optional = Optional.fromNullable(value);
+     * console.log(Optional.unwrap(optional)); // "hello"
+     * console.log(Optional.isSome(optional)); // true
+     *
+     * // Handling null values
+     * const nullValue: string | null = null;
+     * const noneOptional = Optional.fromNullable(nullValue);
+     * console.log(Optional.isNone(noneOptional)); // true
+     *
+     * // Handling undefined values
+     * const undefinedValue: number | undefined = undefined;
+     * const alsoNone = Optional.fromNullable(undefinedValue);
+     * console.log(Optional.isNone(alsoNone)); // true
+     *
+     * // Common use case with API responses
+     * interface User {
+     *   name: string;
+     *   email?: string; // Optional field
+     * }
+     *
+     * const user: User = { name: "John" };
+     * const email = Optional.fromNullable(user.email);
+     * const emailDisplay = Optional.unwrapOr(email, "No email provided");
+     * console.log(emailDisplay); // "No email provided"
+     *
+     * // Chaining with other Optional operations
+     * const processNullableInput = (input: string | null) =>
+     *   Optional.fromNullable(input)
+     *     .map(Optional.map(s => s.trim()))
+     *     .map(Optional.filter(s => s.length > 0))
+     *     .map(Optional.unwrapOr("empty input"));
+     * ```
+     */
+    Optional.fromNullable = (value) => (value == null ? Optional.none : Optional.some(value));
+    /**
+     * 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.
+     *
+     * @template O The `Optional.Base` type to convert.
+     * @param optional The `Optional` to convert.
+     * @returns The contained value if `Some`, otherwise `undefined`.
+     * @example
+     * ```typescript
+     * // Basic conversion
+     * const some = Optional.some(42);
+     * console.log(Optional.toNullable(some)); // 42
+     *
+     * const none = Optional.none;
+     * console.log(Optional.toNullable(none)); // undefined
+     *
+     * // Interface with nullable APIs
+     * interface ApiResponse {
+     *   data?: string;
+     * }
+     *
+     * const optionalData: Optional<string> = processData();
+     * const response: ApiResponse = {
+     *   data: Optional.toNullable(optionalData)
+     * };
+     *
+     * // Converting back and forth
+     * const original: string | undefined = getValue();
+     * const optional = Optional.fromNullable(original);
+     * const processed = Optional.map(optional, s => s.toUpperCase());
+     * const result: string | undefined = Optional.toNullable(processed);
+     *
+     * // Useful in conditional logic
+     * const maybeUser = findUser(id);
+     * const userName = Optional.toNullable(maybeUser);
+     * if (userName !== undefined) {
+     *   console.log(`Found user: ${userName}`);
+     * }
+     * ```
+     */
+    Optional.toNullable = (optional) => (Optional.isSome(optional) ? Optional.unwrap(optional) : undefined);
+})(Optional || (Optional = {}));
+
+export { Optional };
+//# sourceMappingURL=optional.mjs.map

package/dist/functional/optional.mjs.map

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