ts-data-forge 6.4.0 → 6.6.0

package/src/collections/iset-mapped.test.mts

@@ -2,13 +2,13 @@ import { ISetMapped } from './iset-mapped.mjs';
 
 const toKey = (a: Readonly<{ v: number }>): number => a.v;
 
-const fromKey = (k: number): Readonly<{ v: number }> => ({ v: k });
+const fromKey = (k: number): Readonly<{ v: number }> => ({ v: k }) as const;
 
 // Test types for additional functionality
 type TestElement = Readonly<{ id: number; type: string }>;
 
 const testElementToString = (el: Readonly<TestElement>): string =>
-  `${el.type}_${el.id}`;
+  `${el.type}_${el.id}` as const;
 
 const stringToTestElement = (str: string): TestElement => {
   const [type, idStr] = str.split('_');
@@ -185,7 +185,7 @@ describe('ISetMapped.forEach', () => {
       fromKey,
     );
 
-    const elements = [{ v: 1 }, { v: 2 }, { v: 3 }];
+    const elements = [{ v: 1 }, { v: 2 }, { v: 3 }] as const;
 
     for (const el of s0) {
       expect(elements).toContainEqual(el);
@@ -201,7 +201,7 @@ describe('ISetMapped.keys', () => {
       fromKey,
     );
 
-    const elements = [{ v: 1 }, { v: 2 }, { v: 3 }];
+    const elements = [{ v: 1 }, { v: 2 }, { v: 3 }] as const;
 
     for (const k of s0.keys()) {
       expect(elements).toContainEqual(k);
@@ -217,7 +217,7 @@ describe('ISetMapped.values', () => {
       fromKey,
     );
 
-    const elements = [{ v: 1 }, { v: 2 }, { v: 3 }];
+    const elements = [{ v: 1 }, { v: 2 }, { v: 3 }] as const;
 
     for (const v of s0.values()) {
       expect(elements).toContainEqual(v);
@@ -233,7 +233,7 @@ describe('ISetMapped.entries', () => {
       fromKey,
     );
 
-    const elements = [{ v: 1 }, { v: 2 }, { v: 3 }];
+    const elements = [{ v: 1 }, { v: 2 }, { v: 3 }] as const;
 
     for (const [k, v] of s0.entries()) {
       expect(elements).toContainEqual(k);

package/src/collections/iset.mts

@@ -83,7 +83,9 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
   // Reducing a value
 
   /**
-   * Checks if all elements in the set satisfy a predicate.
+   * Checks if all elements in the set satisfy a predicate. Also supports a
+   * type predicate overload that narrows the type of elements in the set if
+   * the predicate returns true for all elements.
    *
    * @example
    *
@@ -101,19 +103,11 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    * assert.isTrue(narrowed);
    * ```
    *
+   * @template L The narrowed type of the elements.
    * @param predicate A function to test each element.
    * @returns `true` if all elements satisfy the predicate, `false` otherwise.
    */
   every: ((predicate: (key: K) => boolean) => boolean) &
-    /**
-     * Checks if all elements in the set satisfy a type predicate. Narrows the
-     * type of elements in the set if the predicate returns true for all
-     * elements.
-     *
-     * @template L The narrowed type of the elements.
-     * @param predicate A type predicate function.
-     * @returns `true` if all elements satisfy the predicate, `false` otherwise.
-     */
     (<L extends K>(predicate: (key: K) => key is L) => this is ISet<L>);
 
   /**
@@ -194,7 +188,7 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    * >[] = [
    *   { type: 'add', key: 'c' },
    *   { type: 'delete', key: 'a' },
-   * ];
+   * ] as const;
    *
    * const mutated = base.withMutations(actions);
    *
@@ -234,8 +228,8 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
   map: <K2 extends MapSetKeyType>(mapFn: (key: K) => K2) => ISet<K2>;
 
   /**
-   * Filters the elements of the set based on a type predicate. Narrows the type
-   * of elements in the resulting set.
+   * Filters the elements of the set based on a predicate. Also supports a type
+   * predicate overload that narrows the type of elements in the resulting set.
    *
    * @example
    *
@@ -254,16 +248,10 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    * ```
    *
    * @template K2 The narrowed type of the elements.
-   * @param predicate A type predicate function.
-   * @returns A new ISet instance with elements that satisfy the type predicate.
+   * @param predicate A function to test each element.
+   * @returns A new ISet instance with elements that satisfy the predicate.
    */
   filter: (<K2 extends K>(predicate: (key: K) => key is K2) => ISet<K2>) &
-    /**
-     * Filters the elements of the set based on a predicate.
-     *
-     * @param predicate A function to test each element.
-     * @returns A new ISet instance with elements that satisfy the predicate.
-     */
     ((predicate: (key: K) => boolean) => ISet<K>);
 
   /**
@@ -637,10 +625,11 @@ export namespace ISet {
   export const diff = <K extends MapSetKeyType>(
     oldSet: ISet<K>,
     newSet: ISet<K>,
-  ): ReadonlyRecord<'added' | 'deleted', ISet<K>> => ({
-    deleted: oldSet.subtract(newSet),
-    added: newSet.subtract(oldSet),
-  });
+  ): ReadonlyRecord<'added' | 'deleted', ISet<K>> =>
+    ({
+      deleted: oldSet.subtract(newSet),
+      added: newSet.subtract(oldSet),
+    }) as const;
 
   /**
    * Computes the intersection of two ISet instances.

package/src/collections/queue.test.mts

@@ -585,7 +585,8 @@ describe('Queue test', () => {
       // Perform 1000 random operations
       for (const _i of range(asUint32(1000))) {
         // Randomly decide to enqueue or dequeue
-        const shouldEnqueue = mut_expected.length === 0 || Math.random() < 0.6;
+        const shouldEnqueue =
+          Arr.isArrayOfLength(mut_expected, 0) || Math.random() < 0.6;
 
         if (shouldEnqueue) {
           mut_counter += 1;

package/src/collections/stack.test.mts

@@ -153,9 +153,9 @@ describe('Stack test', () => {
 
     const stack = createStack<Item>();
 
-    const item1: Item = { id: 1, name: 'first' };
+    const item1: Item = { id: 1, name: 'first' } as const;
 
-    const item2: Item = { id: 2, name: 'second' };
+    const item2: Item = { id: 2, name: 'second' } as const;
 
     stack.push(item1);
 
@@ -198,7 +198,7 @@ describe('Stack test', () => {
   });
 
   test('should not mutate initial values array', () => {
-    const initialValues = [1, 2, 3];
+    const initialValues = [1, 2, 3] as readonly number[];
 
     const originalLength = initialValues.length;
 

package/src/functional/optional/impl/optional-is-optional.mts

@@ -1,4 +1,4 @@
-import { isRecord } from '../../../guard/index.mjs';
+import { hasKey, isRecord } from '../../../guard/index.mjs';
 import { NoneTypeTagName, SomeTypeTagName } from './tag.mjs';
 
 /**
@@ -9,7 +9,7 @@ import { NoneTypeTagName, SomeTypeTagName } from './tag.mjs';
  * ```ts
  * const maybeOptional = Optional.some('value');
  *
- * const notOptional = { $$tag: 'ts-data-forge::Optional.some' };
+ * const notOptional = { $$tag: 'ts-data-forge::Optional.some' } as const;
  *
  * assert.isTrue(Optional.isOptional(maybeOptional));
  *
@@ -23,7 +23,7 @@ export const isOptional = (
   maybeOptional: unknown,
 ): maybeOptional is Optional<unknown> =>
   isRecord(maybeOptional) &&
-  Object.hasOwn(maybeOptional, '$$tag') &&
-  ((maybeOptional['$$tag'] === SomeTypeTagName &&
-    Object.hasOwn(maybeOptional, 'value')) ||
-    maybeOptional['$$tag'] === NoneTypeTagName);
+  hasKey(maybeOptional, '$$tag') &&
+  ((maybeOptional.$$tag === SomeTypeTagName &&
+    hasKey(maybeOptional, 'value')) ||
+    maybeOptional.$$tag === NoneTypeTagName);

package/src/functional/optional/impl/optional-some.mts

@@ -19,7 +19,8 @@ import { SomeTypeTagName } from './tag.mjs';
  * @param value The value to wrap in an {@link Some}.
  * @returns An {@link Some}<S> containing the value.
  */
-export const some = <const S,>(value: S): Some<S> => ({
-  $$tag: SomeTypeTagName,
-  value,
-});
+export const some = <const S,>(value: S): Some<S> =>
+  ({
+    $$tag: SomeTypeTagName,
+    value,
+  }) as const;

package/src/functional/optional/impl/optional-zip.mts

@@ -14,7 +14,7 @@ import { some } from './optional-some.mjs';
  * assert.isTrue(Optional.isSome(zipped));
  *
  * if (Optional.isSome(zipped)) {
- *   const expected: readonly [string, number] = ['left', 1];
+ *   const expected: readonly [string, number] = ['left', 1] as const;
  *
  *   assert.deepStrictEqual(zipped.value, expected);
  * }

package/src/functional/result/impl/result-err.mts

@@ -25,7 +25,8 @@ import { ErrTypeTagName } from './tag.mjs';
  * @param value The error value.
  * @returns A `Result.Err<E>` containing the value.
  */
-export const err = <const E,>(value: E): Err<E> => ({
-  $$tag: ErrTypeTagName,
-  value,
-});
+export const err = <const E,>(value: E): Err<E> =>
+  ({
+    $$tag: ErrTypeTagName,
+    value,
+  }) as const;

package/src/functional/result/impl/result-is-result.mts

@@ -11,7 +11,7 @@ import { ErrTypeTagName, OkTypeTagName } from './tag.mjs';
  *
  * const errValue = Result.err(new Error('failure'));
  *
- * const notResult = { $$tag: 'ts-data-forge::Result.ok' };
+ * const notResult = { $$tag: 'ts-data-forge::Result.ok' } as const;
  *
  * assert.isTrue(Result.isResult(okValue));
  *

package/src/functional/result/impl/result-ok.mts

@@ -25,7 +25,8 @@ import { OkTypeTagName } from './tag.mjs';
  * @param value The success value.
  * @returns A `Result.Ok<S>` containing the value.
  */
-export const ok = <const S,>(value: S): Ok<S> => ({
-  $$tag: OkTypeTagName,
-  value,
-});
+export const ok = <const S,>(value: S): Ok<S> =>
+  ({
+    $$tag: OkTypeTagName,
+    value,
+  }) as const;

package/src/functional/result.test.mts

@@ -821,7 +821,7 @@ describe('Result test', () => {
     });
 
     test('should return Ok with object when function succeeds', () => {
-      const obj = { name: 'test', value: 123 };
+      const obj = { name: 'test', value: 123 } as const;
 
       const result = Result.fromThrowable(() => obj);
 
@@ -901,7 +901,7 @@ describe('Result test', () => {
     });
 
     test('should work with array access', () => {
-      const arr = [1, 2, 3];
+      const arr = [1, 2, 3] as readonly number[];
 
       // This won't throw, but demonstrates the pattern
       const result = Result.fromThrowable(() => {

package/src/functional/ternary-result/impl/ternary-result-err.mts

@@ -13,7 +13,8 @@ import { ErrTypeTagName } from './tag.mjs';
  * assert.isTrue(TernaryResult.isErr(failure));
  * ```
  */
-export const err = <const E,>(value: E): TernaryErr<E> => ({
-  $$tag: ErrTypeTagName,
-  value,
-});
+export const err = <const E,>(value: E): TernaryErr<E> =>
+  ({
+    $$tag: ErrTypeTagName,
+    value,
+  }) as const;

package/src/functional/ternary-result/impl/ternary-result-is-ternary-result.mts

@@ -11,7 +11,7 @@ import { ErrTypeTagName, OkTypeTagName, WarnTypeTagName } from './tag.mjs';
  *
  * const warnValue = TernaryResult.warn('done', 'retry later');
  *
- * const notResult = { $$tag: 'ts-data-forge::Result.ok' };
+ * const notResult = { $$tag: 'ts-data-forge::Result.ok' } as const;
  *
  * assert.isTrue(TernaryResult.isTernaryResult(okValue));
  *

package/src/functional/ternary-result/impl/ternary-result-ok.mts

@@ -14,7 +14,8 @@ import { OkTypeTagName } from './tag.mjs';
  * });
  * ```
  */
-export const ok = <const S,>(value: S): TernaryOk<S> => ({
-  $$tag: OkTypeTagName,
-  value,
-});
+export const ok = <const S,>(value: S): TernaryOk<S> =>
+  ({
+    $$tag: OkTypeTagName,
+    value,
+  }) as const;

package/src/functional/ternary-result/impl/ternary-result-warn.mts

@@ -19,8 +19,9 @@ import { WarnTypeTagName } from './tag.mjs';
 export const warn = <const S, const W>(
   value: S,
   warning: W,
-): TernaryWarn<S, W> => ({
-  $$tag: WarnTypeTagName,
-  value,
-  warning,
-});
+): TernaryWarn<S, W> =>
+  ({
+    $$tag: WarnTypeTagName,
+    value,
+    warning,
+  }) as const;

package/src/guard/has-key.mts

@@ -17,7 +17,9 @@
  * @example
  *
  * ```ts
- * const maybeUser: Readonly<{ id?: number; name?: string }> = { id: 42 };
+ * const maybeUser: Readonly<{ id?: number; name?: string }> = {
+ *   id: 42,
+ * } as const;
  *
  * if (hasKey(maybeUser, 'id')) {
  *   // `maybeUser` is now known to have an `id` property.
@@ -43,7 +45,9 @@ export const hasKey = <
 >(
   obj: R,
   key: K,
-): obj is HasKeyReturnType<R, K> => Object.hasOwn(obj, key);
+): obj is HasKeyReturnType<R, K> =>
+  // eslint-disable-next-line ts-data-forge/prefer-is-record-and-has-key
+  Object.hasOwn(obj, key);
 
 /**
  * @internal

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

@@ -84,7 +84,7 @@ describe('isError from @sindresorhus/is', () => {
       name: 'Error',
       message: 'This is not a real error',
       stack: 'fake stack trace',
-    };
+    } as const;
 
     assert.isFalse(isErrorBySindreSorhus(errorLikeObject));
   });

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

@@ -84,7 +84,7 @@ describe(isNonEmptyString, () => {
       undefined,
       'third',
       false,
-    ];
+    ] as const;
 
     // @ts-expect-error Testing non-string types
     const nonEmptyStrings = mixed.filter(isNonEmptyString);

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

@@ -33,4 +33,5 @@
  */
 // eslint-disable-next-line @typescript-eslint/no-restricted-types
 export const isNonNullObject = (u: unknown): u is object =>
+  // eslint-disable-next-line ts-data-forge/prefer-is-non-null-object
   typeof u === 'object' && u !== null;

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

@@ -73,7 +73,7 @@ describe(isNonNullObject, () => {
   });
 
   test('should act as a type guard', () => {
-    const value: unknown = { test: true };
+    const value: unknown = { test: true } as const;
 
     if (isNonNullObject(value)) {
       expectType<typeof value, object>('=');
@@ -81,7 +81,8 @@ describe(isNonNullObject, () => {
   });
 
   test('should narrow nullable object types', () => {
-    const nullable: UnknownRecord | null = Math.random() > 0.5 ? {} : null;
+    const nullable: UnknownRecord | null =
+      Math.random() > 0.5 ? ({} as const) : null;
 
     if (isNonNullObject(nullable)) {
       expectType<typeof nullable, UnknownRecord>('=');
@@ -98,7 +99,7 @@ describe(isNonNullObject, () => {
       [],
       () => {},
       true,
-    ];
+    ] as const;
 
     const objects = mixed.filter(isNonNullObject);
 

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

@@ -102,7 +102,7 @@ describe(isPrimitive, () => {
       null,
       undefined,
       Symbol('test'),
-    ];
+    ] as const;
 
     const primitives = values.filter(isPrimitive);
 

package/src/guard/is-record.mts

@@ -25,7 +25,7 @@ import { isNonNullObject } from './is-non-null-object.mjs';
  * @example
  *
  * ```ts
- * const entries: readonly unknown[] = [{ id: 1 }, 'str', 0, null];
+ * const entries: readonly unknown[] = [{ id: 1 }, 'str', 0, null] as const;
  *
  * const records = entries.filter(isRecord);
  *
@@ -58,7 +58,7 @@ export const isRecord = (u: unknown): u is UnknownRecord => isNonNullObject(u);
  *
  * @example
  * ```ts
- * const obj: unknown = { foo: 1 };
+ * const obj: unknown = { foo: 1 } as const;
  *
  * if (isMutableRecord(obj)) {
  *   obj['bar'] = 2; // Safe: obj is now known to be a mutable record

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

@@ -4,7 +4,7 @@ import { isRecord } from './is-record.mjs';
 describe(isRecord, () => {
   describe('arrays are Records', () => {
     test('number[] is assignable to Record<number, unknown>', () => {
-      const arr: Record<number, unknown> = [1, 2, 3];
+      const arr: Record<number, unknown> = [1, 2, 3] as const;
 
       const unk: unknown = arr;
 
@@ -14,7 +14,7 @@ describe(isRecord, () => {
     });
 
     test('string[] is assignable to Record<number, unknown>', () => {
-      const arr: Record<number, unknown> = ['1', '2', '3'];
+      const arr: Record<number, unknown> = ['1', '2', '3'] as const;
 
       const unk: unknown = arr;
 

package/src/guard/is-type.mts

@@ -9,7 +9,7 @@
  * @example
  *
  * ```ts
- * const values: readonly (number | undefined)[] = [1, undefined, 2];
+ * const values: readonly (number | undefined)[] = [1, undefined, 2] as const;
  *
  * const undefinedValues = values.filter(isUndefined);
  *
@@ -34,7 +34,7 @@ export const isUndefined = (u: unknown): u is undefined => u === undefined;
  * @example
  *
  * ```ts
- * const values: readonly (number | undefined)[] = [1, undefined, 2];
+ * const values: readonly (number | undefined)[] = [1, undefined, 2] as const;
  *
  * const definedValues = values.filter(isNotUndefined);
  *
@@ -60,7 +60,7 @@ export const isNotUndefined = <T,>(u: T): u is RelaxedExclude<T, undefined> =>
  * @example
  *
  * ```ts
- * const flags: readonly unknown[] = [true, 'no', false];
+ * const flags: readonly unknown[] = [true, 'no', false] as const;
  *
  * const booleans = flags.filter(isBoolean);
  *
@@ -84,7 +84,7 @@ export const isBoolean = (u: unknown): u is boolean => typeof u === 'boolean';
  * @example
  *
  * ```ts
- * const flags: readonly unknown[] = [true, 'no', false];
+ * const flags: readonly unknown[] = [true, 'no', false] as const;
  *
  * const nonBooleans = flags.filter(isNotBoolean);
  *
@@ -111,7 +111,7 @@ export const isNotBoolean = <T,>(u: T): u is RelaxedExclude<T, boolean> =>
  * @example
  *
  * ```ts
- * const mixed: readonly unknown[] = [1, '2', 3];
+ * const mixed: readonly unknown[] = [1, '2', 3] as const;
  *
  * const numbers = mixed.filter(isNumber);
  *
@@ -135,7 +135,7 @@ export const isNumber = (u: unknown): u is number => typeof u === 'number';
  * @example
  *
  * ```ts
- * const mixed: readonly unknown[] = [1, '2', 3];
+ * const mixed: readonly unknown[] = [1, '2', 3] as const;
  *
  * const nonNumbers = mixed.filter(isNotNumber);
  *
@@ -161,7 +161,7 @@ export const isNotNumber = <T,>(u: T): u is RelaxedExclude<T, number> =>
  * @example
  *
  * ```ts
- * const values: readonly unknown[] = [1n, 2, 3n];
+ * const values: readonly unknown[] = [1n, 2, 3n] as const;
  *
  * const bigints = values.filter(isBigint);
  *
@@ -185,7 +185,7 @@ export const isBigint = (u: unknown): u is bigint => typeof u === 'bigint';
  * @example
  *
  * ```ts
- * const values: readonly unknown[] = [1n, 2, 3n];
+ * const values: readonly unknown[] = [1n, 2, 3n] as const;
  *
  * const nonBigints = values.filter(isNotBigint);
  *
@@ -212,7 +212,7 @@ export const isNotBigint = <T,>(u: T): u is RelaxedExclude<T, bigint> =>
  * @example
  *
  * ```ts
- * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'];
+ * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'] as const;
  *
  * const strings = values.filter(isString);
  *
@@ -236,7 +236,7 @@ export const isString = (u: unknown): u is string => typeof u === 'string';
  * @example
  *
  * ```ts
- * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'];
+ * const values: readonly unknown[] = ['Ada', 42, 'Lovelace'] as const;
  *
  * const nonStrings = values.filter(isNotString);
  *
@@ -266,7 +266,7 @@ export const isNotString = <T,>(u: T): u is RelaxedExclude<T, string> =>
  *
  * const shared = Symbol.for('shared');
  *
- * const tokens: readonly unknown[] = [id, 'shared', shared];
+ * const tokens: readonly unknown[] = [id, 'shared', shared] as const;
  *
  * const symbols = tokens.filter(isSymbol);
  *
@@ -292,7 +292,7 @@ export const isSymbol = (u: unknown): u is symbol => typeof u === 'symbol';
  * ```ts
  * const id = Symbol('id');
  *
- * const tokens: readonly unknown[] = [id, 'shared'];
+ * const tokens: readonly unknown[] = [id, 'shared'] as const;
  *
  * const nonSymbols = tokens.filter(isNotSymbol);
  *
@@ -343,7 +343,7 @@ export const isNull = (u: unknown): u is null => u === null;
  * @example
  *
  * ```ts
- * const values: readonly (number | null)[] = [null, 5];
+ * const values: readonly (number | null)[] = [null, 5] as const;
  *
  * const nonNullValues = values.filter(isNotNull);
  *
@@ -376,7 +376,7 @@ export const isNotNull = <T,>(u: T | null): u is T => u !== null;
  *   'Ada',
  *   null,
  *   undefined,
- * ];
+ * ] as const;
  *
  * const nullishValues = values.filter(isNullish);
  *
@@ -409,7 +409,7 @@ export const isNullish = (u: unknown): u is null | undefined => u == null;
  *   'Ada',
  *   null,
  *   undefined,
- * ];
+ * ] as const;
  *
  * const definedValues = values.filter(isNonNullish);
  *

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

@@ -572,7 +572,7 @@ describe(isNonNullish, () => {
       'world',
       undefined,
       'test',
-    ];
+    ] as const;
 
     const definedItems = items.filter(isNonNullish);
 
@@ -618,7 +618,7 @@ describe('type guard behavior in complex scenarios', () => {
       undefined,
       false,
       123,
-    ];
+    ] as const;
 
     const nonNullish = mixed.filter(isNonNullish);
 

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

@@ -44,4 +44,6 @@ export const keyIsIn = <
 >(
   key: K,
   obj: R,
-): key is K & keyof typeof obj => Object.hasOwn(obj, key);
+): key is K & keyof typeof obj =>
+  // eslint-disable-next-line ts-data-forge/prefer-is-record-and-has-key
+  Object.hasOwn(obj, key);

package/src/json/json.mts

@@ -93,7 +93,7 @@ export namespace Json {
    * @example
    *
    * ```ts
-   * const data = { name: 'Bob', age: 25, active: true };
+   * const data = { name: 'Bob', age: 25, active: true } as const;
    *
    * // Basic stringify
    * const basic = Json.stringify(data);
@@ -177,7 +177,7 @@ export namespace Json {
    *   email: 'charlie@example.com',
    *   password: 'secret123',
    *   role: 'admin',
-   * };
+   * } as const;
    *
    * // Select only safe properties to serialize
    * const safeJson = Json.stringifySelected(user, ['id', 'name', 'role']);
@@ -262,7 +262,7 @@ export namespace Json {
    *     alpha: 'a',
    *     beta: 'b',
    *   },
-   * };
+   * } as const;
    *
    * // Keys will be sorted alphabetically at all levels
    * const sorted = Json.stringifySortedKey(unorderedData);
@@ -354,6 +354,7 @@ const keysDeepImpl = (
       keysDeepImpl(o, mut_keys);
     }
 
+    // eslint-disable-next-line ts-data-forge/prefer-arr-is-array
     if (Array.isArray(o)) {
       for (const li of o) {
         if (isRecord(li)) {