ts-data-forge 5.0.1 → 5.1.1

package/src/array/impl/array-utils-validation.mts

@@ -7,10 +7,12 @@ import { asUint32, Num } from '../../number/index.mjs';
  *
  * ```ts
  * const maybeArray: unknown = [1, 2, 3];
+ *
  * const maybeValue: unknown = 'Ada';
  *
- * assert.ok(Arr.isArray(maybeArray));
- * assert.notOk(Arr.isArray(maybeValue));
+ * assert.isTrue(Arr.isArray(maybeArray));
+ *
+ * assert.isFalse(Arr.isArray(maybeValue));
  *
  * if (Arr.isArray(maybeArray)) {
  *   assert.deepStrictEqual(maybeArray, [1, 2, 3]);
@@ -40,10 +42,12 @@ type Cast<A, B> = A extends B ? A : never;
  *
  * ```ts
  * const emptyNumbers: readonly number[] = [] as const;
+ *
  * const words = ['Ada', 'Lovelace'] as const;
  *
- * assert.ok(Arr.isEmpty(emptyNumbers));
- * assert.notOk(Arr.isEmpty(words));
+ * assert.isTrue(Arr.isEmpty(emptyNumbers));
+ *
+ * assert.isFalse(Arr.isEmpty(words));
  *
  * if (Arr.isEmpty(emptyNumbers)) {
  *   assert.deepStrictEqual(emptyNumbers, []);
@@ -60,10 +64,12 @@ export const isEmpty = <E,>(array: readonly E[]): array is readonly [] =>
  *
  * ```ts
  * const users: readonly { id: number }[] = [{ id: 1 }];
+ *
  * const emptyUsers: readonly { id: number }[] = [];
  *
- * assert.ok(Arr.isNonEmpty(users));
- * assert.notOk(Arr.isNonEmpty(emptyUsers));
+ * assert.isTrue(Arr.isNonEmpty(users));
+ *
+ * assert.isFalse(Arr.isNonEmpty(emptyUsers));
  *
  * if (Arr.isNonEmpty(users)) {
  *   assert.deepStrictEqual(users[0], { id: 1 });
@@ -81,10 +87,12 @@ export const isNonEmpty = <E,>(
  *
  * ```ts
  * const pair: readonly number[] = [1, 2];
+ *
  * const triple: readonly number[] = [1, 2, 3];
  *
- * assert.ok(Arr.isArrayOfLength(pair, 2));
- * assert.notOk(Arr.isArrayOfLength(triple, 2));
+ * assert.isTrue(Arr.isArrayOfLength(pair, 2));
+ *
+ * assert.isFalse(Arr.isArrayOfLength(triple, 2));
  *
  * if (Arr.isArrayOfLength(pair, 2)) {
  *   assert.deepStrictEqual(pair, [1, 2]);
@@ -103,13 +111,15 @@ export const isArrayOfLength = <E, N extends SizeType.ArgArr>(
  *
  * ```ts
  * const queue: readonly string[] = ['task-1', 'task-2'];
+ *
  * const emptyQueue: readonly string[] = [];
  *
- * assert.ok(Arr.isArrayAtLeastLength(queue, 1));
- * assert.notOk(Arr.isArrayAtLeastLength(emptyQueue, 1));
+ * assert.isTrue(Arr.isArrayAtLeastLength(queue, 1));
+ *
+ * assert.isFalse(Arr.isArrayAtLeastLength(emptyQueue, 1));
  *
  * if (Arr.isArrayAtLeastLength(queue, 1)) {
- *   assert(queue[0] === 'task-1');
+ *   assert.isTrue(queue[0] === 'task-1');
  * }
  * ```
  */
@@ -125,13 +135,16 @@ export const isArrayAtLeastLength = <E, N extends SizeType.ArgArr>(
  *
  * ```ts
  * const numbers = [2, 4, 6] as const;
+ *
  * const words = ['Ada', 'Grace'] as const;
  *
  * const allEven = Arr.every(numbers, (value) => value % 2 === 0);
+ *
  * const allStartWithA = Arr.every(words, (value) => value.startsWith('A'));
  *
- * assert.ok(allEven);
- * assert.notOk(allStartWithA);
+ * assert.isTrue(allEven);
+ *
+ * assert.isFalse(allStartWithA);
  * ```
  */
 // Type guard overloads - narrow the entire array type
@@ -165,10 +178,13 @@ export function every<E>(
   switch (args.length) {
     case 2: {
       const [array, predicate] = args;
+
       return array.every((a, i) => predicate(a, asUint32(i)));
     }
+
     case 1: {
       const [predicate] = args;
+
       return (array) => every(array, predicate);
     }
   }
@@ -181,13 +197,16 @@ export function every<E>(
  *
  * ```ts
  * const numbers = [1, 3, 5] as const;
+ *
  * const words = ['Ada', 'Grace'] as const;
  *
  * const hasEven = Arr.some(numbers, (value) => value % 2 === 0);
+ *
  * const hasShortName = Arr.some(words, (value) => value.length <= 3);
  *
- * assert.notOk(hasEven);
- * assert.ok(hasShortName);
+ * assert.isFalse(hasEven);
+ *
+ * assert.isTrue(hasShortName);
  * ```
  */
 export function some<const Ar extends readonly unknown[]>(
@@ -210,10 +229,13 @@ export function some<E>(
   switch (args.length) {
     case 2: {
       const [array, predicate] = args;
+
       return array.some((a, i) => predicate(a, asUint32(i)));
     }
+
     case 1: {
       const [predicate] = args;
+
       return (array) => some(array, predicate);
     }
   }
@@ -227,11 +249,12 @@ export function some<E>(
  * ```ts
  * const items = ['Ada', 'Grace', 'Katherine'] as const;
  *
- * assert.ok(Arr.indexIsInRange(items, 1));
- * assert.notOk(Arr.indexIsInRange(items, 3));
+ * assert.isTrue(Arr.indexIsInRange(items, 1));
+ *
+ * assert.isFalse(Arr.indexIsInRange(items, 3));
  *
  * if (Arr.indexIsInRange(items, 2)) {
- *   assert(items[2] === 'Katherine');
+ *   assert.isTrue(items[2] === 'Katherine');
  * }
  * ```
  */