ts-data-forge 14.6.2 → 14.6.4

package/dist/expect-type.mjs

@@ -1,70 +1,70 @@
-/**
- * Compile-time type assertion utility for TypeScript type testing.
- *
- * This function performs static type relationship checking at compile-time and
- * has no runtime effect. It is primarily used in test files to verify that
- * TypeScript's type inference and type relationships work as expected. The
- * function will cause TypeScript compilation errors if the specified type
- * relationship does not hold.
- *
- * ## Supported Type Relations
- *
- * ### Equality Relations
- *
- * - **`"="` (strict equality)**: Asserts that types `A` and `B` are exactly the
- *   same type. Uses TypeScript's internal type equality checking.
- * - **`"!="` (strict inequality)**: Asserts that types `A` and `B` are not
- *   exactly the same type.
- *
- * ### Assignability Relations
- *
- * - **`"~="` (mutual assignability)**: Asserts that `A` extends `B` AND `B`
- *   extends `A`. Types are structurally equivalent and mutually assignable.
- * - **`"<="` (subtype relation)**: Asserts that type `A` extends (is assignable
- *   to) type `B`. Type `A` is a subtype of `B`.
- * - **`">="` (supertype relation)**: Asserts that type `B` extends (is assignable
- *   to) type `A`. Type `A` is a supertype of `B`.
- *
- * ### Negative Assignability Relations
- *
- * - **`"!<="` (not subtype)**: Asserts that type `A` does NOT extend type `B`.
- * - **`"!>="` (not supertype)**: Asserts that type `B` does NOT extend type `A`.
- *
- * ## Type Parameter Constraints
- *
- * @since 1.0.0
- * @template A - The first type for comparison. Can be any TypeScript type
- *   including:
- *
- *   - Primitive types (string, number, boolean, etc.)
- *   - Object types and interfaces
- *   - Union and intersection types
- *   - Generic types and type parameters
- *   - Literal types and branded types
- *   - Function types and return types
- *
- * @template B - The second type for comparison. Same constraints as type `A`.
- * @param _relation - A string literal representing the expected type
- *   relationship. TypeScript's type system automatically infers and restricts
- *   the available operators based on the actual relationship between types `A`
- *   and `B`. If an invalid relationship is specified, TypeScript will show a
- *   compilation error.
- *
- *   Combine `expectType` with runtime assertions for comprehensive testing:
- *
- *   ## Important Notes
- *
- *   - **Compile-time only**: This function has no runtime behavior and will be
- *       optimized away.
- *   - **Type inference**: The available relation operators are automatically
- *       inferred by TypeScript based on the actual type relationship between
- *       `A` and `B`.
- *   - **Error feedback**: Invalid type relationships will cause clear TypeScript
- *       compilation errors.
- *   - **Test organization**: Typically used in `.test.mts` files alongside runtime
- *       assertions.
- *   - **Performance**: Has zero runtime overhead as it's purely a compile-time
- *       construct.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const expectType = (_relation) => undefined;
 //# sourceMappingURL=expect-type.mjs.map

package/dist/functional/async-result/impl/async-result-flat-map.mjs

@@ -2,12 +2,12 @@ import { Result } from '../../result/index.mjs';
 export function flatMap(...args) {
     switch (args.length) {
         case 2: {
-            // Direct version: first argument is asyncResult
+
             const [asyncResult, flatMapFn] = args;
             return flatMapImpl(asyncResult, flatMapFn);
         }
         case 1: {
-            // Curried version
+
             const [flatMapFn] = args;
             return (asyncResult) => flatMapImpl(asyncResult, flatMapFn);
         }
@@ -17,7 +17,7 @@ const flatMapImpl = async (asyncResult, flatMapFn) => {
     const result = await asyncResult;
     return Result.isErr(result)
         ? result
-        : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        :
             (await flatMapFn(result.value));
 };
 //# sourceMappingURL=async-result-flat-map.mjs.map

package/dist/functional/async-result/impl/async-result-map-err.mjs

@@ -2,12 +2,12 @@ import { Result } from '../../result/index.mjs';
 export function mapErr(...args) {
     switch (args.length) {
         case 2: {
-            // Direct version: first argument is asyncResult
+
             const [asyncResult, mapFn] = args;
             return mapErrImpl(asyncResult, mapFn);
         }
         case 1: {
-            // Curried version: first argument is mapping function
+
             const [mapFn] = args;
             return (asyncResult) => mapErrImpl(asyncResult, mapFn);
         }

package/dist/functional/async-result/impl/async-result-map.mjs

@@ -2,12 +2,12 @@ import { Result } from '../../result/index.mjs';
 export function map(...args) {
     switch (args.length) {
         case 2: {
-            // Direct version: first argument is asyncResult
+
             const [asyncResult, mapFn] = args;
             return mapImpl(asyncResult, mapFn);
         }
         case 1: {
-            // Curried version
+
             const [mapFn] = args;
             return (asyncResult) => mapImpl(asyncResult, mapFn);
         }

package/dist/functional/async-result/impl/async-result-unwrap-or.mjs

@@ -1,35 +1,35 @@
 import { Result } from '../../result/index.mjs';
-/**
- * Unwraps an `AsyncResult`, resolving to the success value or a default value
- * if it resolves to `Err`.
- *
- * @example
- *
- * ```ts
- * const okValue = AsyncResult.fromPromise(
- *   Promise.resolve(10),
- *   () => 'failed',
- * );
- *
- * const errValue = AsyncResult.fromPromise(
- *   Promise.reject(new Error('boom')),
- *   () => 'failed',
- * );
- *
- * assert.isTrue((await AsyncResult.unwrapOr(okValue, 0)) === 10);
- *
- * assert.isTrue((await AsyncResult.unwrapOr(errValue, 0)) === 0);
- * ```
- *
- * @template S The type of the success value.
- * @template E The type of the error value.
- * @template D The type of the default value.
- * @param asyncResult The `AsyncResult` to unwrap.
- * @param defaultValue The value to resolve to if `asyncResult` resolves to
- *   `Err`.
- * @returns A Promise of the success value if `Ok`, otherwise of
- *   `defaultValue`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const unwrapOr = async (asyncResult, defaultValue) => {
     const result = await asyncResult;
     return Result.isOk(result) ? result.value : defaultValue;

package/dist/functional/optional/impl/optional-expect-to-be.mjs

@@ -7,7 +7,7 @@ export function expectToBe(...args) {
             return expectToBeImpl(optional, message);
         }
         case 1: {
-            // Curried version: first argument is message
+
             const [message] = args;
             return (optional) => expectToBeImpl(optional, message);
         }

package/dist/functional/optional/impl/optional-filter.mjs

@@ -9,7 +9,7 @@ export function filter(...args) {
             return filterImpl(optional, predicate);
         }
         case 1: {
-            // Curried version: first argument is predicate function
+
             const [predicate] = args;
             return (optional) => filterImpl(optional, predicate);
         }

package/dist/functional/optional/impl/optional-flat-map.mjs

@@ -8,7 +8,7 @@ export function flatMap(...args) {
             return flatMapImpl(optional, flatMapFn);
         }
         case 1: {
-            // Curried version
+
             const [flatMapFn] = args;
             return (optional) => flatMapImpl(optional, flatMapFn);
         }

package/dist/functional/optional/impl/optional-from-nullable.mjs

@@ -1,28 +1,28 @@
 import { none } from './optional-none.mjs';
 import { some } from './optional-some.mjs';
-/**
- * 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 `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 `Some<NonNullable<T>>` if the value is not null or
- *   undefined, otherwise `None`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const fromNullable = (value) => (value == null ? none : some(value));
 //# sourceMappingURL=optional-from-nullable.mjs.map

package/dist/functional/optional/impl/optional-is-none.mjs

@@ -1,22 +1,22 @@
 import { NoneTypeTagName } from './tag.mjs';
-/**
- * Checks if an {@link Optional} is {@link None}. Acts as a type guard.
- *
- * @example
- *
- * ```ts
- * const optionalValue = Optional.none as Optional<number>;
- *
- * if (Optional.isNone(optionalValue)) {
- *   // Type narrowed to None
- *   expectType<typeof optionalValue, None>('=');
- * }
- * ```
- *
- * @template O The {@link UnknownOptional} type to check.
- * @param optional The {@link Optional} to check.
- * @returns `true` if the {@link Optional} is {@link None}, `false`
- *   otherwise.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isNone = (optional) => optional.$$tag === NoneTypeTagName;
 //# sourceMappingURL=optional-is-none.mjs.map

package/dist/functional/optional/impl/optional-is-optional.mjs

@@ -1,23 +1,23 @@
 import { hasKey, isRecord } from '../../../guard/index.mjs';
 import { NoneTypeTagName, SomeTypeTagName } from './tag.mjs';
-/**
- * Checks if the given value is an {@link Optional}.
- *
- * @example
- *
- * ```ts
- * const maybeOptional = Optional.some('value');
- *
- * const notOptional = { $$tag: 'ts-data-forge::Optional.some' } as const;
- *
- * assert.isTrue(Optional.isOptional(maybeOptional));
- *
- * assert.isFalse(Optional.isOptional(notOptional));
- * ```
- *
- * @param maybeOptional The value to check.
- * @returns `true` if the value is an {@link Optional}, otherwise `false`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isOptional = (maybeOptional) => isRecord(maybeOptional) &&
     hasKey(maybeOptional, '$$tag') &&
     ((maybeOptional.$$tag === SomeTypeTagName &&

package/dist/functional/optional/impl/optional-is-some.mjs

@@ -1,23 +1,23 @@
 import { SomeTypeTagName } from './tag.mjs';
-/**
- * Checks if an {@link Optional} is {@link Some}. Acts as a type guard.
- *
- * @example
- *
- * ```ts
- * const optionalNumber = Optional.some(42);
- *
- * if (Optional.isSome(optionalNumber)) {
- *   const value: number = optionalNumber.value;
- *
- *   assert.isTrue(value === 42);
- * }
- * ```
- *
- * @template O The {@link UnknownOptional} type to check.
- * @param optional The {@link Optional} to check.
- * @returns `true` if the {@link Optional} is {@link Some}, `false`
- *   otherwise.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const isSome = (optional) => optional.$$tag === SomeTypeTagName;
 //# sourceMappingURL=optional-is-some.mjs.map

package/dist/functional/optional/impl/optional-map.mjs

@@ -9,14 +9,14 @@ export function map(...args) {
             return mapImpl(optional, mapFn);
         }
         case 1: {
-            // Curried version: first argument is mapping function
+
             const [mapFn] = args;
             return (optional) => mapImpl(optional, mapFn);
         }
     }
 }
 const mapImpl = (optional, mapFn) => isSome(optional)
-    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    ?
         some(mapFn(unwrap(optional)))
     : none;
 //# sourceMappingURL=optional-map.mjs.map

package/dist/functional/optional/impl/optional-match.mjs

@@ -7,14 +7,14 @@ export function match(...args) {
             return matchImpl(optional, cases);
         }
         case 1: {
-            // Curried version: the only argument is the case handlers
+
             const [cases] = args;
             return (optional) => matchImpl(optional, cases);
         }
     }
 }
 const matchImpl = (optional, cases) => isSome(optional)
-    ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    ?
         cases.some(unwrap(optional))
     : cases.none();
 //# sourceMappingURL=optional-match.mjs.map

package/dist/functional/optional/impl/optional-none.mjs

@@ -1,19 +1,19 @@
 import { NoneTypeTagName } from './tag.mjs';
-/**
- * The singleton instance representing {@link None} (an empty
- * Optional).
- *
- * @example
- *
- * ```ts
- * const someValue = Optional.some({ id: 1 });
- *
- * const noneValue = Optional.none;
- *
- * assert.isTrue(Optional.isSome(someValue));
- *
- * assert.isTrue(Optional.isNone(noneValue));
- * ```
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const none = { $$tag: NoneTypeTagName };
 //# sourceMappingURL=optional-none.mjs.map

package/dist/functional/optional/impl/optional-or-else.mjs

@@ -6,7 +6,7 @@ export function orElse(...args) {
             return orElseImpl(optional, alternative);
         }
         case 1: {
-            // Curried version
+
             const [alternative] = args;
             return (optional) => orElseImpl(optional, alternative);
         }

package/dist/functional/optional/impl/optional-some.mjs

@@ -1,23 +1,23 @@
 import { SomeTypeTagName } from './tag.mjs';
-/**
- * Creates an {@link Some} containing the given value.
- *
- * @example
- *
- * ```ts
- * const someValue = Optional.some({ id: 1 });
- *
- * const noneValue = Optional.none;
- *
- * assert.isTrue(Optional.isSome(someValue));
- *
- * assert.isTrue(Optional.isNone(noneValue));
- * ```
- *
- * @template S The type of the value.
- * @param value The value to wrap in an {@link Some}.
- * @returns An {@link Some}<S> containing the value.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const some = (value) => ({
     $$tag: SomeTypeTagName,
     value,

package/dist/functional/optional/impl/optional-to-nullable.mjs

@@ -1,30 +1,30 @@
 import { isSome } from './optional-is-some.mjs';
 import { unwrap } from './optional-unwrap.mjs';
-/**
- * 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.isTrue(Optional.toNullable(someNumber) === 42);
- *
- * assert.isTrue(Optional.toNullable(noneNumber) === undefined);
- * ```
- *
- * @template O The `UnknownOptional` type to convert.
- * @param optional The `Optional` to convert.
- * @returns The contained value if `Some`, otherwise `undefined`.
- */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 export const toNullable = (optional) => (isSome(optional) ? unwrap(optional) : undefined);
 //# sourceMappingURL=optional-to-nullable.mjs.map

package/dist/functional/optional/impl/optional-unwrap-or.mjs

@@ -6,7 +6,7 @@ export function unwrapOr(...args) {
             return unwrapOrImpl(optional, defaultValue);
         }
         case 1: {
-            // Curried version: first argument is default value
+
             const [defaultValue] = args;
             return (optional) => unwrapOrImpl(optional, defaultValue);
         }