ts-data-forge 2.1.1 → 2.1.3

package/src/collections/queue.test.mts

@@ -1,5 +1,6 @@
 import { Arr } from '../array/index.mjs';
 import { Optional } from '../functional/index.mjs';
+import { range } from '../iterator/index.mjs';
 import { asUint32 } from '../number/index.mjs';
 import { createQueue, type Queue } from './queue.mjs';
 
@@ -19,22 +20,23 @@ describe('Queue', () => {
   });
 
   describe('enqueue', () => {
-    let q: Queue<number>;
+    let mut_q: Queue<number>;
 
+    // eslint-disable-next-line vitest/no-hooks
     beforeEach(() => {
-      q = createQueue();
+      mut_q = createQueue();
     });
 
     test('should increase size and not be empty after enqueueing to an empty queue', () => {
-      q.enqueue(1);
-      expect(q.isEmpty).toBe(false);
-      expect(q.size).toBe(1);
+      mut_q.enqueue(1);
+      expect(mut_q.isEmpty).toBe(false);
+      expect(mut_q.size).toBe(1);
     });
 
     test('should increase size when enqueueing to a non-empty queue', () => {
-      q.enqueue(1);
-      q.enqueue(2);
-      expect(q.size).toBe(2);
+      mut_q.enqueue(1);
+      mut_q.enqueue(2);
+      expect(mut_q.size).toBe(2);
     });
   });
 
@@ -86,35 +88,35 @@ describe('Queue', () => {
 
       expect(q.size).toBe(3);
 
-      let result = q.dequeue(); // Dequeues 1 (first in)
-      expect(Optional.isSome(result) && result.value === 1).toBe(true);
+      let mut_result = q.dequeue(); // Dequeues 1 (first in)
+      expect(Optional.isSome(mut_result) && mut_result.value === 1).toBe(true);
       expect(q.size).toBe(2);
 
-      result = q.dequeue(); // Dequeues 2
-      expect(Optional.isSome(result) && result.value === 2).toBe(true);
+      mut_result = q.dequeue(); // Dequeues 2
+      expect(Optional.isSome(mut_result) && mut_result.value === 2).toBe(true);
       expect(q.size).toBe(1);
 
-      result = q.dequeue(); // Dequeues 3
-      expect(Optional.isSome(result) && result.value === 3).toBe(true);
+      mut_result = q.dequeue(); // Dequeues 3
+      expect(Optional.isSome(mut_result) && mut_result.value === 3).toBe(true);
       expect(q.size).toBe(0);
       expect(q.isEmpty).toBe(true);
 
-      result = q.dequeue();
-      expect(Optional.isNone(result)).toBe(true);
+      mut_result = q.dequeue();
+      expect(Optional.isNone(mut_result)).toBe(true);
     });
 
     test('initial values are dequeued in the same order (FIFO)', () => {
       const q = createQueue([1, 2, 3]); // Internal: [1, 2, 3]
       expect(q.size).toBe(3);
 
-      let result = q.dequeue(); // Dequeues 1 (first element)
-      expect(Optional.isSome(result) && result.value === 1).toBe(true);
+      const result1 = q.dequeue(); // Dequeues 1 (first element)
+      expect(Optional.isSome(result1) && result1.value === 1).toBe(true);
 
-      result = q.dequeue(); // Dequeues 2
-      expect(Optional.isSome(result) && result.value === 2).toBe(true);
+      const result2 = q.dequeue(); // Dequeues 2
+      expect(Optional.isSome(result2) && result2.value === 2).toBe(true);
 
-      result = q.dequeue(); // Dequeues 3
-      expect(Optional.isSome(result) && result.value === 3).toBe(true);
+      const result3 = q.dequeue(); // Dequeues 3
+      expect(Optional.isSome(result3) && result3.value === 3).toBe(true);
 
       expect(q.isEmpty).toBe(true);
     });
@@ -125,20 +127,20 @@ describe('Queue', () => {
       q.enqueue('A');
       q.enqueue('B');
 
-      let result = q.dequeue();
-      expect(Optional.isSome(result) && result.value === 'A').toBe(true);
+      const result1 = q.dequeue();
+      expect(Optional.isSome(result1) && result1.value === 'A').toBe(true);
 
       q.enqueue('C');
       q.enqueue('D');
 
-      result = q.dequeue();
-      expect(Optional.isSome(result) && result.value === 'B').toBe(true);
+      const result2 = q.dequeue();
+      expect(Optional.isSome(result2) && result2.value === 'B').toBe(true);
 
-      result = q.dequeue();
-      expect(Optional.isSome(result) && result.value === 'C').toBe(true);
+      const result3 = q.dequeue();
+      expect(Optional.isSome(result3) && result3.value === 'C').toBe(true);
 
-      result = q.dequeue();
-      expect(Optional.isSome(result) && result.value === 'D').toBe(true);
+      const result4 = q.dequeue();
+      expect(Optional.isSome(result4) && result4.value === 'D').toBe(true);
 
       expect(q.isEmpty).toBe(true);
     });
@@ -149,7 +151,7 @@ describe('Queue', () => {
       const q = createQueue<number>();
 
       // Fill and partially empty the queue to create wraparound conditions
-      for (let i = 1; i <= 5; i++) {
+      for (const i of range(1, 6)) {
         q.enqueue(i);
       }
 
@@ -177,14 +179,14 @@ describe('Queue', () => {
       const q = createQueue<number>();
 
       // Add more elements than initial capacity (8) to trigger resize
-      for (let i = 1; i <= 20; i++) {
+      for (const i of range(1, 21)) {
         q.enqueue(i);
       }
 
       expect(q.size).toBe(20);
 
       // Verify all elements can be dequeued in correct order
-      for (let i = 1; i <= 20; i++) {
+      for (const i of range(1, 21)) {
         const result = q.dequeue();
         expect(Optional.isSome(result) && result.value === i).toBe(true);
       }
@@ -196,29 +198,29 @@ describe('Queue', () => {
       const q = createQueue<number>();
 
       // Add many elements to trigger multiple resizes
-      for (let i = 1; i <= 100; i++) {
+      for (const i of range(1, 101)) {
         q.enqueue(i);
       }
 
       expect(q.size).toBe(100);
 
       // Remove half
-      for (let i = 1; i <= 50; i++) {
+      for (const i of range(1, 51)) {
         expect(Optional.unwrap(q.dequeue())).toBe(i);
       }
 
       // Add more to trigger another resize
-      for (let i = 101; i <= 150; i++) {
+      for (const i of range(101, 151)) {
         q.enqueue(i);
       }
 
       expect(q.size).toBe(100); // 50 remaining + 50 new
 
       // Verify correct order
-      for (let i = 51; i <= 100; i++) {
+      for (const i of range(51, 101)) {
         expect(Optional.unwrap(q.dequeue())).toBe(i);
       }
-      for (let i = 101; i <= 150; i++) {
+      for (const i of range(101, 151)) {
         expect(Optional.unwrap(q.dequeue())).toBe(i);
       }
 
@@ -229,7 +231,7 @@ describe('Queue', () => {
       const q = createQueue<string>();
 
       // Test single element enqueue/dequeue cycles
-      for (let i = 0; i < 10; i++) {
+      for (const i of range(10)) {
         q.enqueue(`item-${i}`);
         expect(q.size).toBe(1);
 
@@ -248,7 +250,7 @@ describe('Queue', () => {
       expect(q.size).toBe(50);
 
       // Verify all elements are in correct order
-      for (let i = 1; i <= 50; i++) {
+      for (const i of range(1, 51)) {
         expect(Optional.unwrap(q.dequeue())).toBe(i);
       }
 
@@ -260,18 +262,18 @@ describe('Queue', () => {
       const objects = Arr.seq(10).map((i) => ({ id: i }));
 
       // Add all objects
-      objects.forEach((obj) => {
+      for (const obj of objects) {
         q.enqueue(obj);
-      });
+      }
 
       // Remove first 5 objects
-      for (let i = 0; i < 5; i++) {
+      for (const i of range(0, 5)) {
         const result = q.dequeue();
         expect(Optional.isSome(result) && result.value.id === i).toBe(true);
       }
 
       // Remaining objects should still be accessible
-      for (let i = 5; i < 10; i++) {
+      for (const i of range(5, 10)) {
         const result = q.dequeue();
         expect(Optional.isSome(result) && result.value.id === i).toBe(true);
       }

package/src/collections/stack.mts

@@ -1,7 +1,6 @@
-import { Arr } from '../array/index.mjs';
 import { Optional } from '../functional/index.mjs';
+import { range } from '../iterator/index.mjs';
 import { asUint32, Uint32 } from '../number/index.mjs';
-import { castMutable } from '../others/index.mjs';
 
 /**
  * Interface for a high-performance stack with LIFO (Last-In, First-Out) behavior.
@@ -116,8 +115,9 @@ class StackClass<T> implements Stack<T> {
       Math.max(StackClass.#INITIAL_CAPACITY, initialValues.length * 2),
     );
 
-    this.#buffer = castMutable(
-      Arr.create<T | undefined, Uint32>(initialCapacity, undefined),
+    this.#buffer = Array.from<unknown, T | undefined>(
+      { length: initialCapacity },
+      () => undefined,
     );
     this.#mut_size = asUint32(0);
     this.#capacity = initialCapacity;
@@ -238,7 +238,7 @@ class StackClass<T> implements Stack<T> {
    * // High-volume pushing (demonstrates amortized O(1) performance)
    * const dataStack = createStack<number>();
    *
-   * for (let i = 0; i < 1000000; i++) {
+   * for (const i of range(1000000)) {
    *   dataStack.push(i); // Each operation is O(1) amortized
    * }
    *
@@ -274,12 +274,13 @@ class StackClass<T> implements Stack<T> {
    */
   #resize(): void {
     const newCapacity = asUint32(this.#capacity * 2);
-    const newBuffer = castMutable(
-      Arr.create<T | undefined, Uint32>(newCapacity, undefined),
+    const newBuffer = Array.from<unknown, T | undefined>(
+      { length: newCapacity },
+      () => undefined,
     );
 
     // Copy existing elements
-    for (let i = 0; i < this.#mut_size; i++) {
+    for (const i of range(this.#mut_size)) {
       newBuffer[i] = this.#buffer[i];
     }
 
@@ -384,7 +385,7 @@ class StackClass<T> implements Stack<T> {
  * const processingStack = createStack<number>();
  *
  * // Add large amount of data (demonstrates amortized O(1) performance)
- * for (let i = 0; i < 100000; i++) {
+ * for (const i of range(100000)) {
  *   processingStack.push(i); // Each push is O(1) amortized
  * }
  *

package/src/collections/stack.test.mts

@@ -1,5 +1,7 @@
 import { expectType } from '../expect-type.mjs';
 import { Optional } from '../functional/index.mjs';
+import { range } from '../iterator/index.mjs';
+import { asPositiveSafeInt, asSafeInt } from '../number/index.mjs';
 import { createStack, type Stack } from './stack.mjs';
 
 describe('Stack', () => {
@@ -125,10 +127,10 @@ describe('Stack', () => {
 
   test('should handle large number of operations efficiently', () => {
     const stack = createStack<number>();
-    const n = 10000;
+    const n = asPositiveSafeInt(10000);
 
     // Push many elements
-    for (let i = 0; i < n; i++) {
+    for (const i of range(n)) {
       stack.push(i);
     }
 
@@ -136,7 +138,7 @@ describe('Stack', () => {
     expect(stack.isEmpty).toBe(false);
 
     // Pop all elements and verify LIFO order
-    for (let i = n - 1; i >= 0; i--) {
+    for (const i of range(asSafeInt(n - 1), -1, -1)) {
       const result = stack.pop();
       expect(Optional.isSome(result)).toBe(true);
       expect(Optional.unwrap(result)).toBe(i);
@@ -157,7 +159,7 @@ describe('Stack', () => {
     Optional.unwrap(stack.pop());
 
     // Original array should be unchanged
-    expect(initialValues.length).toBe(originalLength);
+    expect(initialValues).toHaveLength(originalLength);
     expect(initialValues).toStrictEqual([1, 2, 3]);
   });
 
@@ -170,8 +172,8 @@ describe('Stack', () => {
     stack.push('another');
 
     expect(Optional.unwrap(stack.pop())).toBe('another');
-    expect(Optional.unwrap(stack.pop())).toBe(undefined);
-    expect(Optional.unwrap(stack.pop())).toBe(null);
+    expect(Optional.unwrap(stack.pop())).toBeUndefined();
+    expect(Optional.unwrap(stack.pop())).toBeNull();
     expect(Optional.unwrap(stack.pop())).toBe('value');
     expect(stack.isEmpty).toBe(true);
   });
@@ -183,7 +185,7 @@ describe('Stack', () => {
     const startTime = performance.now();
 
     // Push operations should be O(1) amortized
-    for (let i = 0; i < 1000; i++) {
+    for (const i of range(511)) {
       stack.push(i);
     }
 
@@ -195,14 +197,14 @@ describe('Stack', () => {
     const endTime = performance.now();
     const duration = endTime - startTime;
 
-    // Should complete in reasonable time (much less than 100ms for 1000 operations)
+    // Should complete in reasonable time (much less than 100ms for 512 operations)
     expect(duration).toBeLessThan(100);
   });
 
   test('should handle alternating push/pop operations', () => {
     const stack = createStack<number>();
 
-    for (let i = 0; i < 100; i++) {
+    for (const i of range(100)) {
       stack.push(i);
       if (i % 2 === 1) {
         // Pop every other time
@@ -215,7 +217,7 @@ describe('Stack', () => {
     expect(stack.size).toBe(50);
 
     // Verify elements are in correct LIFO order
-    for (let i = 98; i >= 0; i -= 2) {
+    for (const i of range(98, -1, -2)) {
       const result = stack.pop();
       expect(Optional.unwrap(result)).toBe(i);
     }

package/src/entry-point.mts

@@ -1,3 +1,4 @@
+// eslint-disable-next-line import/no-unassigned-import
 import 'ts-type-forge';
 
 export * from './index.mjs';

package/src/functional/match.mts

@@ -186,11 +186,7 @@ export function match<
     }
     case 3: {
       const [target, cases, defaultValue] = args;
-      if (keyIsIn(target, cases)) {
-        return cases[target];
-      } else {
-        return defaultValue;
-      }
+      return keyIsIn(target, cases) ? cases[target] : defaultValue;
     }
   }
 }

package/src/functional/optional.mts

@@ -1,5 +1,4 @@
 import { isRecord } from '../guard/index.mjs';
-import { pipe } from './pipe.mjs';
 
 /** @internal String literal tag to identify the 'Some' variant of Optional. */
 const SomeTypeTagName = 'ts-data-forge::Optional.some';
@@ -451,11 +450,12 @@ export namespace Optional {
     switch (args.length) {
       case 2: {
         const [optional, predicate] = args;
-        return isSome(optional)
-          ? pipe(unwrap(optional)).map((value) =>
-              predicate(value) ? some(value) : none,
-            ).value
-          : none;
+        if (isSome(optional)) {
+          const value = unwrap(optional);
+          return predicate(value) ? some(value) : none;
+        }
+        // If the optional is None, return None
+        return none;
       }
 
       case 1: {

package/src/functional/optional.test.mts

@@ -55,7 +55,7 @@ describe('Optional', () => {
       expect(Optional.isNone(Optional.none)).toBe(true);
       expect(Optional.isSome(Optional.none)).toBe(false);
       // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-      expect(Optional.unwrapOr(Optional.none, undefined)).toBe(undefined);
+      expect(Optional.unwrapOr(Optional.none, undefined)).toBeUndefined();
     });
 
     test('should always reference the same instance', () => {
@@ -158,12 +158,12 @@ describe('Optional', () => {
     test('should return the value for Some', () => {
       expect(Optional.unwrap(Optional.some(42))).toBe(42);
       expect(Optional.unwrap(Optional.some('hello'))).toBe('hello');
-      expect(Optional.unwrap(Optional.some(null))).toBe(null);
+      expect(Optional.unwrap(Optional.some(null))).toBeNull();
     });
 
     test('should return undefined for None', () => {
       // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-      expect(Optional.unwrapOr(Optional.none, undefined)).toBe(undefined);
+      expect(Optional.unwrapOr(Optional.none, undefined)).toBeUndefined();
     });
 
     test('should have correct return types', () => {
@@ -579,12 +579,12 @@ describe('Optional', () => {
     test('should convert Some to its value', () => {
       expect(Optional.toNullable(Optional.some(42))).toBe(42);
       expect(Optional.toNullable(Optional.some('hello'))).toBe('hello');
-      expect(Optional.toNullable(Optional.some(null))).toBe(null);
+      expect(Optional.toNullable(Optional.some(null))).toBeNull();
     });
 
     test('should convert None to null', () => {
       // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-      expect(Optional.toNullable(Optional.none)).toBe(undefined);
+      expect(Optional.toNullable(Optional.none)).toBeUndefined();
     });
 
     test('should have correct return type', () => {
@@ -598,7 +598,7 @@ describe('Optional', () => {
       const someUndefined = Optional.some(undefined);
       expect(Optional.isSome(someUndefined)).toBe(true);
       // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
-      expect(Optional.unwrap(someUndefined)).toBe(undefined);
+      expect(Optional.unwrap(someUndefined)).toBeUndefined();
 
       // This is different from None
       expect(someUndefined).not.toBe(Optional.none);
@@ -607,7 +607,7 @@ describe('Optional', () => {
     test('should handle null as a Some value', () => {
       const someNull = Optional.some(null);
       expect(Optional.isSome(someNull)).toBe(true);
-      expect(Optional.unwrap(someNull)).toBe(null);
+      expect(Optional.unwrap(someNull)).toBeNull();
     });
 
     test('should handle nested Optionals', () => {

package/src/functional/result.mts

@@ -852,11 +852,7 @@ export namespace Result {
         return err(error);
       }
       const msg = unknownToString(error);
-      if (isErr(msg)) {
-        return err(new Error(String(error)));
-      } else {
-        return err(new Error(msg.value));
-      }
+      return err(new Error(msg));
     }
   };
 

package/src/guard/is-non-empty-string.test.mts

@@ -85,7 +85,7 @@ describe('isNonEmptyString', () => {
 
   test('should not accept String objects', () => {
     // @ts-expect-error Testing non-string types
-    // eslint-disable-next-line no-new-wrappers
+    // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins
     expect(isNonEmptyString(new String('hello') as unknown)).toBe(false);
   });
 });

package/src/guard/is-non-null-object.test.mts

@@ -31,11 +31,11 @@ describe('isNonNullObject', () => {
   });
 
   test('should return true for boxed primitives', () => {
-    // eslint-disable-next-line no-new-wrappers
+    // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins
     expect(isNonNullObject(new String('hello'))).toBe(true);
-    // eslint-disable-next-line no-new-wrappers
+    // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins
     expect(isNonNullObject(new Number(42))).toBe(true);
-    // eslint-disable-next-line no-new-wrappers
+    // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins
     expect(isNonNullObject(new Boolean(true))).toBe(true);
   });
 

package/src/guard/is-primitive.test.mts

@@ -66,11 +66,11 @@ describe('isPrimitive', () => {
   });
 
   test('should return false for boxed primitives', () => {
-    // eslint-disable-next-line no-new-wrappers
+    // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins
     expect(isPrimitive(new String('hello'))).toBe(false);
-    // eslint-disable-next-line no-new-wrappers
+    // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins
     expect(isPrimitive(new Number(42))).toBe(false);
-    // eslint-disable-next-line no-new-wrappers
+    // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins
     expect(isPrimitive(new Boolean(true))).toBe(false);
   });
 
@@ -89,12 +89,12 @@ describe('isPrimitive', () => {
     const primitives = values.filter(isPrimitive);
     const nonPrimitives = values.filter((v) => !isPrimitive(v));
 
-    expect(primitives.length).toBe(6); // string, 42, true, null, undefined, symbol
+    expect(primitives).toHaveLength(6); // string, 42, true, null, undefined, symbol
     expect(primitives[0]).toBe('string');
     expect(primitives[1]).toBe(42);
     expect(primitives[2]).toBe(true);
-    expect(primitives[3]).toBe(null);
-    expect(primitives[4]).toBe(undefined);
+    expect(primitives[3]).toBeNull();
+    expect(primitives[4]).toBeUndefined();
     expect(typeof primitives[5]).toBe('symbol');
 
     expect(nonPrimitives).toStrictEqual([{}, []]);

package/src/guard/is-type.test.mts

@@ -112,7 +112,7 @@ describe('isString', () => {
     expect(isString(true)).toBe(false);
     expect(isString(null)).toBe(false);
     expect(isString(undefined)).toBe(false);
-    // eslint-disable-next-line no-new-wrappers
+    // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins
     expect(isString(new String('hello'))).toBe(false);
   });
 
@@ -120,7 +120,7 @@ describe('isString', () => {
     const value: unknown = 'test';
     if (isString(value)) {
       expectType<typeof value, string>('=');
-      expect(value.length).toBe(4);
+      expect(value).toHaveLength(4);
     }
   });
 });
@@ -140,7 +140,7 @@ describe('isNumber', () => {
     expect(isNumber(true)).toBe(false);
     expect(isNumber(null)).toBe(false);
     expect(isNumber(BigInt(123))).toBe(false);
-    // eslint-disable-next-line no-new-wrappers
+    // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins
     expect(isNumber(new Number(42))).toBe(false);
   });
 
@@ -187,7 +187,7 @@ describe('isBoolean', () => {
     expect(isBoolean(0)).toBe(false);
     expect(isBoolean('true')).toBe(false);
     expect(isBoolean(null)).toBe(false);
-    // eslint-disable-next-line no-new-wrappers
+    // eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins
     expect(isBoolean(new Boolean(true))).toBe(false);
   });
 
@@ -424,7 +424,7 @@ describe('isNonNullish', () => {
     const value: string | null | undefined = 'test';
     if (isNonNullish(value)) {
       expectType<typeof value, string>('<=');
-      expect(value.length).toBe(4);
+      expect(value).toHaveLength(4);
     }
   });
 
@@ -460,13 +460,9 @@ describe('type guard behavior in complex scenarios', () => {
   test('should work with nested conditions', () => {
     const value: string | number | boolean | null | undefined = 'test';
 
-    if (isNonNullish(value)) {
-      if (isNotBoolean(value)) {
-        if (isNotNumber(value)) {
-          expectType<typeof value, string>('<=');
-          expect(typeof value).toBe('string');
-        }
-      }
+    if (isNonNullish(value) && isNotBoolean(value) && isNotNumber(value)) {
+      expectType<typeof value, string>('<=');
+      expect(typeof value).toBe('string');
     }
   });
 

package/src/iterator/range.test.mts

@@ -15,7 +15,7 @@ describe('range', () => {
     expect(Array.from(range(0))).toStrictEqual([]);
   });
 
-  test('range(0)', () => {
+  test('range(-1)', () => {
     // @ts-expect-error negative end is not allowed
     expect(Array.from(range(-1))).toStrictEqual([]);
   });

package/src/json/json.mts

@@ -1,8 +1,7 @@
 import { Arr } from '../array/index.mjs';
 import { pipe, Result } from '../functional/index.mjs';
 import { isRecord } from '../guard/index.mjs';
-import { castMutable } from '../others/index.mjs';
-import { unknownToString } from '../others/unknown-to-string.mjs';
+import { castMutable, unknownToString } from '../others/index.mjs';
 
 /**
  * A collection of type-safe JSON utility functions that provide safe parsing,
@@ -74,9 +73,7 @@ export namespace Json {
       );
     } catch (error: unknown) {
       const errStr = unknownToString(error);
-      return Result.err(
-        Result.isOk(errStr) ? errStr.value : 'Failed to parse JSON',
-      );
+      return Result.err(errStr);
     }
   };
 
@@ -129,9 +126,7 @@ export namespace Json {
       return Result.ok(JSON.stringify(value, replacer, space));
     } catch (error) {
       const errStr = unknownToString(error);
-      return Result.err(
-        Result.isOk(errStr) ? errStr.value : 'Failed to stringify JSON',
-      );
+      return Result.err(errStr);
     }
   };
 
@@ -182,9 +177,7 @@ export namespace Json {
       );
     } catch (error) {
       const errStr = unknownToString(error);
-      return Result.err(
-        Result.isOk(errStr) ? errStr.value : 'Failed to stringify JSON',
-      );
+      return Result.err(errStr);
     }
   };