ts-data-forge 1.0.0

package/src/expect-type.mts

@@ -0,0 +1,206 @@
+/**
+ * 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
+ *
+ * @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.
+ *
+ * ## Usage Patterns
+ *
+ * ### Basic Type Testing
+ * @example
+ * ```typescript
+ * import { expectType } from './expect-type.mjs';
+ *
+ * // Primitive type equality
+ * expectType<string, string>("=");           // ✓ exact match
+ * expectType<number, string>("!=");          // ✓ different types
+ * expectType<42, number>("<=");              // ✓ literal extends primitive
+ * expectType<number, 42>(">=");              // ✓ primitive is supertype
+ *
+ * // Type assertions will cause compilation errors for wrong relationships:
+ * // expectType<string, number>("=");        // ❌ TypeScript error
+ * // expectType<number, string>("<=");       // ❌ TypeScript error
+ * ```
+ *
+ * ### Array and Tuple Type Validation
+ * @example
+ * ```typescript
+ * // Testing array utility function return types
+ * const zeros = Arr.zeros(3);
+ * expectType<typeof zeros, readonly [0, 0, 0]>("=");
+ *
+ * const sequence = Arr.seq(5);
+ * expectType<typeof sequence, readonly [0, 1, 2, 3, 4]>("=");
+ *
+ * // Dynamic length arrays
+ * const dynamicArray = Arr.zeros(someLength);
+ * expectType<typeof dynamicArray, readonly 0[]>("=");
+ * ```
+ *
+ * ### Function Return Type Testing
+ * @example
+ * ```typescript
+ * // Testing function return types
+ * const createUser = () => ({ id: 1, name: 'John' });
+ * expectType<ReturnType<typeof createUser>, { id: number; name: string }>("~=");
+ *
+ * // Generic function type inference
+ * const identity = <T>(x: T): T => x;
+ * const result = identity('hello');
+ * expectType<typeof result, string>("=");
+ * ```
+ *
+ * ### Union and Intersection Types
+ * @example
+ * ```typescript
+ * // Union type relationships
+ * expectType<string, string | number>("<=");     // string extends union
+ * expectType<string | number, string>(">=");     // union contains string
+ * expectType<string | number, number>(">=");     // union contains number
+ *
+ * // Intersection type relationships
+ * type A = { a: number };
+ * type B = { b: string };
+ * expectType<A & B, A>(">=");                    // intersection extends component
+ * expectType<A, A & B>("<=");                    // component extends intersection
+ * ```
+ *
+ * ### Branded Type Validation
+ * @example
+ * ```typescript
+ * // Testing branded number types
+ * expectType<PositiveInt, number>("<=");         // branded type extends base
+ * expectType<number, PositiveInt>(">=");         // base type is supertype
+ * expectType<PositiveInt, NegativeInt>("!=");    // different branded types
+ *
+ * // Type guard function validation
+ * if (isPositiveInt(value)) {
+ *   expectType<typeof value, PositiveInt>("<=");
+ * }
+ * ```
+ *
+ * ### Optional and Result Type Testing
+ * @example
+ * ```typescript
+ * // Optional type narrowing
+ * const optional: Optional<number> = Optional.some(42);
+ * if (Optional.isSome(optional)) {
+ *   expectType<typeof optional, Optional.Some<number>>("<=");
+ * }
+ * if (Optional.isNone(optional)) {
+ *   expectType<typeof optional, Optional.None>("<=");
+ * }
+ *
+ * // Result type validation
+ * const result: Result<string, Error> = Result.ok('success');
+ * expectType<typeof result, Result<string, Error>>("<=");
+ * ```
+ *
+ * ### Type Guard and Validation Testing
+ * @example
+ * ```typescript
+ * // Testing type guard functions
+ * if (isRecord(value)) {
+ *   expectType<typeof value, UnknownRecord>("<=");
+ * }
+ *
+ * // Testing compile-time type predicates
+ * const obj = { key: 'value' };
+ * if (hasKey(obj, 'key')) {
+ *   expectType<typeof obj.key, unknown>("<=");
+ * }
+ * ```
+ *
+ * ## Common Testing Patterns
+ *
+ * ### Dual Testing Strategy
+ * Combine `expectType` with runtime assertions for comprehensive testing:
+ *
+ * @example
+ * ```typescript
+ * describe('Arr.zeros', () => {
+ *   test('should create array of zeros with correct type', () => {
+ *     const result = Arr.zeros(3);
+ *
+ *     // Compile-time type assertion
+ *     expectType<typeof result, readonly [0, 0, 0]>("=");
+ *
+ *     // Runtime behavior assertion
+ *     expect(result).toStrictEqual([0, 0, 0]);
+ *   });
+ * });
+ * ```
+ *
+ * ### Type Relationship Validation
+ * Test complex type hierarchies and relationships:
+ *
+ * @example
+ * ```typescript
+ * // Ensure proper type hierarchy
+ * expectType<PositiveInt, Int>("<=");           // positive is subset of int
+ * expectType<Int, FiniteNumber>("<=");          // int is subset of finite
+ * expectType<FiniteNumber, number>("<=");       // finite is subset of number
+ *
+ * // Verify mutual exclusion
+ * expectType<PositiveInt, NegativeInt>("!=");   // different int types
+ * expectType<PositiveInt, NegativeInt>("!<=");  // neither extends the other
+ * expectType<NegativeInt, PositiveInt>("!<=");
+ * ```
+ *
+ * ## 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.
+ *
+ * @since 1.0.0
+ */
+export const expectType = <A, B>(
+  _relation: TypeEq<A, B> extends true
+    ? '<=' | '=' | '>=' | '~='
+    :
+        | '!='
+        | (TypeExtends<A, B> extends true
+            ? '<=' | (TypeExtends<B, A> extends true ? '>=' | '~=' : '!>=')
+            : '!<=' | (TypeExtends<B, A> extends true ? '>=' : '!>=')),
+): void => undefined;

package/src/functional/index.mts

@@ -0,0 +1,4 @@
+export * from './match.mjs';
+export * from './optional.mjs';
+export * from './pipe.mjs';
+export * from './result.mjs';

package/src/functional/match.mts

@@ -0,0 +1,300 @@
+import { expectType } from '../expect-type.mjs';
+import { keyIsIn } from '../guard/index.mjs';
+
+/**
+ * @internal
+ * Utility type to extract the union of all values from a record type.
+ * @template T The record type to extract values from.
+ */
+type ValueOf<T> = T[keyof T];
+
+/**
+ * @internal
+ * Represents a record with unknown value types.
+ */
+type UnknownRecord = Record<PropertyKey, unknown>;
+
+/**
+ * @internal
+ * Represents a readonly record mapping keys of type K to values of type V.
+ * @template K The type of keys.
+ * @template V The type of values.
+ */
+type ReadonlyRecord<K extends PropertyKey, V> = Readonly<Record<K, V>>;
+
+/**
+ * @internal
+ * A relaxed version of Exclude that handles edge cases with property keys.
+ * @template T The type to exclude from.
+ * @template U The type to exclude.
+ */
+type RelaxedExclude<T, U> = T extends U ? never : T;
+
+/**
+ * @internal
+ * Checks if two types are exactly equal.
+ * @template T First type to compare.
+ * @template U Second type to compare.
+ */
+type TypeEq<T, U> = [T] extends [U] ? ([U] extends [T] ? true : false) : false;
+
+/**
+ * Type-safe pattern matching function for string-based discriminated unions.
+ *
+ * Provides compile-time guarantees for exhaustive case handling when working with
+ * literal string unions. Automatically enforces completeness checking when all
+ * cases are covered, and requires a default value when cases are incomplete.
+ *
+ * ## Key Features:
+ * - **Exhaustive Matching**: When all cases of a literal union are handled, no default value is needed
+ * - **Partial Matching**: When cases are incomplete or working with general string types, a default value is required
+ * - **Type Safety**: Prevents extra cases and ensures only valid keys are used
+ * - **Strict Property Checking**: Rejects objects with unexpected properties
+ *
+ * @param target - The value to match against
+ * @param cases - Object mapping possible values to their corresponding results
+ * @param defaultValue - Fallback value (required when not all cases are covered)
+ * @returns The matched result or default value
+ *
+ * @example
+ * Exhaustive matching (no default needed):
+ * ```typescript
+ * type Status = 'loading' | 'success' | 'error';
+ * const status: Status = 'loading';
+ *
+ * const message = match(status, {
+ *   loading: 'Please wait...',
+ *   success: 'Operation completed!',
+ *   error: 'Something went wrong'
+ * });
+ * // Type: string
+ * // Result: 'Please wait...'
+ * ```
+ *
+ * @example
+ * Partial matching (default required):
+ * ```typescript
+ * type Priority = 'low' | 'medium' | 'high' | 'critical';
+ * const priority: Priority = 'medium';
+ *
+ * const color = match(priority, {
+ *   high: 'red',
+ *   critical: 'darkred'
+ * }, 'gray'); // Default required for uncovered cases
+ * // Type: 'red' | 'darkred' | 'gray'
+ * // Result: 'gray'
+ * ```
+ *
+ * @example
+ * Working with general string types:
+ * ```typescript
+ * const userInput: string = getUserInput();
+ *
+ * const route = match(userInput, {
+ *   'home': '/',
+ *   'about': '/about',
+ *   'contact': '/contact'
+ * }, '/404'); // Default required for string type
+ * // Type: '/' | '/about' | '/contact' | '/404'
+ * ```
+ *
+ * @example
+ * HTTP status code handling:
+ * ```typescript
+ * type HttpStatus = 200 | 404 | 500;
+ * const status: HttpStatus = 404;
+ *
+ * const response = match(String(status), {
+ *   '200': { ok: true, message: 'Success' },
+ *   '404': { ok: false, message: 'Not Found' },
+ *   '500': { ok: false, message: 'Server Error' }
+ * });
+ * // All cases covered, no default needed
+ * // Result: { ok: false, message: 'Not Found' }
+ * ```
+ *
+ * @example
+ * Complex discriminated union handling:
+ * ```typescript
+ * type ApiResponse =
+ *   | { status: 'loading' }
+ *   | { status: 'success'; data: string }
+ *   | { status: 'error'; error: string };
+ *
+ * const handleResponse = (response: ApiResponse) =>
+ *   match(response.status, {
+ *     loading: 'Please wait...',
+ *     success: 'Data loaded successfully!',
+ *     error: 'Failed to load data'
+ *   });
+ * ```
+ *
+ * @example
+ * Advanced usage with functional composition:
+ * ```typescript
+ * // Creating reusable matchers
+ * const logLevelToColor = (level: string) => match(level, {
+ *   'debug': 'gray',
+ *   'info': 'blue',
+ *   'warn': 'yellow',
+ *   'error': 'red'
+ * }, 'black'); // Default for unknown levels
+ *
+ * const logLevelToIcon = (level: string) => match(level, {
+ *   'debug': '🐛',
+ *   'info': 'ℹ️',
+ *   'warn': '⚠️',
+ *   'error': '❌'
+ * }, '📝');
+ *
+ * // Combining matchers
+ * const formatLogEntry = (level: string, message: string) => ({
+ *   color: logLevelToColor(level),
+ *   icon: logLevelToIcon(level),
+ *   text: `${logLevelToIcon(level)} ${message}`
+ * });
+ * ```
+ */
+export const match: MatchFnOverload = (<
+  const Case extends string,
+  const R extends UnknownRecord,
+  const D,
+>(
+  ...args:
+    | readonly [target: Case, cases: R]
+    | readonly [target: Case, cases: R, defaultValue: D]
+): ValueOf<R> | D => {
+  switch (args.length) {
+    case 2: {
+      const [target, cases] = args;
+      return cases[target];
+    }
+    case 3: {
+      const [target, cases, defaultValue] = args;
+      if (keyIsIn(target, cases)) {
+        return cases[target];
+      } else {
+        return defaultValue;
+      }
+    }
+  }
+}) as MatchFnOverload;
+
+/**
+ * @internal
+ * Overloaded function type for the match function.
+ * Provides different signatures based on whether exhaustive matching is possible.
+ * @template Case The string literal union type to match against.
+ * @template R The record type containing the case mappings.
+ * @template D The type of the default value.
+ */
+type MatchFnOverload = {
+  /**
+   * Exhaustive matching signature - used when all cases in a literal union are covered.
+   * No default value is required or allowed.
+   * @template Case The string literal union type.
+   * @template R The record type with mappings for all cases.
+   * @param target The value to match.
+   * @param cases Object mapping all possible case values to results.
+   * @returns The matched result value.
+   */
+  <const Case extends string, const R extends ReadonlyRecord<Case, unknown>>(
+    target: Case,
+    cases: StrictPropertyCheck<R, Case>,
+  ): R[Case];
+
+  /**
+   * Partial matching signature - used when not all cases are covered or when dealing with general string types.
+   * A default value is required.
+   * @template Case The string type (may be literal union or general string).
+   * @template R The record type with partial case mappings.
+   * @template D The type of the default value.
+   * @param target The value to match.
+   * @param cases Object mapping some case values to results.
+   * @param defaultValue Required fallback value for unmatched cases.
+   * @returns The matched result value or the default value.
+   */
+  <const Case extends string, const R extends UnknownRecord, const D>(
+    target: Case,
+    cases: StrictPropertyCheck<R, Case>,
+    defaultValue: IsLiteralUnionFullyCovered<Case, R> extends true ? never : D,
+  ): ValueOf<R> | D;
+};
+
+/**
+ * @internal
+ * Helper type to ensure that an object `T` only contains keys specified in `ExpectedKeys`.
+ * If `T` has any keys not in `ExpectedKeys`, this type resolves to `never`.
+ * @template T The object type to check.
+ * @template ExpectedKeys The union of string literal types representing the allowed keys.
+ */
+type StrictPropertyCheck<T, ExpectedKeys extends PropertyKey> =
+  RelaxedExclude<keyof T, ExpectedKeys> extends never ? T : never;
+
+/**
+ * @internal
+ * Helper type to check if all cases in `Case` union are fully covered by keys in `R`.
+ * This checks bidirectional coverage: all Case members are in R, and no extra keys.
+ * @template Case A union of string literal types representing the possible cases.
+ * @template R A record type.
+ */
+type AllCasesCovered<Case extends PropertyKey, R> =
+  TypeEq<Case, keyof R> extends true ? true : false;
+
+expectType<AllCasesCovered<'a' | 'b', { a: 1; b: 2 }>, true>('=');
+expectType<AllCasesCovered<'a' | 'b' | 'c', { a: 1; b: 2 }>, false>('=');
+expectType<AllCasesCovered<'a' | 'b', { a: 1; b: 2; c: 3 }>, false>('=');
+expectType<AllCasesCovered<string, Record<string, string>>, true>('=');
+
+/**
+ * @internal
+ * Helper type to check if Case is a literal union type and all cases are covered.
+ * @template Case A union of string literal types.
+ * @template R A record type.
+ */
+type IsLiteralUnionFullyCovered<
+  Case extends PropertyKey,
+  R extends UnknownRecord,
+> =
+  TypeEq<IsLiteralType<Case>, true> extends true
+    ? AllCasesCovered<Case, R>
+    : false;
+
+expectType<IsLiteralUnionFullyCovered<'a' | 'b', { a: 1; b: 2 }>, true>('=');
+expectType<IsLiteralUnionFullyCovered<'a' | 'b' | 'c', { a: 1; b: 2 }>, false>(
+  '=',
+);
+expectType<IsLiteralUnionFullyCovered<'a' | 'b', { a: 1; b: 2; c: 3 }>, false>(
+  '=',
+);
+expectType<IsLiteralUnionFullyCovered<string, Record<string, string>>, false>(
+  '=',
+);
+expectType<
+  // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+  IsLiteralUnionFullyCovered<'a' | 'b' | string, { a: 1; b: 2 }>,
+  false
+>('=');
+
+/**
+ * @internal
+ * Helper type to determine if a given PropertyKey `T` is a literal type (e.g., 'a', 1)
+ * or a general type (e.g., string, number).
+ * @template T The PropertyKey type to check.
+ * @returns `true` if `T` is a literal type, `false` otherwise.
+ */
+type IsLiteralType<T extends PropertyKey> = string extends T
+  ? false
+  : number extends T
+    ? false
+    : symbol extends T
+      ? false
+      : true;
+
+expectType<IsLiteralType<'a' | 'b'>, true>('=');
+expectType<IsLiteralType<'a'>, true>('=');
+expectType<IsLiteralType<string>, false>('=');
+expectType<IsLiteralType<number>, false>('=');
+expectType<IsLiteralType<1>, true>('=');
+expectType<IsLiteralType<number | 'aa'>, false>('=');
+expectType<IsLiteralType<'aa' | 32>, true>('=');

package/src/functional/match.test.mts

@@ -0,0 +1,177 @@
+import { expectType } from '../expect-type.mjs';
+import { match } from './match.mjs';
+
+describe('match', () => {
+  type Direction = 'E' | 'N' | 'S' | 'W';
+  const direction: Direction = 'N' as Direction;
+
+  test('literal union', () => {
+    const res = match(direction, {
+      E: 2,
+      N: 3,
+      S: 4,
+      W: 5,
+    });
+
+    expectType<typeof res, 2 | 3 | 4 | 5>('=');
+
+    expect(res).toBe(3);
+  });
+
+  test('Literal union with missing key - requires default', () => {
+    const res = match(
+      direction,
+      {
+        E: 2,
+        S: 4,
+        W: 5,
+      },
+      999,
+    );
+
+    expectType<typeof res, 2 | 4 | 5 | 999>('=');
+
+    expect(res).toBe(999);
+  });
+
+  test('Literal union with missing key - 2-arg form should cause type error', () => {
+    // @ts-expect-error Cannot use 2-argument form when not all cases are covered
+    const res = match(direction, {
+      E: 2,
+      S: 4,
+      W: 5,
+    });
+
+    expectType<typeof res, unknown>('=');
+
+    expect(res).toBeUndefined();
+  });
+
+  test('Missing key cases with string - requires default', () => {
+    const res = match(
+      direction as string,
+      {
+        E: 2,
+        S: 4,
+        W: 5,
+      },
+      'default',
+    );
+
+    expectType<typeof res, 2 | 4 | 5 | 'default'>('=');
+
+    expect(res).toBe('default');
+  });
+
+  test('String type always requires default even with all keys', () => {
+    const res = match(
+      direction as string,
+      {
+        E: 2,
+        N: 3,
+        S: 4,
+        W: 5,
+      },
+      'default',
+    );
+
+    expectType<typeof res, 2 | 3 | 4 | 5 | 'default'>('=');
+
+    expect(res).toBe(3);
+  });
+
+  test('A case with excess properties', () => {
+    // @ts-expect-error excess properties
+    const res = match(direction, {
+      E: 2,
+      N: 3,
+      S: 4,
+      W: 5,
+      X: 0,
+    });
+
+    expectType<typeof res, 2 | 3 | 4 | 5>('=');
+
+    expect(res).toBe(3);
+  });
+
+  test('with default case - all keys present should cause type error', () => {
+    const res = match(
+      direction,
+      {
+        E: 2,
+        N: 3,
+        S: 4,
+        W: 5,
+      },
+      // @ts-expect-error When all cases are covered, default value should not be allowed
+      999,
+    );
+
+    expect(res).toBe(3);
+  });
+
+  test('all keys present without default - should work correctly', () => {
+    const res = match(direction, {
+      E: 2,
+      N: 3,
+      S: 4,
+      W: 5,
+    });
+
+    expectType<typeof res, 2 | 3 | 4 | 5>('=');
+
+    expect(res).toBe(3);
+  });
+
+  test('with default case - missing key', () => {
+    const res = match(
+      direction,
+      {
+        E: 2,
+        S: 4,
+        W: 5,
+      },
+      999,
+    );
+
+    expectType<typeof res, 2 | 4 | 5 | 999>('=');
+
+    expect(res).toBe(999);
+  });
+
+  test('with default case - string key', () => {
+    const res = match(
+      direction as string,
+      {
+        E: 2,
+        N: 3,
+        S: 4,
+        W: 5,
+      },
+      'default',
+    );
+
+    expectType<typeof res, 2 | 3 | 4 | 5 | 'default'>('=');
+
+    expect(res).toBe(3);
+  });
+
+  test('with default case - string key missing', () => {
+    const unknownDirection = 'X' as string;
+    const res = match(
+      unknownDirection,
+      {
+        E: 2,
+        N: 3,
+        S: 4,
+        W: 5,
+      },
+      'default',
+    );
+
+    expectType<typeof res, 2 | 3 | 4 | 5 | 'default'>('=');
+
+    expect(res).toBe('default');
+  });
+});