ts-data-forge 2.0.0 → 2.0.2

package/README.md

@@ -166,7 +166,7 @@ const maybeValue = Optional.some(42);
 
 const doubled = Optional.map(maybeValue, (x) => x * 2);
 
-assert.strictEqual(Optional.unwrapOr(doubled, 0), 84);
+assert(Optional.unwrapOr(doubled, 0) === 84);
 
 // Result for error handling
 const success = Result.ok(42);
@@ -196,16 +196,16 @@ const handleStatus = (status: Status, data?: string): string =>
         error: 'An error occurred',
     });
 
-assert.strictEqual(handleStatus('loading'), 'Please wait...');
-assert.strictEqual(handleStatus('success', 'Hello'), 'Data: Hello');
-assert.strictEqual(handleStatus('error'), 'An error occurred');
+assert(handleStatus('loading') === 'Please wait...');
+assert(handleStatus('success', 'Hello') === 'Data: Hello');
+assert(handleStatus('error') === 'An error occurred');
 
 // Pattern matching with Result
 const processResult = (result: Result<number, string>): string =>
     Result.isOk(result) ? `Success: ${result.value}` : `Error: ${result.value}`;
 
-assert.strictEqual(processResult(Result.ok(42)), 'Success: 42');
-assert.strictEqual(processResult(Result.err('Failed')), 'Error: Failed');
+assert(processResult(Result.ok(42)) === 'Success: 42');
+assert(processResult(Result.err('Failed')) === 'Error: Failed');
 ```
 
 ### 3. Number Utilities with `Num` and Branded Number Types
@@ -216,35 +216,35 @@ The `Num` object provides safe and convenient functions for numerical operations
 import { Num } from 'ts-data-forge';
 
 // Basic conversions
-assert.strictEqual(Num.from('123'), 123);
-assert.strictEqual(Number.isNaN(Num.from('abc')), true);
+assert(Num.from('123') === 123);
+assert(Number.isNaN(Num.from('abc')));
 
 // Range checking
 const inRange = Num.isInRange(0, 10);
 
-assert.strictEqual(inRange(5), true);
-assert.strictEqual(inRange(0), true); // (inclusive lower bound)
-assert.strictEqual(inRange(10), false); // (exclusive upper bound)
+assert(inRange(5));
+assert(inRange(0)); // (inclusive lower bound)
+assert(!inRange(10)); // (exclusive upper bound)
 
 // Clamping values
 const clamp = Num.clamp(0, 100);
 
-assert.strictEqual(clamp(150), 100);
-assert.strictEqual(clamp(-10), 0);
+assert(clamp(150) === 100);
+assert(clamp(-10) === 0);
 
 // Rounding utilities
 const round2 = Num.round(2);
 
-assert.strictEqual(round2(3.14159), 3.14);
-assert.strictEqual(Num.roundAt(3.14159, 3), 3.142);
-assert.strictEqual(Num.roundToInt(3.7), 4);
+assert(round2(3.14159) === 3.14);
+assert(Num.roundAt(3.14159, 3) === 3.142);
+assert(Num.roundToInt(3.7) === 4);
 
 // Type guards
 const value = 5; // example value
 if (Num.isNonZero(value)) {
     // value is guaranteed to be non-zero
     const result = Num.div(10, value); // Safe division
-    assert.strictEqual(result, 2);
+    assert(result === 2);
 }
 ```
 
@@ -272,10 +272,10 @@ const unsigned = asUint(42); // Uint - non-negative integer
 const finite = asFiniteNumber(3.14); // FiniteNumber - finite floating-point
 const safeInt = asSafeInt(42); // SafeInt - integer in safe range
 
-assert.strictEqual(integer, 42);
-assert.strictEqual(unsigned, 42);
-assert.strictEqual(finite, 3.14);
-assert.strictEqual(safeInt, 42);
+assert(integer === 42);
+assert(unsigned === 42);
+assert(finite === 3.14);
+assert(safeInt === 42);
 
 // This line would cause a runtime error:
 assert.throw(() => {
@@ -285,29 +285,29 @@ assert.throw(() => {
 // Range-constrained types (16-bit, 32-bit)
 const int16 = asInt16(1000); // Int16: [-32768, 32767]
 const uint32 = asUint32(3000000000); // Uint32: [0, 4294967295]
-assert.strictEqual(int16, 1000);
-assert.strictEqual(uint32, 3000000000);
+assert(int16 === 1000);
+assert(uint32 === 3000000000);
 
 // Non-zero and positive variants
 const nonZeroInt = asNonZeroInt(5); // NonZeroInt - excludes zero
 const positiveInt = asPositiveInt(10); // PositiveInt - excludes zero and negatives
-assert.strictEqual(nonZeroInt, 5);
-assert.strictEqual(positiveInt, 10);
+assert(nonZeroInt === 5);
+assert(positiveInt === 10);
 
 // Type-safe arithmetic with automatic clamping
 const sum = Int16.add(int16, asInt16(2000)); // Int16 (3000)
 const clamped = Int16.clamp(100000); // Int16 (32767 - clamped to MAX_VALUE)
-assert.strictEqual(sum, 3000);
-assert.strictEqual(clamped, 32767);
+assert(sum === 3000);
+assert(clamped === 32767);
 
 // Safe division with non-zero types
 const ratio = NonZeroInt.div(asNonZeroInt(10), nonZeroInt); // No division by zero risk
-assert.strictEqual(ratio, 2);
+assert(ratio === 2);
 
 // Random generation within type constraints
 const randomInt16 = Int16.random(); // Int16 (random value in valid range)
-assert.strictEqual(-32768 <= randomInt16, true);
-assert.strictEqual(randomInt16 <= 32767, true);
+assert(-32768 <= randomInt16);
+assert(randomInt16 <= 32767);
 ```
 
 ### 4. Array Utilities with `Arr`
@@ -322,13 +322,13 @@ const numbers: readonly number[] = [1, 2, 3, 4, 5, 2, 3];
 // Reduction
 const sum = Arr.sum(numbers);
 
-assert.strictEqual(sum, 20);
+assert(sum === 20);
 
 // Type-safe length checking
 if (Arr.isArrayAtLeastLength(numbers, 2)) {
     // numbers is now guaranteed to have at least 2 elements
     expectType<typeof numbers, readonly [number, number, ...number[]]>('=');
-    assert.strictEqual(numbers[1], 2); // Safe access to index 1
+    assert(numbers[1] === 2); // Safe access to index 1
 }
 
 // Take first n elements
@@ -361,7 +361,7 @@ assert.deepStrictEqual(
     Optional.some({ name: 'Charlie', age: 35 } as const),
 );
 if (Optional.isSome(oldestPerson)) {
-    assert.strictEqual(oldestPerson.value.name, 'Charlie');
+    assert(oldestPerson.value.name === 'Charlie');
 }
 ```
 
@@ -378,10 +378,10 @@ const mapWithOne = originalMap.set('one', 1);
 const mapWithTwo = mapWithOne.set('two', 2);
 
 // Original map is unchanged
-assert.strictEqual(originalMap.size, 0);
+assert(originalMap.size === 0);
 assert.deepStrictEqual(mapWithTwo.get('one'), Optional.some(1));
 
-assert.strictEqual(mapWithTwo.has('three'), false);
+assert(!mapWithTwo.has('three'));
 
 // Using pipe for fluent updates
 const sequence = Arr.seq(10); // [0, 1, 2, ..., 9]
@@ -391,7 +391,7 @@ const pairs = sequence.map(
 const skipped = Arr.skip(pairs, 1); // [[1, "1"], ..., [9, "9"]]
 const idMap = IMap.create<number, string>(skipped);
 
-assert.strictEqual(idMap.size, 9);
+assert(idMap.size === 9);
 
 // Efficient batch updates with withMutations
 const idMapUpdated = idMap.withMutations([
@@ -400,15 +400,15 @@ const idMapUpdated = idMap.withMutations([
     { type: 'delete', key: 4 },
 ]);
 
-assert.strictEqual(idMapUpdated.size, 9);
+assert(idMapUpdated.size === 9);
 
 // ISet usage
 const originalSet = ISet.create<number>([]);
 const setWithItems = originalSet.add(1).add(2).add(1); // Duplicate ignored
 
-assert.strictEqual(originalSet.size, 0); // (unchanged)
-assert.strictEqual(setWithItems.has(1), true);
-assert.strictEqual(setWithItems.size, 2);
+assert(originalSet.size === 0); // (unchanged)
+assert(setWithItems.has(1));
+assert(setWithItems.size === 2);
 ```
 
 ### 6. Type Guards
@@ -441,9 +441,9 @@ if (isNonNullObject(value)) {
 }
 
 // Example usage
-assert.strictEqual(processData({ name: 'Alice' }), 'Hello, Alice!');
-assert.strictEqual(processData({ age: 30 }), undefined);
-assert.strictEqual(processData('not an object'), undefined);
+assert(processData({ name: 'Alice' }) === 'Hello, Alice!');
+assert(processData({ age: 30 }) === undefined);
+assert(processData('not an object') === undefined);
 ```
 
 ### 7. Iteration with `range`

package/dist/functional/pipe.d.mts

@@ -1,13 +1,4 @@
 import { Optional } from './optional.mjs';
-/**
- * @internal
- * Utility type to merge intersection types into a single object type.
- * This helps with TypeScript's display of complex intersection types.
- * @template T The intersection type to merge.
- */
-type MergeIntersection<T> = {
-    [K in keyof T]: T[K];
-};
 /**
  * Creates a new pipe object that allows for chaining operations on a value.
  *
@@ -26,13 +17,14 @@ type MergeIntersection<T> = {
  *
  * @example
  * Basic value transformation chaining:
- * ```typescript
+ * ```ts
  * // Simple sequential transformations
  * const result = pipe(10)
  *   .map(x => x * 2)        // 20
  *   .map(x => x + 5)        // 25
  *   .map(x => x.toString()) // '25'
  *   .value;
+ * assert(result === '25');
  *
  * // String processing pipeline
  * const processed = pipe("  Hello World  ")
@@ -41,82 +33,93 @@ type MergeIntersection<T> = {
  *   .map(s => s.split(' '))       // ["hello", "world"]
  *   .map(arr => arr.join('-'))    // "hello-world"
  *   .value;
+ * assert(processed === "hello-world");
  * ```
  *
  * @example
  * Nullable value handling with automatic null checking:
- * ```typescript
- * // Safe operations on potentially null values
- * const maybeNumber: number | null = getNumberFromAPI();
+ * ```ts
+ * // Safe operations on potentially nullish values
+ * const maybeNumber: number | undefined = 10;
  * const result = pipe(maybeNumber)
  *   .mapNullable(x => x * 2)           // Only applies if not null
  *   .mapNullable(x => `Result: ${x}`)  // Only applies if previous step succeeded
  *   .value; // 'Result: 20' or undefined
+ * assert(result === 'Result: 20');
  *
- * // Handling undefined values
- * const maybeUser: User | undefined = findUser(id);
- * const userName = pipe(maybeUser)
- *   .mapNullable(user => user.name)
- *   .mapNullable(name => name.toUpperCase())
- *   .value; // string or undefined
+ * // Handling null values
+ * const nullValue: number | null = null;
+ * const nullResult = pipe(nullValue)
+ *   .mapNullable(x => x * 2)
+ *   .value;
+ * assert(nullResult === undefined);
  * ```
  *
  * @example
  * Optional value handling with monadic operations:
- * ```typescript
+ * ```ts
  * // Working with Optional types
  * const optional = Optional.some(42);
  * const result = pipe(optional)
  *   .mapOptional(x => x / 2)        // Optional.some(21)
  *   .mapOptional(x => Math.sqrt(x)) // Optional.some(~4.58)
  *   .value; // Optional.some(4.58...)
+ * assert(Optional.isSome(result) === true);
+ * assert(Math.abs(Optional.unwrap(result)! - Math.sqrt(21)) < 0.01);
  *
- * // Optional chains that can become None
- * const parseAndProcess = (input: string) =>
- *   pipe(Optional.fromNullable(input))
- *     .mapOptional(s => s.trim())
- *     .mapOptional(s => s.length > 0 ? s : null) // Could become None
- *     .mapOptional(s => parseInt(s, 10))
- *     .mapOptional(n => isNaN(n) ? null : n)
- *     .value; // Optional<number>
+ * // Optional with None
+ * const noneOptional = Optional.none;
+ * const noneResult = pipe(noneOptional)
+ *   .mapOptional(x => x * 2)
+ *   .value;
+ * assert(Optional.isNone(noneResult) === true);
  * ```
  *
  * @example
  * Mixed type transformations:
- * ```typescript
+ * ```ts
  * // Starting with a string, transforming through different types
  * const complex = pipe('hello')
  *   .map(s => s.length)          // number: 5
- *   .map(n => n > 3 ? n : null)  // number | null: 5
- *   .mapNullable(n => n * 10)    // number: 50 (or undefined if null)
+ *   .map(n => n > 3 ? n : undefined)  // number | undefined: 5
+ *   .mapNullable(n => n * 10)    // number: 50 (or undefined if undefined)
  *   .value; // 50 or undefined
+ * assert(complex === 50);
  *
- * // API response processing
- * const processApiResponse = (response: ApiResponse) =>
- *   pipe(response)
- *     .map(r => r.data)                    // Extract data
- *     .mapNullable(data => data.user)      // Safe user access
- *     .mapNullable(user => user.profile)   // Safe profile access
- *     .mapNullable(profile => profile.avatar) // Safe avatar access
- *     .value; // string | undefined
+ * // Short string case
+ * const shortString = pipe('hi')
+ *   .map(s => s.length)          // number: 2
+ *   .map(n => n > 3 ? n : undefined)  // number | undefined: undefined
+ *   .mapNullable(n => n * 10)    // undefined
+ *   .value;
+ * assert(shortString === undefined);
  * ```
  *
  * @example
  * Error-safe computation chains:
- * ```typescript
+ * ```ts
  * // Building complex computations safely
- * const safeCalculation = (input: unknown) =>
- *   pipe(input)
- *     .map(val => typeof val === 'number' ? val : null)
- *     .mapNullable(n => n > 0 ? n : null)          // Positive numbers only
- *     .mapNullable(n => Math.sqrt(n))              // Safe square root
- *     .mapNullable(n => n < 100 ? n : null)        // Limit result
- *     .mapNullable(n => Math.round(n * 100) / 100) // Round to 2 decimals
- *     .value; // number | undefined
+ * const maybeNumber: number | undefined = 25;
+ * const result = pipe(maybeNumber)
+ *   .mapNullable(n => n > 0 ? n : undefined)          // Positive numbers only
+ *   .mapNullable(n => Math.sqrt(n))              // Safe square root
+ *   .mapNullable(n => n < 100 ? n : undefined)        // Limit result
+ *   .mapNullable(n => Math.round(n * 100) / 100) // Round to 2 decimals
+ *   .value; // number | undefined
+ *
+ * assert(result === 5); // sqrt(25) = 5
+ *
+ * const negativeNumber: number | undefined = -5;
+ * const negativeResult = pipe(negativeNumber)
+ *   .mapNullable(n => n > 0 ? n : undefined)
+ *   .value;
+ * assert(negativeResult === undefined); // negative number
  * ```
+ *
  */
 export declare function pipe<const A extends Optional.Base>(a: A): PipeWithMapOptional<A>;
-export declare function pipe<const A>(a: A): PipeWithMapNullable<A>;
+export declare function pipe<const A>(a: A): PipeBase<A>;
+type Pipe<A> = A extends Optional.Base ? PipeWithMapOptional<A> : PipeBase<A>;
 /**
  * @internal
  * Base pipe interface providing core functionality.
@@ -132,15 +135,7 @@ type PipeBase<A> = Readonly<{
      * @param fn Function to transform the current value.
      * @returns A new pipe containing the transformed value.
      */
-    map: <B>(fn: (a: A) => B) => PipeBase<B>;
-}>;
-/**
- * @internal
- * Pipe interface for non-Optional values, providing null-safe mapping.
- * Extends PipeBase with mapNullable functionality.
- * @template A The type of the current value in the pipe.
- */
-type PipeWithMapNullable<A> = MergeIntersection<PipeBase<A> & Readonly<{
+    map: <B>(fn: (a: A) => B) => Pipe<B>;
     /**
      * Maps the current value only if it's not null or undefined.
      * If the current value is null/undefined, the transformation is skipped
@@ -149,8 +144,8 @@ type PipeWithMapNullable<A> = MergeIntersection<PipeBase<A> & Readonly<{
      * @param fn Function to transform the non-null value.
      * @returns A new pipe containing the transformed value or undefined.
      */
-    mapNullable: <B>(fn: (a: NonNullable<A>) => B) => PipeBase<B | undefined>;
-}>>;
+    mapNullable: <B>(fn: (a: NonNullable<A>) => B) => Pipe<B | undefined>;
+}>;
 /**
  * @internal
  * Pipe interface for Optional values, providing Optional-aware mapping.
@@ -166,7 +161,7 @@ type PipeWithMapOptional<A extends Optional.Base> = MergeIntersection<PipeBase<A
      * @param fn Function to transform the inner value of the Optional.
      * @returns A new pipe containing an Optional with the transformed value.
      */
-    mapOptional: <B>(fn: (a: Optional.Unwrap<A>) => B) => PipeBase<Optional<B>>;
+    mapOptional: <B>(fn: (a: Optional.Unwrap<A>) => B) => Pipe<Optional<B>>;
 }>>;
 export {};
 //# sourceMappingURL=pipe.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pipe.d.mts","sourceRoot":"","sources":["../../src/functional/pipe.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;GAKG;AACH,KAAK,iBAAiB,CAAC,CAAC,IAAI;KACzB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GG;AACH,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,QAAQ,CAAC,IAAI,EAChD,CAAC,EAAE,CAAC,GACH,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAE1B,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAkB5D;;;;;GAKG;AACH,KAAK,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC1B,qCAAqC;IACrC,KAAK,EAAE,CAAC,CAAC;IACT;;;;;OAKG;IACH,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC;CAC1C,CAAC,CAAC;AAEH;;;;;GAKG;AACH,KAAK,mBAAmB,CAAC,CAAC,IAAI,iBAAiB,CAC7C,QAAQ,CAAC,CAAC,CAAC,GACT,QAAQ,CAAC;IACP;;;;;;;OAOG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CAC3E,CAAC,CACL,CAAC;AAEF;;;;;GAKG;AACH,KAAK,mBAAmB,CAAC,CAAC,SAAS,QAAQ,CAAC,IAAI,IAAI,iBAAiB,CACnE,QAAQ,CAAC,CAAC,CAAC,GACT,QAAQ,CAAC;IACP;;;;;;;OAOG;IACH,WAAW,EAAE,CAAC,CAAC,EACb,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAC7B,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CAC5B,CAAC,CACL,CAAC"}
+{"version":3,"file":"pipe.d.mts","sourceRoot":"","sources":["../../src/functional/pipe.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqHG;AACH,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,QAAQ,CAAC,IAAI,EAChD,CAAC,EAAE,CAAC,GACH,mBAAmB,CAAC,CAAC,CAAC,CAAC;AAE1B,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAkBjD,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,QAAQ,CAAC,IAAI,GAAG,mBAAmB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAE9E;;;;;GAKG;AACH,KAAK,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC;IAC1B,qCAAqC;IACrC,KAAK,EAAE,CAAC,CAAC;IACT;;;;;OAKG;IACH,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC;IAErC;;;;;;;OAOG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CACvE,CAAC,CAAC;AAEH;;;;;GAKG;AACH,KAAK,mBAAmB,CAAC,CAAC,SAAS,QAAQ,CAAC,IAAI,IAAI,iBAAiB,CACnE,QAAQ,CAAC,CAAC,CAAC,GACT,QAAQ,CAAC;IACP;;;;;;;OAOG;IACH,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,CACL,CAAC"}

package/dist/functional/pipe.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"pipe.mjs","sources":["../../src/functional/pipe.mts"],"sourcesContent":[null],"names":[],"mappings":";;AA6HM,SAAU,IAAI,CAAU,CAAI,EAAA;AAChC,IAAA,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE;QAC1B,OAAO;AACL,YAAA,KAAK,EAAE,CAAC;AACR,YAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACxB,YAAA,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;SAC/C;IACH;SAAO;QACL,OAAO;AACL,YAAA,KAAK,EAAE,CAAC;AACR,YAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACxB,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC,IAAI,IAAI,GAAG,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;SACzD;IACH;AACF;;;;"}
+{"version":3,"file":"pipe.mjs","sources":["../../src/functional/pipe.mts"],"sourcesContent":[null],"names":[],"mappings":";;AA8HM,SAAU,IAAI,CAAU,CAAI,EAAA;AAChC,IAAA,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE;QAC1B,OAAO;AACL,YAAA,KAAK,EAAE,CAAC;AACR,YAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACxB,YAAA,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;SAC/C;IACH;SAAO;QACL,OAAO;AACL,YAAA,KAAK,EAAE,CAAC;AACR,YAAA,GAAG,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YACxB,WAAW,EAAE,CAAC,EAAE,KAAK,IAAI,CAAC,CAAC,IAAI,IAAI,GAAG,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;SACzD;IACH;AACF;;;;"}

package/dist/object/object.d.mts

@@ -258,7 +258,7 @@ export declare namespace Obj {
      * }
      * ```
      */
-    export const fromEntries: <const Entries extends readonly (readonly [PropertyKey, unknown])[]>(entries: Entries) => IsFixedLengthList<Entries> extends true ? TsDataForgeInternals.EntriesToObject<Entries> : TsDataForgeInternals.PartialIfKeyIsUnion<TsDataForgeInternals.KeysOfEntries<Entries>, Record<TsDataForgeInternals.KeysOfEntries<Entries>, TsDataForgeInternals.ValuesOfEntries<Entries>>>;
+    export const fromEntries: <const Entries extends readonly (readonly [PropertyKey, unknown])[]>(entries: Entries) => IsFixedLengthList<Entries> extends true ? TsDataForgeInternals.EntriesToObject<Entries> : TsDataForgeInternals.PartialIfKeyIsUnion<TsDataForgeInternals.KeysOfEntries<Entries>, ReadonlyRecord<TsDataForgeInternals.KeysOfEntries<Entries>, TsDataForgeInternals.ValuesOfEntries<Entries>>>;
     /**
      * @internal
      * Internal type utilities for the Obj module.

package/dist/object/object.d.mts.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "private": false,
   "keywords": [
     "typescript",

package/src/functional/pipe.mts

@@ -1,15 +1,5 @@
 import { Optional } from './optional.mjs';
 
-/**
- * @internal
- * Utility type to merge intersection types into a single object type.
- * This helps with TypeScript's display of complex intersection types.
- * @template T The intersection type to merge.
- */
-type MergeIntersection<T> = {
-  [K in keyof T]: T[K];
-};
-
 /**
  * Creates a new pipe object that allows for chaining operations on a value.
  *
@@ -28,13 +18,14 @@ type MergeIntersection<T> = {
  *
  * @example
  * Basic value transformation chaining:
- * ```typescript
+ * ```ts
  * // Simple sequential transformations
  * const result = pipe(10)
  *   .map(x => x * 2)        // 20
  *   .map(x => x + 5)        // 25
  *   .map(x => x.toString()) // '25'
  *   .value;
+ * assert(result === '25');
  *
  * // String processing pipeline
  * const processed = pipe("  Hello World  ")
@@ -43,85 +34,95 @@ type MergeIntersection<T> = {
  *   .map(s => s.split(' '))       // ["hello", "world"]
  *   .map(arr => arr.join('-'))    // "hello-world"
  *   .value;
+ * assert(processed === "hello-world");
  * ```
  *
  * @example
  * Nullable value handling with automatic null checking:
- * ```typescript
- * // Safe operations on potentially null values
- * const maybeNumber: number | null = getNumberFromAPI();
+ * ```ts
+ * // Safe operations on potentially nullish values
+ * const maybeNumber: number | undefined = 10;
  * const result = pipe(maybeNumber)
  *   .mapNullable(x => x * 2)           // Only applies if not null
  *   .mapNullable(x => `Result: ${x}`)  // Only applies if previous step succeeded
  *   .value; // 'Result: 20' or undefined
+ * assert(result === 'Result: 20');
  *
- * // Handling undefined values
- * const maybeUser: User | undefined = findUser(id);
- * const userName = pipe(maybeUser)
- *   .mapNullable(user => user.name)
- *   .mapNullable(name => name.toUpperCase())
- *   .value; // string or undefined
+ * // Handling null values
+ * const nullValue: number | null = null;
+ * const nullResult = pipe(nullValue)
+ *   .mapNullable(x => x * 2)
+ *   .value;
+ * assert(nullResult === undefined);
  * ```
  *
  * @example
  * Optional value handling with monadic operations:
- * ```typescript
+ * ```ts
  * // Working with Optional types
  * const optional = Optional.some(42);
  * const result = pipe(optional)
  *   .mapOptional(x => x / 2)        // Optional.some(21)
  *   .mapOptional(x => Math.sqrt(x)) // Optional.some(~4.58)
  *   .value; // Optional.some(4.58...)
+ * assert(Optional.isSome(result) === true);
+ * assert(Math.abs(Optional.unwrap(result)! - Math.sqrt(21)) < 0.01);
  *
- * // Optional chains that can become None
- * const parseAndProcess = (input: string) =>
- *   pipe(Optional.fromNullable(input))
- *     .mapOptional(s => s.trim())
- *     .mapOptional(s => s.length > 0 ? s : null) // Could become None
- *     .mapOptional(s => parseInt(s, 10))
- *     .mapOptional(n => isNaN(n) ? null : n)
- *     .value; // Optional<number>
+ * // Optional with None
+ * const noneOptional = Optional.none;
+ * const noneResult = pipe(noneOptional)
+ *   .mapOptional(x => x * 2)
+ *   .value;
+ * assert(Optional.isNone(noneResult) === true);
  * ```
  *
  * @example
  * Mixed type transformations:
- * ```typescript
+ * ```ts
  * // Starting with a string, transforming through different types
  * const complex = pipe('hello')
  *   .map(s => s.length)          // number: 5
- *   .map(n => n > 3 ? n : null)  // number | null: 5
- *   .mapNullable(n => n * 10)    // number: 50 (or undefined if null)
+ *   .map(n => n > 3 ? n : undefined)  // number | undefined: 5
+ *   .mapNullable(n => n * 10)    // number: 50 (or undefined if undefined)
  *   .value; // 50 or undefined
+ * assert(complex === 50);
  *
- * // API response processing
- * const processApiResponse = (response: ApiResponse) =>
- *   pipe(response)
- *     .map(r => r.data)                    // Extract data
- *     .mapNullable(data => data.user)      // Safe user access
- *     .mapNullable(user => user.profile)   // Safe profile access
- *     .mapNullable(profile => profile.avatar) // Safe avatar access
- *     .value; // string | undefined
+ * // Short string case
+ * const shortString = pipe('hi')
+ *   .map(s => s.length)          // number: 2
+ *   .map(n => n > 3 ? n : undefined)  // number | undefined: undefined
+ *   .mapNullable(n => n * 10)    // undefined
+ *   .value;
+ * assert(shortString === undefined);
  * ```
  *
  * @example
  * Error-safe computation chains:
- * ```typescript
+ * ```ts
  * // Building complex computations safely
- * const safeCalculation = (input: unknown) =>
- *   pipe(input)
- *     .map(val => typeof val === 'number' ? val : null)
- *     .mapNullable(n => n > 0 ? n : null)          // Positive numbers only
- *     .mapNullable(n => Math.sqrt(n))              // Safe square root
- *     .mapNullable(n => n < 100 ? n : null)        // Limit result
- *     .mapNullable(n => Math.round(n * 100) / 100) // Round to 2 decimals
- *     .value; // number | undefined
+ * const maybeNumber: number | undefined = 25;
+ * const result = pipe(maybeNumber)
+ *   .mapNullable(n => n > 0 ? n : undefined)          // Positive numbers only
+ *   .mapNullable(n => Math.sqrt(n))              // Safe square root
+ *   .mapNullable(n => n < 100 ? n : undefined)        // Limit result
+ *   .mapNullable(n => Math.round(n * 100) / 100) // Round to 2 decimals
+ *   .value; // number | undefined
+ *
+ * assert(result === 5); // sqrt(25) = 5
+ *
+ * const negativeNumber: number | undefined = -5;
+ * const negativeResult = pipe(negativeNumber)
+ *   .mapNullable(n => n > 0 ? n : undefined)
+ *   .value;
+ * assert(negativeResult === undefined); // negative number
  * ```
+ *
  */
 export function pipe<const A extends Optional.Base>(
   a: A,
 ): PipeWithMapOptional<A>;
 
-export function pipe<const A>(a: A): PipeWithMapNullable<A>;
+export function pipe<const A>(a: A): PipeBase<A>;
 
 export function pipe<const A>(a: A): PipeImpl<A> {
   if (Optional.isOptional(a)) {
@@ -139,6 +140,8 @@ export function pipe<const A>(a: A): PipeImpl<A> {
   }
 }
 
+type Pipe<A> = A extends Optional.Base ? PipeWithMapOptional<A> : PipeBase<A>;
+
 /**
  * @internal
  * Base pipe interface providing core functionality.
@@ -154,29 +157,18 @@ type PipeBase<A> = Readonly<{
    * @param fn Function to transform the current value.
    * @returns A new pipe containing the transformed value.
    */
-  map: <B>(fn: (a: A) => B) => PipeBase<B>;
-}>;
+  map: <B>(fn: (a: A) => B) => Pipe<B>;
 
-/**
- * @internal
- * Pipe interface for non-Optional values, providing null-safe mapping.
- * Extends PipeBase with mapNullable functionality.
- * @template A The type of the current value in the pipe.
- */
-type PipeWithMapNullable<A> = MergeIntersection<
-  PipeBase<A> &
-    Readonly<{
-      /**
-       * Maps the current value only if it's not null or undefined.
-       * If the current value is null/undefined, the transformation is skipped
-       * and undefined is propagated through the pipe.
-       * @template B The type of the transformed value.
-       * @param fn Function to transform the non-null value.
-       * @returns A new pipe containing the transformed value or undefined.
-       */
-      mapNullable: <B>(fn: (a: NonNullable<A>) => B) => PipeBase<B | undefined>;
-    }>
->;
+  /**
+   * Maps the current value only if it's not null or undefined.
+   * If the current value is null/undefined, the transformation is skipped
+   * and undefined is propagated through the pipe.
+   * @template B The type of the transformed value.
+   * @param fn Function to transform the non-null value.
+   * @returns A new pipe containing the transformed value or undefined.
+   */
+  mapNullable: <B>(fn: (a: NonNullable<A>) => B) => Pipe<B | undefined>;
+}>;
 
 /**
  * @internal
@@ -195,9 +187,7 @@ type PipeWithMapOptional<A extends Optional.Base> = MergeIntersection<
        * @param fn Function to transform the inner value of the Optional.
        * @returns A new pipe containing an Optional with the transformed value.
        */
-      mapOptional: <B>(
-        fn: (a: Optional.Unwrap<A>) => B,
-      ) => PipeBase<Optional<B>>;
+      mapOptional: <B>(fn: (a: Optional.Unwrap<A>) => B) => Pipe<Optional<B>>;
     }>
 >;
 

package/src/object/object.mts

@@ -361,7 +361,7 @@ export namespace Obj {
     ? TsDataForgeInternals.EntriesToObject<Entries>
     : TsDataForgeInternals.PartialIfKeyIsUnion<
         TsDataForgeInternals.KeysOfEntries<Entries>,
-        Record<
+        ReadonlyRecord<
           TsDataForgeInternals.KeysOfEntries<Entries>,
           TsDataForgeInternals.ValuesOfEntries<Entries>
         >