ts-data-forge 5.0.1 → 5.1.1

package/src/guard/key-is-in.mts

@@ -19,12 +19,13 @@
  *
  * ```ts
  * const user = { id: 1, name: 'Ada' } as const;
+ *
  * const maybeKey: string = 'name';
  *
  * if (keyIsIn(maybeKey, user)) {
- *   assert(user[maybeKey] === 'Ada');
+ *   assert.isTrue(user[maybeKey] === 'Ada');
  * } else {
- *   assert.fail('Expected a known key.');
+ *   assert.fail();
  * }
  * ```
  *

package/src/guard/key-is-in.test.mts

@@ -9,11 +9,11 @@ describe(keyIsIn, () => {
   f('a' as 'a' | 'b' | 'c', { a: 0, b: 1 });
 
   test('', () => {
-    expect(
+    assert.isTrue(
       keyIsIn('a', {
         a: 0,
         b: 1,
       }),
-    ).toBe(true);
+    );
   });
 });

package/src/iterator/range.mts

@@ -40,11 +40,15 @@ import { SafeInt, asSafeInt } from '../number/index.mjs';
  *
  * ```ts
  * const zeroToThree = Array.from(range(0, 3));
+ *
  * const threeToZero = Array.from(range(3, 0, -1));
+ *
  * const defaultEnd = Array.from(range(4));
  *
  * assert.deepStrictEqual(zeroToThree, [0, 1, 2]);
+ *
  * assert.deepStrictEqual(threeToZero, [3, 2, 1]);
+ *
  * assert.deepStrictEqual(defaultEnd, [0, 1, 2, 3]);
  * ```
  *
@@ -86,15 +90,20 @@ export function* range(
   switch (args.length) {
     case 1: {
       const [end] = args;
+
       for (const i of range(0, end, 1)) {
         yield i;
       }
+
       break;
     }
 
     case 2:
+
+    // falls through
     case 3: {
       const [start, end, step = 1] = args;
+
       for (
         let mut_i: SafeInt = asSafeInt(start);
         step > 0 ? mut_i < end : mut_i > end;

package/src/json/json.mts

@@ -21,28 +21,33 @@ export namespace Json {
    *
    * ```ts
    * const validJson = '{"name": "Alice", "age": 30}';
+   *
    * const invalidJson = '{invalid json}';
    *
    * const parsed = Json.parse(validJson);
+   *
    * const failed = Json.parse(invalidJson);
    *
-   * assert.ok(Result.isOk(parsed));
+   * assert.isTrue(Result.isOk(parsed));
+   *
    * if (Result.isOk(parsed)) {
    *   assert.deepStrictEqual(parsed.value, { name: 'Alice', age: 30 });
    * }
    *
-   * assert.ok(Result.isErr(failed));
+   * assert.isTrue(Result.isErr(failed));
    *
    * // With reviver
    * const jsonWithDate = '{"created": "2024-01-01T00:00:00.000Z"}';
+   *
    * const withReviver = Json.parse(jsonWithDate, (key, value) => {
    *   if (key === 'created' && typeof value === 'string') {
    *     return new Date(value);
    *   }
+   *
    *   return value;
    * });
    *
-   * assert.ok(Result.isOk(withReviver));
+   * assert.isTrue(Result.isOk(withReviver));
    * ```
    *
    * @param text - A valid JSON string to parse. Can contain any valid JSON data
@@ -71,6 +76,7 @@ export namespace Json {
       );
     } catch (error: unknown) {
       const errStr = unknownToString(error);
+
       return Result.err(errStr);
     }
   };
@@ -91,26 +97,31 @@ export namespace Json {
    *
    * // Basic stringify
    * const basic = Json.stringify(data);
-   * assert.ok(Result.isOk(basic));
+   *
+   * assert.isTrue(Result.isOk(basic));
+   *
    * if (Result.isOk(basic)) {
-   *   assert(basic.value === '{"name":"Bob","age":25,"active":true}');
+   *   assert.isTrue(basic.value === '{"name":"Bob","age":25,"active":true}');
    * }
    *
    * // With formatting
    * const formatted = Json.stringify(data, undefined, 2);
-   * assert.ok(Result.isOk(formatted));
+   *
+   * assert.isTrue(Result.isOk(formatted));
    *
    * // With replacer
    * const filtered = Json.stringify(data, (key, value) => {
    *   if (key === 'age') return undefined; // omit age field
+   *
    *   return value;
    * });
    *
-   * assert.ok(Result.isOk(filtered));
+   * assert.isTrue(Result.isOk(filtered));
+   *
    * if (Result.isOk(filtered)) {
-   *   assert(isString(filtered.value));
+   *   assert.isTrue(isString(filtered.value));
    *
-   *   assert.ok(!filtered.value.includes('age'));
+   *   assert.isFalse(filtered.value.includes('age'));
    * }
    * ```
    *
@@ -143,6 +154,7 @@ export namespace Json {
       return Result.ok(JSON.stringify(value, replacer, space));
     } catch (error) {
       const errStr = unknownToString(error);
+
       return Result.err(errStr);
     }
   };
@@ -170,23 +182,28 @@ export namespace Json {
    * // Select only safe properties to serialize
    * const safeJson = Json.stringifySelected(user, ['id', 'name', 'role']);
    *
-   * assert.ok(Result.isOk(safeJson));
+   * assert.isTrue(Result.isOk(safeJson));
+   *
    * if (Result.isOk(safeJson)) {
-   *   assert(isString(safeJson.value));
+   *   assert.isTrue(isString(safeJson.value));
    *
    *   const parsed: unknown = JSON.parse(safeJson.value);
+   *
    *   assert.deepStrictEqual(parsed, {
    *     id: 1,
    *     name: 'Charlie',
    *     role: 'admin',
    *   });
-   *   assert.ok(!safeJson.value.includes('password'));
-   *   assert.ok(!safeJson.value.includes('email'));
+   *
+   *   assert.isFalse(safeJson.value.includes('password'));
+   *
+   *   assert.isFalse(safeJson.value.includes('email'));
    * }
    *
    * // With formatting
    * const formatted = Json.stringifySelected(user, ['id', 'name'], 2);
-   * assert.ok(Result.isOk(formatted));
+   *
+   * assert.isTrue(Result.isOk(formatted));
    * ```
    *
    * @param value - The JavaScript value to serialize. While any value is
@@ -218,6 +235,7 @@ export namespace Json {
       );
     } catch (error) {
       const errStr = unknownToString(error);
+
       return Result.err(errStr);
     }
   };
@@ -249,28 +267,34 @@ export namespace Json {
    * // Keys will be sorted alphabetically at all levels
    * const sorted = Json.stringifySortedKey(unorderedData);
    *
-   * assert.ok(Result.isOk(sorted));
+   * assert.isTrue(Result.isOk(sorted));
+   *
    * if (Result.isOk(sorted)) {
    *   // Keys should appear in alphabetical order
    *   const expected =
    *     '{"apple":2,"mango":3,"nested":{"alpha":"a","beta":"b","zulu":"z"},"zebra":1}';
-   *   assert(sorted.value === expected);
+   *
+   *   assert.isTrue(sorted.value === expected);
    * }
    *
    * // With formatting
    * const formatted = Json.stringifySortedKey(unorderedData, 2);
-   * assert.ok(Result.isOk(formatted));
+   *
+   * assert.isTrue(Result.isOk(formatted));
+   *
    * if (Result.isOk(formatted)) {
-   *   assert(isString(formatted.value));
+   *   assert.isTrue(isString(formatted.value));
    *
    *   // Check that keys are in order (first key should be "apple")
-   *   assert.ok(
+   *   assert.isTrue(
    *     formatted.value.indexOf('"apple"') < formatted.value.indexOf('"mango"'),
    *   );
-   *   assert.ok(
+   *
+   *   assert.isTrue(
    *     formatted.value.indexOf('"mango"') < formatted.value.indexOf('"nested"'),
    *   );
-   *   assert.ok(
+   *
+   *   assert.isTrue(
    *     formatted.value.indexOf('"nested"') < formatted.value.indexOf('"zebra"'),
    *   );
    * }
@@ -321,10 +345,13 @@ const keysDeepImpl = (
 ): void => {
   for (const k of Object.keys(obj)) {
     mut_keys.push(k);
+
     const o = obj[k];
+
     if (isRecord(o)) {
       keysDeepImpl(o, mut_keys);
     }
+
     if (Array.isArray(o)) {
       for (const li of o) {
         if (isRecord(li)) {
@@ -349,6 +376,8 @@ const keysDeepImpl = (
  */
 const keysDeep = (obj: UnknownRecord): readonly string[] => {
   const mut_keys: string[] = [];
+
   keysDeepImpl(obj, mut_keys);
+
   return mut_keys;
 };