ts-data-forge 3.2.0 → 3.3.1

package/dist/collections/stack.mjs

@@ -33,12 +33,13 @@ import '../number/num.mjs';
 import '../number/refined-number-utils.mjs';
 
 /**
- * Class implementation for a stack with LIFO (Last-In, First-Out) behavior using a dynamic array.
- * This implementation provides O(1) amortized push and O(1) pop operations by using a resizable buffer
- * that grows as needed.
+ * Class implementation for a stack with LIFO (Last-In, First-Out) behavior
+ * using a dynamic array. This implementation provides O(1) amortized push and
+ * O(1) pop operations by using a resizable buffer that grows as needed.
  *
- * The underlying array automatically resizes when it becomes full, ensuring that the stack
- * can grow to accommodate any number of elements while maintaining efficient operations.
+ * The underlying array automatically resizes when it becomes full, ensuring
+ * that the stack can grow to accommodate any number of elements while
+ * maintaining efficient operations.
  *
  * @template T The type of elements in the stack.
  * @implements Stack
@@ -54,6 +55,7 @@ class StackClass {
     static #INITIAL_CAPACITY = 8;
     /**
      * Constructs a new StackClass instance.
+     *
      * @param initialValues Optional initial values to populate the stack.
      */
     constructor(initialValues = []) {
@@ -77,50 +79,16 @@ class StackClass {
     /**
      * Removes and returns the element at the top of the stack (LIFO).
      *
-     * This operation removes the element that was added most recently (last-in) and returns it.
-     * If the stack is empty, returns `Optional.none`. The operation is guaranteed to be O(1)
-     * and does not require any array resizing or memory reallocation.
-     *
-     * **Time Complexity:** O(1) - constant time operation
-     * **Space Complexity:** O(1) - no additional memory allocation
-     *
-     * @returns An Optional containing the removed element, or `Optional.none` if the stack is empty.
-     *
-     * @example
-     * ```typescript
-     * const stack = createStack<string>();
-     *
-     * // Add some elements
-     * stack.push("bottom");
-     * stack.push("middle");
-     * stack.push("top");
+     * This operation removes the element that was added most recently (last-in)
+     * and returns it. If the stack is empty, returns `Optional.none`. The
+     * operation is guaranteed to be O(1) and does not require any array resizing
+     * or memory reallocation.
      *
-     * // Remove elements in LIFO order
-     * const top = stack.pop();
-     * if (top.isSome) {
-     *   console.log(top.value); // "top" (last pushed, first popped)
-     * }
+     * **Time Complexity:** O(1) - constant time operation **Space Complexity:**
+     * O(1) - no additional memory allocation
      *
-     * const middle = stack.pop().unwrap(); // "middle"
-     * console.log(stack.size); // 1
-     *
-     * // Safe handling of empty stack
-     * const emptyStack = createStack<number>();
-     * const result = emptyStack.pop();
-     * if (result.isNone) {
-     *   console.log("Stack is empty");
-     * }
-     *
-     * // Typical usage in algorithms
-     * const pathStack = createStack<string>();
-     * pathStack.push("/home");
-     * pathStack.push("/users");
-     * pathStack.push("/documents");
-     *
-     * // Backtrack one level
-     * const currentDir = pathStack.pop().unwrap(); // "/documents"
-     * const parentDir = pathStack.pop().unwrap();  // "/users"
-     * ```
+     * @returns An Optional containing the removed element, or `Optional.none` if
+     *   the stack is empty.
      */
     pop() {
         if (this.isEmpty) {
@@ -135,60 +103,19 @@ class StackClass {
     /**
      * Adds an element to the top of the stack (LIFO).
      *
-     * This operation adds the element to the top of the stack, where it will be the first
-     * to be popped (last-in, first-out ordering). The operation is amortized O(1),
-     * meaning it's O(1) for most operations with occasional O(n) when the buffer needs resizing.
+     * This operation adds the element to the top of the stack, where it will be
+     * the first to be popped (last-in, first-out ordering). The operation is
+     * amortized O(1), meaning it's O(1) for most operations with occasional O(n)
+     * when the buffer needs resizing.
      *
-     * **Time Complexity:** O(1) amortized - O(n) only when buffer resize is needed
-     * **Space Complexity:** O(1) - constant additional memory per element
+     * **Time Complexity:** O(1) amortized - O(n) only when buffer resize is
+     * needed **Space Complexity:** O(1) - constant additional memory per element
      *
-     * **Buffer Resizing:** When the internal buffer becomes full, it automatically doubles
-     * in size and copies existing elements to maintain the stack structure.
+     * **Buffer Resizing:** When the internal buffer becomes full, it
+     * automatically doubles in size and copies existing elements to maintain the
+     * stack structure.
      *
      * @param value The element to add to the top of the stack.
-     *
-     * @example
-     * ```typescript
-     * const actionStack = createStack<string>();
-     *
-     * // Add actions in chronological order
-     * actionStack.push("open file");        // O(1)
-     * actionStack.push("edit content");     // O(1)
-     * actionStack.push("save file");        // O(1)
-     *
-     * console.log(actionStack.size); // 3
-     *
-     * // Actions will be undone in reverse order (LIFO)
-     * while (!actionStack.isEmpty) {
-     *   const action = actionStack.pop().unwrap();
-     *   console.log(`Undoing: ${action}`);
-     * }
-     * // Output:
-     * // Undoing: save file
-     * // Undoing: edit content
-     * // Undoing: open file
-     *
-     * // High-volume pushing (demonstrates amortized O(1) performance)
-     * const dataStack = createStack<number>();
-     *
-     * for (const i of range(1000000)) {
-     *   dataStack.push(i); // Each operation is O(1) amortized
-     * }
-     *
-     * console.log(dataStack.size); // 1000000
-     *
-     * // Function call stack simulation
-     * type StackFrame = { function: string; variables: Record<string, any> };
-     * const callStack = createStack<StackFrame>();
-     *
-     * callStack.push({ function: "main", variables: { argc: 1, argv: ["program"] } });
-     * callStack.push({ function: "process", variables: { data: [1, 2, 3] } });
-     * callStack.push({ function: "validate", variables: { input: "test" } });
-     *
-     * // Current function context is at the top
-     * const currentFrame = callStack.pop().unwrap();
-     * console.log(`Current function: ${currentFrame.function}`);
-     * ```
      */
     push(value) {
         // Resize if buffer is full
@@ -215,13 +142,16 @@ class StackClass {
     }
 }
 /**
- * Creates a new Stack instance with LIFO (Last-In, First-Out) behavior using a high-performance dynamic array.
+ * Creates a new Stack instance with LIFO (Last-In, First-Out) behavior using a
+ * high-performance dynamic array.
  *
- * This factory function creates an optimized stack implementation that maintains excellent performance
- * characteristics for both push and pop operations. The underlying dynamic array automatically
- * resizes to accommodate growing workloads while providing predictable O(1) operations.
+ * This factory function creates an optimized stack implementation that
+ * maintains excellent performance characteristics for both push and pop
+ * operations. The underlying dynamic array automatically resizes to accommodate
+ * growing workloads while providing predictable O(1) operations.
  *
  * **Implementation Features:**
+ *
  * - **O(1) push operations** (amortized - occasionally O(n) when resizing)
  * - **O(1) pop operations** (always)
  * - **Automatic buffer resizing** - starts at 8 elements, doubles when full
@@ -229,121 +159,42 @@ class StackClass {
  * - **Dynamic array design** - eliminates need for complex memory management
  *
  * **Performance Benefits:**
+ *
  * - No array shifting required for stack operations
  * - Minimal memory allocation overhead
  * - Predictable performance under high load
  * - Efficient memory usage with automatic cleanup
  *
- * @template T The type of elements stored in the stack.
- * @param initialValues Optional array of initial elements to populate the stack.
- *                      Elements will be popped in reverse order of how they appear in the array
- *                      (last array element will be popped first).
- *                      If provided, the initial buffer capacity will be at least twice the array length.
- * @returns A new Stack instance optimized for high-performance LIFO operations.
- *
  * @example
- * ```typescript
- * import { createStack } from './stack';
- *
- * // Example 1: Function call simulation
- * type FunctionCall = { name: string; args: any[]; context: any };
- * const callStack = createStack<FunctionCall>();
- *
- * // Simulate function calls (push onto stack)
- * callStack.push({ name: "main", args: [], context: {} });              // O(1)
- * callStack.push({ name: "processData", args: [data], context: {} });   // O(1)
- * callStack.push({ name: "validateInput", args: [input], context: {} }); // O(1)
- *
- * // Simulate function returns (pop from stack)
- * while (!callStack.isEmpty) {
- *   const call = callStack.pop().unwrap(); // O(1)
- *   console.log(`Returning from: ${call.name}`);
- * }
- * // Output:
- * // Returning from: validateInput
- * // Returning from: processData
- * // Returning from: main
- *
- * // Example 2: Expression evaluation with operator precedence
- * const operatorStack = createStack<string>();
- * const operandStack = createStack<number>();
- *
- * // Simulate parsing "3 + 4 * 2"
- * operandStack.push(3);
- * operatorStack.push("+");
- * operandStack.push(4);
- * operatorStack.push("*");  // Higher precedence
- * operandStack.push(2);
  *
- * // Process higher precedence first (LIFO)
- * const op = operatorStack.pop().unwrap(); // "*"
- * const b = operandStack.pop().unwrap();   // 2
- * const a = operandStack.pop().unwrap();   // 4
- * operandStack.push(a * b); // Push result: 8
+ * ```ts
+ * const stack = createStack<string>();
  *
- * // Example 3: Undo/Redo functionality
- * type EditAction = {
- *   type: 'insert' | 'delete' | 'modify';
- *   position: number;
- *   oldValue: string;
- *   newValue: string;
- * };
+ * assert.ok(stack.isEmpty);
+ * assert(stack.size === 0);
  *
- * const undoStack = createStack<EditAction>();
- * const redoStack = createStack<EditAction>();
+ * stack.push('first');
+ * // eslint-disable-next-line unicorn/prefer-single-call
+ * stack.push('second');
  *
- * // Perform edits (push to undo stack)
- * const edit1: EditAction = { type: 'insert', position: 0, oldValue: '', newValue: 'Hello' };
- * const edit2: EditAction = { type: 'insert', position: 5, oldValue: '', newValue: ' World' };
+ * assert.notOk(stack.isEmpty);
+ * assert(stack.size === 2);
+ * assert.deepStrictEqual(stack.pop(), Optional.some('second'));
+ * assert.deepStrictEqual(stack.pop(), Optional.some('first'));
+ * assert.deepStrictEqual(stack.pop(), Optional.none);
  *
- * undoStack.push(edit1);
- * undoStack.push(edit2);
+ * const seededStack = createStack([10, 20, 30]);
  *
- * // Undo last edit
- * if (!undoStack.isEmpty) {
- *   const lastEdit = undoStack.pop().unwrap();
- *   redoStack.push(lastEdit);
- *   console.log(`Undid: ${lastEdit.type} at position ${lastEdit.position}`);
- * }
- *
- * // Example 4: High-throughput data processing
- * const processingStack = createStack<number>();
- *
- * // Add large amount of data (demonstrates amortized O(1) performance)
- * for (const i of range(100000)) {
- *   processingStack.push(i); // Each push is O(1) amortized
- * }
- *
- * // Process data in LIFO order
- * let processedCount = 0;
- * while (!processingStack.isEmpty) {
- *   const value = processingStack.pop().unwrap(); // O(1)
- *   // Process value...
- *   processedCount++;
- * }
- * console.log(`Processed ${processedCount} items`); // 100000
- *
- * // Example 5: Stack with pre-populated data
- * const historyStack = createStack<string>([
- *   "page1.html",
- *   "page2.html",
- *   "page3.html",
- *   "page4.html"
- * ]);
- *
- * console.log(historyStack.size); // Output: 4
- *
- * // Navigate back through history (LIFO order)
- * while (!historyStack.isEmpty) {
- *   const page = historyStack.pop().unwrap();
- *   console.log(`Going back to: ${page}`);
- * }
- * // Output:
- * // Going back to: page4.html (last added, first removed)
- * // Going back to: page3.html
- * // Going back to: page2.html
- * // Going back to: page1.html
+ * assert(seededStack.size === 3);
+ * assert.deepStrictEqual(seededStack.pop(), Optional.some(30));
  * ```
+ *
+ * @template T The type of elements stored in the stack.
+ * @param initialValues Optional array of initial elements to populate the
+ *   stack. Elements will be popped in reverse order of how they appear in the
+ *   array (last array element will be popped first). If provided, the initial
+ *   buffer capacity will be at least twice the array length.
+ * @returns A new Stack instance optimized for high-performance LIFO operations.
  */
 const createStack = (initialValues) => new StackClass(initialValues);
 

package/dist/collections/stack.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"stack.mjs","sources":["../../src/collections/stack.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"stack.mjs","sources":["../../src/collections/stack.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgKA;;;;;;;;;;;AAWG;AACH,MAAM,UAAU,CAAA;;AAEd,IAAA,OAAO;;AAGP,IAAA,SAAS;;AAGT,IAAA,SAAS;;AAGT,IAAA,OAAgB,iBAAiB,GAAG,CAAC;AAErC;;;;AAIG;AACH,IAAA,WAAA,CAAY,gBAA8B,EAAE,EAAA;AAC1C,QAAA,MAAM,eAAe,GAAG,QAAQ,CAC9B,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,iBAAiB,EAAE,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CACjE;AAED,QAAA,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,IAAI,CACvB,EAAE,MAAM,EAAE,eAAe,EAAE,EAC3B,MAAM,SAAS,CAChB;AACD,QAAA,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC;AAC5B,QAAA,IAAI,CAAC,SAAS,GAAG,eAAe;;AAGhC,QAAA,KAAK,MAAM,KAAK,IAAI,aAAa,EAAE;AACjC,YAAA,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;QAClB;IACF;;AAGA,IAAA,IAAI,OAAO,GAAA;AACT,QAAA,OAAO,IAAI,CAAC,SAAS,KAAK,CAAC;IAC7B;;AAGA,IAAA,IAAI,IAAI,GAAA;AACN,QAAA,OAAO,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC;IACjC;AAEA;;;;;;;;;;;;;AAaG;IACH,GAAG,GAAA;AACD,QAAA,IAAI,IAAI,CAAC,OAAO,EAAE;YAChB,OAAO,QAAQ,CAAC,IAAI;QACtB;AAEA,QAAA,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;;QAE9C,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAE;QAC7C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC;AAEzC,QAAA,OAAO,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC;IAC/B;AAEA;;;;;;;;;;;;;;;;AAgBG;AACH,IAAA,IAAI,CAAC,KAAQ,EAAA;;QAEX,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS,EAAE;YACrC,IAAI,CAAC,OAAO,EAAE;QAChB;QAEA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK;AACpC,QAAA,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;IAChD;AAEA;;;;AAIG;IACH,OAAO,GAAA;QACL,MAAM,WAAW,GAAG,QAAQ,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;AAChD,QAAA,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAC1B,EAAE,MAAM,EAAE,WAAW,EAAE,EACvB,MAAM,SAAS,CAChB;;QAGD,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE;YACrC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAChC;AAEA,QAAA,IAAI,CAAC,OAAO,GAAG,SAAS;AACxB,QAAA,IAAI,CAAC,SAAS,GAAG,WAAW;IAC9B;;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDG;AACI,MAAM,WAAW,GAAG,CAAK,aAA4B,KAC1D,IAAI,UAAU,CAAI,aAAa;;;;"}

package/dist/entry-point.d.mts

@@ -0,0 +1,3 @@
+export * from './array/index.mjs';
+export * from './index.mjs';
+//# sourceMappingURL=entry-point.d.mts.map

package/dist/entry-point.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point.d.mts","sourceRoot":"","sources":["../src/entry-point.mts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC"}

package/dist/entry-point.mjs

@@ -0,0 +1,62 @@
+import * as index from './array/impl/index.mjs';
+export { index as Arr };
+export { IMapMapped } from './collections/imap-mapped.mjs';
+export { IMap } from './collections/imap.mjs';
+export { ISetMapped } from './collections/iset-mapped.mjs';
+export { ISet } from './collections/iset.mjs';
+export { createQueue } from './collections/queue.mjs';
+export { createStack } from './collections/stack.mjs';
+export { expectType } from './expect-type.mjs';
+export { match } from './functional/match.mjs';
+export { Optional } from './functional/optional.mjs';
+export { pipe } from './functional/pipe.mjs';
+export { Result } from './functional/result.mjs';
+export { hasKey } from './guard/has-key.mjs';
+export { isNonEmptyString } from './guard/is-non-empty-string.mjs';
+export { isNonNullObject } from './guard/is-non-null-object.mjs';
+export { isPrimitive } from './guard/is-primitive.mjs';
+export { isRecord } from './guard/is-record.mjs';
+export { isBigint, isBoolean, isNonNullish, isNotBigint, isNotBoolean, isNotNull, isNotNumber, isNotString, isNotSymbol, isNotUndefined, isNull, isNullish, isNumber, isString, isSymbol, isUndefined } from './guard/is-type.mjs';
+export { keyIsIn } from './guard/key-is-in.mjs';
+export { range } from './iterator/range.mjs';
+export { Json } from './json/json.mjs';
+export { FiniteNumber, asFiniteNumber, isFiniteNumber } from './number/branded-types/finite-number.mjs';
+export { Int, asInt, isInt } from './number/branded-types/int.mjs';
+export { Int16, asInt16, isInt16 } from './number/branded-types/int16.mjs';
+export { Int32, asInt32, isInt32 } from './number/branded-types/int32.mjs';
+export { NonNegativeFiniteNumber, asNonNegativeFiniteNumber, isNonNegativeFiniteNumber } from './number/branded-types/non-negative-finite-number.mjs';
+export { NonNegativeInt16, asNonNegativeInt16, isNonNegativeInt16 } from './number/branded-types/non-negative-int16.mjs';
+export { NonNegativeInt32, asNonNegativeInt32, isNonNegativeInt32 } from './number/branded-types/non-negative-int32.mjs';
+export { NonZeroFiniteNumber, asNonZeroFiniteNumber, isNonZeroFiniteNumber } from './number/branded-types/non-zero-finite-number.mjs';
+export { NonZeroInt, asNonZeroInt, isNonZeroInt } from './number/branded-types/non-zero-int.mjs';
+export { NonZeroInt16, asNonZeroInt16, isNonZeroInt16 } from './number/branded-types/non-zero-int16.mjs';
+export { NonZeroInt32, asNonZeroInt32, isNonZeroInt32 } from './number/branded-types/non-zero-int32.mjs';
+export { NonZeroSafeInt, asNonZeroSafeInt, isNonZeroSafeInt } from './number/branded-types/non-zero-safe-int.mjs';
+export { NonZeroUint16, asNonZeroUint16, isNonZeroUint16 } from './number/branded-types/non-zero-uint16.mjs';
+export { NonZeroUint32, asNonZeroUint32, isNonZeroUint32 } from './number/branded-types/non-zero-uint32.mjs';
+export { PositiveFiniteNumber, asPositiveFiniteNumber, isPositiveFiniteNumber } from './number/branded-types/positive-finite-number.mjs';
+export { PositiveInt, asPositiveInt, isPositiveInt } from './number/branded-types/positive-int.mjs';
+export { PositiveInt16, asPositiveInt16, isPositiveInt16 } from './number/branded-types/positive-int16.mjs';
+export { PositiveInt32, asPositiveInt32, isPositiveInt32 } from './number/branded-types/positive-int32.mjs';
+export { PositiveSafeInt, asPositiveSafeInt, isPositiveSafeInt } from './number/branded-types/positive-safe-int.mjs';
+export { PositiveUint16, asPositiveUint16, isPositiveUint16 } from './number/branded-types/positive-uint16.mjs';
+export { PositiveUint32, asPositiveUint32, isPositiveUint32 } from './number/branded-types/positive-uint32.mjs';
+export { SafeInt, asSafeInt, isSafeInt } from './number/branded-types/safe-int.mjs';
+export { SafeUint, asSafeUint, isSafeUint } from './number/branded-types/safe-uint.mjs';
+export { Uint, asUint, isUint } from './number/branded-types/uint.mjs';
+export { Uint16, asUint16, isUint16 } from './number/branded-types/uint16.mjs';
+export { Uint32, asUint32, isUint32 } from './number/branded-types/uint32.mjs';
+export { Int8, asInt8, isInt8 } from './number/enum/int8.mjs';
+export { Uint8, asUint8, isUint8 } from './number/enum/uint8.mjs';
+export { Num } from './number/num.mjs';
+export { TsDataForgeInternals } from './number/refined-number-utils.mjs';
+export { Obj } from './object/object.mjs';
+export { castDeepMutable, castMutable } from './others/cast-mutable.mjs';
+export { castDeepReadonly, castReadonly } from './others/cast-readonly.mjs';
+export { ifThen } from './others/if-then.mjs';
+export { mapNullable } from './others/map-nullable.mjs';
+export { memoizeFunction } from './others/memoize-function.mjs';
+export { tp } from './others/tuple.mjs';
+export { unknownToString } from './others/unknown-to-string.mjs';
+export { createPromise } from './promise/promise.mjs';
+//# sourceMappingURL=entry-point.mjs.map

package/dist/entry-point.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/expect-type.d.mts

@@ -1,199 +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
+ * 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.
+ *
+ * - **`"="` (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`.
+ *
+ * - **`"~="` (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:
+ * @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.
- *
- * ## 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
+ * @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 declare 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;
 //# sourceMappingURL=expect-type.d.mts.map

package/dist/expect-type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"expect-type.d.mts","sourceRoot":"","sources":["../src/expect-type.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoMG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,EAC7B,WAAW,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAChC,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAEpB,IAAI,GACJ,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAC3B,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,GAC7D,KAAK,GAAG,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC,KACnE,IAAiB,CAAC"}
+{"version":3,"file":"expect-type.d.mts","sourceRoot":"","sources":["../src/expect-type.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,EAC7B,WAAW,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAChC,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAEpB,IAAI,GACJ,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAC3B,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,GAC7D,KAAK,GAAG,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC,KACnE,IAAiB,CAAC"}