ts-data-forge 2.1.1 → 2.1.3

package/src/number/branded-types/safe-int.test.mts

@@ -1,4 +1,5 @@
 import { expectType } from '../../expect-type.mjs';
+import { range } from '../../iterator/index.mjs';
 import { asSafeInt, SafeInt } from './safe-int.mjs';
 
 describe('SafeInt', () => {
@@ -142,7 +143,7 @@ describe('SafeInt', () => {
       const min = -20;
       const max = 20;
 
-      for (let i = 0; i < 10; i++) {
+      for (const _ of range(10)) {
         const result = SafeInt.random(min, max);
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
@@ -152,7 +153,7 @@ describe('SafeInt', () => {
     });
 
     test('generates values within safe integer range', () => {
-      for (let i = 0; i < 10; i++) {
+      for (const _ of range(10)) {
         const result = SafeInt.random(-30, 30);
         expect(result).toBeGreaterThanOrEqual(Number.MIN_SAFE_INTEGER);
         expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);

package/src/number/branded-types/safe-uint.test.mts

@@ -1,4 +1,5 @@
 import { expectType } from '../../expect-type.mjs';
+import { range } from '../../iterator/index.mjs';
 import { asSafeUint, isSafeUint, SafeUint } from './safe-uint.mjs';
 
 describe('SafeUint', () => {
@@ -147,7 +148,7 @@ describe('SafeUint', () => {
       const min = 0;
       const max = 20;
 
-      for (let i = 0; i < 10; i++) {
+      for (const _ of range(10)) {
         const result = SafeUint.random(min, max);
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
@@ -158,7 +159,7 @@ describe('SafeUint', () => {
     });
 
     test('generates values within safe uint range', () => {
-      for (let i = 0; i < 10; i++) {
+      for (const _ of range(10)) {
         const result = SafeUint.random(0, 30);
         expect(result).toBeGreaterThanOrEqual(0);
         expect(result).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);

package/src/number/branded-types/uint.test.mts

@@ -1,4 +1,5 @@
 import { expectType } from '../../expect-type.mjs';
+import { range } from '../../iterator/index.mjs';
 import { asUint, isUint, Uint } from './uint.mjs';
 
 describe('Uint', () => {
@@ -129,7 +130,7 @@ describe('Uint', () => {
       const min = 0;
       const max = 20;
 
-      for (let i = 0; i < 10; i++) {
+      for (const _ of range(10)) {
         const result = Uint.random(min, max);
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
@@ -140,7 +141,7 @@ describe('Uint', () => {
     });
 
     test('generates values starting from 0', () => {
-      for (let i = 0; i < 10; i++) {
+      for (const _ of range(10)) {
         const result = Uint.random(0, 30);
         expect(result).toBeGreaterThanOrEqual(0);
         expect(result).toBeLessThanOrEqual(30);

package/src/number/branded-types/uint16.test.mts

@@ -1,4 +1,5 @@
 import { expectType } from '../../expect-type.mjs';
+import { range } from '../../iterator/index.mjs';
 import { asNonZeroUint16 } from './non-zero-uint16.mjs';
 import { asUint16, isUint16, Uint16 } from './uint16.mjs';
 
@@ -141,7 +142,7 @@ describe('Uint16', () => {
       const min = 0;
       const max = 20;
 
-      for (let i = 0; i < 10; i++) {
+      for (const _ of range(10)) {
         const result = Uint16.random(min, max);
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
@@ -152,7 +153,7 @@ describe('Uint16', () => {
     });
 
     test('generates values within Uint16 range', () => {
-      for (let i = 0; i < 10; i++) {
+      for (const _ of range(10)) {
         const result = Uint16.random(0, 30);
         expect(result).toBeGreaterThanOrEqual(0);
         expect(result).toBeLessThanOrEqual(65535);

package/src/number/branded-types/uint32.test.mts

@@ -1,4 +1,5 @@
 import { expectType } from '../../expect-type.mjs';
+import { range } from '../../iterator/index.mjs';
 import { asNonZeroUint32 } from './non-zero-uint32.mjs';
 import { asUint32, isUint32, Uint32 } from './uint32.mjs';
 
@@ -141,7 +142,7 @@ describe('Uint32', () => {
       const min = 0;
       const max = 20;
 
-      for (let i = 0; i < 10; i++) {
+      for (const _ of range(10)) {
         const result = Uint32.random(min, max);
         expect(result).toBeGreaterThanOrEqual(min);
         expect(result).toBeLessThanOrEqual(max);
@@ -152,7 +153,7 @@ describe('Uint32', () => {
     });
 
     test('generates values within Uint32 range', () => {
-      for (let i = 0; i < 10; i++) {
+      for (const _ of range(10)) {
         const result = Uint32.random(0, 30);
         expect(result).toBeGreaterThanOrEqual(0);
         expect(result).toBeLessThanOrEqual(4294967295);

package/src/object/object.test.mts

@@ -28,20 +28,20 @@ describe('shallowEq', () => {
 });
 
 describe('pick', () => {
-  test('truthy case 1', () => {
+  test('should pick specified keys', () => {
     expect(Obj.pick({ a: 1, b: 2, c: 3 }, ['a', 'b'])).toStrictEqual({
       a: 1,
       b: 2,
     });
   });
 
-  test('should support curried form', () => {
+  test('pick should support curried form', () => {
     const pickAB = Obj.pick(['a', 'b']);
     const result = pickAB({ a: 1, b: 2, c: 3, d: 4 });
     expect(result).toStrictEqual({ a: 1, b: 2 });
   });
 
-  test('should work with pipe when curried', () => {
+  test('pick should work with pipe when curried', () => {
     const pickIdAndName = Obj.pick(['id', 'name']);
     const user = { id: 1, name: 'Alice', email: 'alice@example.com', age: 30 };
 
@@ -49,13 +49,13 @@ describe('pick', () => {
     expect(result).toStrictEqual({ id: 1, name: 'Alice' });
   });
 
-  test('should handle empty keys in curried form', () => {
+  test('pick should handle empty keys in curried form', () => {
     const pickNone = Obj.pick([]);
     const result = pickNone({ a: 1, b: 2 });
     expect(result).toStrictEqual({});
   });
 
-  test('should work for records that only partially contain the key in curried form', () => {
+  test('pick should work for records that only partially contain the key in curried form', () => {
     const pickVisible = Obj.pick(['name', 'age']);
     const user = {
       id: 1,
@@ -71,17 +71,17 @@ describe('pick', () => {
 });
 
 describe('omit', () => {
-  test('truthy case 1', () => {
+  test('should omit specified keys', () => {
     expect(Obj.omit({ a: 1, b: 2, c: 3 }, ['c'])).toStrictEqual({ a: 1, b: 2 });
   });
 
-  test('should support curried form', () => {
+  test('omit should support curried form', () => {
     const omitC = Obj.omit(['c']);
     const result = omitC({ a: 1, b: 2, c: 3, d: 4 });
     expect(result).toStrictEqual({ a: 1, b: 2, d: 4 });
   });
 
-  test('should work with pipe when curried', () => {
+  test('omit should work with pipe when curried', () => {
     const omitSensitive = Obj.omit(['password', 'email']);
     const user = {
       id: 1,
@@ -94,7 +94,7 @@ describe('omit', () => {
     expect(result).toStrictEqual({ id: 1, name: 'Alice' });
   });
 
-  test('should handle empty keys in curried form', () => {
+  test('omit should handle empty keys in curried form', () => {
     const omitNone = Obj.omit([]);
     const original = { a: 1, b: 2, c: 3 };
     const result = omitNone(original);
@@ -107,7 +107,7 @@ describe('omit', () => {
     expect(result).toStrictEqual({ a: 1, c: 3, e: 5 });
   });
 
-  test('should work for records that only partially contain the key in curried form', () => {
+  test('omit should work for records that only partially contain the key in curried form', () => {
     const omitSensitive = Obj.omit(['password', 'email']);
     const user = {
       id: 1,

package/src/others/cast-readonly.test.mts

@@ -25,16 +25,16 @@ describe('castReadonly', () => {
     expect(Object.is(readonly, original)).toBe(true);
   });
 
-  test('should work with primitives', () => {
+  test('castReadonly should work with primitives', () => {
     expect(castReadonly(42)).toBe(42);
     expect(castReadonly('hello')).toBe('hello');
     expect(castReadonly(true)).toBe(true);
   });
 
-  test('should work with null and undefined', () => {
-    expect(castReadonly(null)).toBe(null);
+  test('castReadonly should work with null and undefined', () => {
+    expect(castReadonly(null)).toBeNull();
     // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-    expect(castReadonly(undefined)).toBe(undefined);
+    expect(castReadonly(undefined)).toBeUndefined();
   });
 });
 
@@ -75,15 +75,15 @@ describe('castDeepReadonly', () => {
     expect(readonly[1]?.meta.active).toBe(false);
   });
 
-  test('should work with primitives', () => {
+  test('castDeepReadonly should work with primitives', () => {
     expect(castDeepReadonly(42)).toBe(42);
     expect(castDeepReadonly('hello')).toBe('hello');
     expect(castDeepReadonly(true)).toBe(true);
   });
 
-  test('should work with null and undefined', () => {
-    expect(castDeepReadonly(null)).toBe(null);
+  test('castDeepReadonly should work with null and undefined', () => {
+    expect(castDeepReadonly(null)).toBeNull();
     // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-    expect(castDeepReadonly(undefined)).toBe(undefined);
+    expect(castDeepReadonly(undefined)).toBeUndefined();
   });
 });

package/src/others/memoize-function.mts

@@ -101,7 +101,7 @@
  * const memoizedFindPaths = memoizeFunction(
  *   findPaths,
  *   (start, end, visited = new Set()) =>
- *     `${start}->${end}:[${[...visited].sort().join(',')}]`
+ *     `${start}->${end}:[${[...visited].toSorted().join(',')}]`
  * );
  * ```
  *

package/src/others/memoize-function.test.mts

@@ -37,12 +37,12 @@ describe('memoizeFunction', () => {
     const memoized = memoizeFunction(mockFn, (x) => x);
 
     // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-    expect(memoized(5)).toBe(undefined);
+    expect(memoized(5)).toBeUndefined();
     expect(mockFn).toHaveBeenCalledTimes(1);
 
     // Should use cache even for undefined
     // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-    expect(memoized(5)).toBe(undefined);
+    expect(memoized(5)).toBeUndefined();
     expect(mockFn).toHaveBeenCalledTimes(1);
   });
 

package/src/others/unknown-to-string.mts

@@ -1,4 +1,3 @@
-import { Result } from '../functional/index.mjs';
 import { isNonNullish } from '../guard/index.mjs';
 
 /**
@@ -20,22 +19,22 @@ import { isNonNullish } from '../guard/index.mjs';
  * @param value - The unknown value to convert to string
  * @param options - Optional configuration for the conversion
  * @param options.prettyPrintObject - If true, objects are formatted with 2-space indentation
- * @returns A Result containing either the string representation or an Error for failures
+ * @returns The string representation of the value. For circular references or non-serializable objects, returns an error message string
  *
  * @example Basic type conversions
  * ```typescript
  * // Primitive types
- * unknownToString('hello');        // Ok('hello')
- * unknownToString(123);            // Ok('123')
- * unknownToString(true);           // Ok('true')
- * unknownToString(null);           // Ok('null')
- * unknownToString(undefined);      // Ok('undefined')
- * unknownToString(Symbol('test')); // Ok('Symbol(test)')
- * unknownToString(123n);           // Ok('123')
+ * unknownToString('hello');        // 'hello'
+ * unknownToString(123);            // '123'
+ * unknownToString(true);           // 'true'
+ * unknownToString(null);           // 'null'
+ * unknownToString(undefined);      // 'undefined'
+ * unknownToString(Symbol('test')); // 'Symbol(test)'
+ * unknownToString(123n);           // '123'
  *
  * // Function conversion
  * const fn = () => 'test';
- * unknownToString(fn); // Ok('() => 'test'')
+ * unknownToString(fn); // "() => 'test'"
  * ```
  *
  * @example Object stringification
@@ -43,24 +42,20 @@ import { isNonNullish } from '../guard/index.mjs';
  * // Simple object
  * const obj = { a: 1, b: 'hello', c: [1, 2, 3] };
  * const result = unknownToString(obj);
- * if (Result.isOk(result)) {
- *   console.log(result.value); // '{"a":1,"b":"hello","c":[1,2,3]}'
- * }
+ * console.log(result); // '{"a":1,"b":"hello","c":[1,2,3]}'
  *
  * // Pretty printing
  * const prettyResult = unknownToString(obj, { prettyPrintObject: true });
- * if (Result.isOk(prettyResult)) {
- *   console.log(prettyResult.value);
- *   // {
- *   //   "a": 1,
- *   //   "b": "hello",
- *   //   "c": [
- *   //     1,
- *   //     2,
- *   //     3
- *   //   ]
- *   // }
- * }
+ * console.log(prettyResult);
+ * // {
+ * //   "a": 1,
+ * //   "b": "hello",
+ * //   "c": [
+ * //     1,
+ * //     2,
+ * //     3
+ * //   ]
+ * // }
  * ```
  *
  * @example Error handling for circular references
@@ -70,19 +65,7 @@ import { isNonNullish } from '../guard/index.mjs';
  * circular.self = circular;
  *
  * const result = unknownToString(circular);
- * if (Result.isErr(result)) {
- *   console.log(result.value.message);
- *   // "Converting circular structure to JSON"
- * }
- *
- * // Handle with custom serialization
- * const safeStringify = (value: unknown): string => {
- *   const result = unknownToString(value);
- *   return Result.isOk(result)
- *     ? result.value
- *     : `[Error: ${result.value.message}]`;
- * };
- * ```
+ * console.log(result); // "Converting circular structure to JSON"
  *
  * @example Logging and debugging utilities
  * ```typescript
@@ -92,13 +75,9 @@ import { isNonNullish } from '../guard/index.mjs';
  *     const timestamp = new Date().toISOString();
  *     const dataStr = data !== undefined
  *       ? unknownToString(data, { prettyPrintObject: true })
- *       : Result.ok('');
+ *       : '';
  *
- *     if (Result.isOk(dataStr)) {
- *       console.log(`[${timestamp}] ${message}`, dataStr.value);
- *     } else {
- *       console.log(`[${timestamp}] ${message} [Unstringifiable data]`);
- *     }
+ *     console.log(`[${timestamp}] ${message}`, dataStr);
  *   }
  * }
  *
@@ -110,19 +89,11 @@ import { isNonNullish } from '../guard/index.mjs';
  * ```typescript
  * // Safe error response formatting
  * function formatErrorResponse(error: unknown): string {
- *   const result = unknownToString(error, { prettyPrintObject: true });
+ *   const errorStr = unknownToString(error, { prettyPrintObject: true });
  *
- *   if (Result.isOk(result)) {
- *     return JSON.stringify({
- *       success: false,
- *       error: result.value
- *     });
- *   }
- *
- *   // Fallback for unstringifiable errors
  *   return JSON.stringify({
  *     success: false,
- *     error: 'An unknown error occurred'
+ *     error: errorStr
  *   });
  * }
  *
@@ -138,78 +109,72 @@ import { isNonNullish } from '../guard/index.mjs';
  * ```typescript
  * // Date objects
  * unknownToString(new Date('2023-01-01'));
- * // Ok('"2023-01-01T00:00:00.000Z"') - JSON stringified
+ * // '"2023-01-01T00:00:00.000Z"' - JSON stringified
  *
  * // Regular expressions
  * unknownToString(/test/gi);
- * // Ok('{}') - RegExp has no enumerable properties
+ * // '{}' - RegExp has no enumerable properties
  *
  * // Arrays
  * unknownToString([1, 'two', { three: 3 }]);
- * // Ok('[1,"two",{"three":3}]')
+ * // '[1,"two",{"three":3}]'
  *
  * // Map and Set (converted to empty objects by JSON.stringify)
- * unknownToString(new Map([['a', 1]])); // Ok('{}')
- * unknownToString(new Set([1, 2, 3]));   // Ok('{}')
+ * unknownToString(new Map([['a', 1]])); // '{}'
+ * unknownToString(new Set([1, 2, 3]));   // '{}'
  * ```
  *
- * @example Integration with Result type
+ * @example Using with validation
  * ```typescript
- * import { Result, pipe } from '../functional';
- *
- * // Chain with other Result operations
- * function processUserInput(input: unknown): Result<string, Error> {
- *   return pipe(input)
- *     .map(val => unknownToString(val))
- *     .map(Result.flatten) // Flatten Result<Result<string, Error>, never>
- *     .map(str => Result.map(str, s => s.trim()))
- *     .map(Result.flatten)
- *     .map(str => Result.flatMap(str, s =>
- *       s.length > 0
- *         ? Result.ok(s)
- *         : Result.err(new Error('Empty string'))
- *     ))
- *     .value;
+ * // Simple validation helper
+ * function validateAndStringify(input: unknown): string {
+ *   const str = unknownToString(input);
+ *   const trimmed = str.trim();
+ *
+ *   if (trimmed.length === 0) {
+ *     throw new Error('Empty string');
+ *   }
+ *
+ *   return trimmed;
  * }
  * ```
  *
- * @see Result - For error handling pattern used by this function
+ * **Error Handling:**
+ * Circular references and non-serializable objects return descriptive error messages instead of throwing
  * @see JSON.stringify - Underlying serialization for objects
  */
 export const unknownToString = (
   value: unknown,
   options?: Partial<Readonly<{ prettyPrintObject: boolean }>>,
-): Result<string, Error> => {
+): string => {
   switch (typeof value) {
     case 'string':
-      return Result.ok(value);
+      return value;
 
     case 'number':
     case 'bigint':
     case 'boolean':
     case 'symbol':
     case 'function':
-      return Result.ok(value.toString());
+      return value.toString();
 
     case 'object':
       if (!isNonNullish(value)) {
-        return Result.ok('null');
+        return 'null';
       }
       try {
         const stringified =
           options?.prettyPrintObject === true
             ? JSON.stringify(value, undefined, 2)
             : JSON.stringify(value);
-        return Result.ok(stringified);
+        return stringified;
       } catch (error) {
-        return Result.err(
-          error instanceof Error
-            ? error
-            : new Error('Failed to stringify object'),
-        );
+        return error instanceof Error
+          ? error.message
+          : '[Circular or Non-serializable]';
       }
 
     case 'undefined':
-      return Result.ok('undefined');
+      return 'undefined';
   }
 };

package/src/others/unknown-to-string.test.mts

@@ -1,76 +1,51 @@
-import { Result } from '../functional/index.mjs';
 import { unknownToString } from './unknown-to-string.mjs';
 
 describe('unknownToString', () => {
   test('string', () => {
     const result = unknownToString('aaaaa');
-    expect(Result.isOk(result)).toBe(true);
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('aaaaa');
-    }
+    expect(result).toBe('aaaaa');
     expect(JSON.stringify('aaaaa')).toBe('"aaaaa"');
   });
 
   test('number', () => {
     const result = unknownToString(1);
-    expect(Result.isOk(result)).toBe(true);
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('1');
-    }
+    expect(result).toBe('1');
     expect(JSON.stringify(1)).toBe('1');
   });
 
   test('boolean', () => {
     const result = unknownToString(true);
-    expect(Result.isOk(result)).toBe(true);
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('true');
-    }
+    expect(result).toBe('true');
     expect(JSON.stringify(true)).toBe('true');
   });
 
   test('symbol', () => {
     const result = unknownToString(Symbol('sym'));
-    expect(Result.isOk(result)).toBe(true);
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('Symbol(sym)');
-    }
+    expect(result).toBe('Symbol(sym)');
     expect(JSON.stringify(Symbol('sym'))).toBeUndefined();
   });
 
   test('function', () => {
     const result = unknownToString(() => 0);
-    expect(Result.isOk(result)).toBe(true);
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('() => 0');
-    }
+    expect(result).toBe('() => 0');
     expect(JSON.stringify(() => 0)).toBeUndefined();
   });
 
   test('undefined', () => {
     const result = unknownToString(undefined);
-    expect(Result.isOk(result)).toBe(true);
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('undefined');
-    }
+    expect(result).toBe('undefined');
     expect(JSON.stringify(undefined)).toBeUndefined();
   });
 
   test('null', () => {
     const result = unknownToString(null);
-    expect(Result.isOk(result)).toBe(true);
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('null');
-    }
+    expect(result).toBe('null');
     expect(JSON.stringify(null)).toBe('null');
   });
 
   test('object', () => {
     const result = unknownToString({ a: { b: 1 } });
-    expect(Result.isOk(result)).toBe(true);
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('{"a":{"b":1}}');
-    }
+    expect(result).toBe('{"a":{"b":1}}');
     expect(JSON.stringify({ a: { b: 1 } })).toBe('{"a":{"b":1}}');
   });
 
@@ -79,36 +54,29 @@ describe('unknownToString', () => {
       { a: { b: 1 } },
       { prettyPrintObject: true },
     );
-    expect(Result.isOk(result)).toBe(true);
-    if (Result.isOk(result)) {
-      expect(result.value).toBe(
-        [
-          //
-          `{`,
-          `  "a": {`,
-          `    "b": 1`,
-          `  }`,
-          `}`,
-        ].join('\n'),
-      );
-    }
+    expect(result).toBe(
+      [
+        //
+        `{`,
+        `  "a": {`,
+        `    "b": 1`,
+        `  }`,
+        `}`,
+      ].join('\n'),
+    );
   });
 
-  test('circular reference returns error', () => {
-    const circular: { a: number; self?: unknown } = { a: 1 };
-    circular.self = circular;
-    const result = unknownToString(circular);
-    expect(Result.isErr(result)).toBe(true);
-    if (Result.isErr(result)) {
-      expect(result.value.message).toContain('circular');
-    }
+  test('circular reference returns error message', () => {
+    const mut_circular: { a: number; self?: unknown } = { a: 1 };
+    mut_circular.self = mut_circular;
+    const result = unknownToString(mut_circular);
+    // Should return an error message string instead of throwing
+    expect(typeof result).toBe('string');
+    expect(result).toMatch(/circular|serialize/iu);
   });
 
   test('BigInt value', () => {
     const result = unknownToString(BigInt(123));
-    expect(Result.isOk(result)).toBe(true);
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('123');
-    }
+    expect(result).toBe('123');
   });
 });