ts-data-forge 14.7.1 → 14.9.0

package/src/array/impl/array-utils-reducing-value.mts

@@ -1,15 +1,15 @@
 import { isError } from '@sindresorhus/is';
-import { type Int, type NonEmptyTuple, type Uint } from 'ts-type-forge';
+import type { Int, NonEmptyTuple, Uint } from 'ts-type-forge';
 import { IMap } from '../../collections/index.mjs';
 import { Optional, Result } from '../../functional/index.mjs';
 import { isString, isUndefined } from '../../guard/index.mjs';
 import { asUint32, Num, Uint32 } from '../../number/index.mjs';
 import { unknownToString } from '../../others/index.mjs';
-import {
-  type ArrayIndex,
-  type MapSetKeyType,
-  type SizeType,
-  type Some,
+import type {
+  ArrayIndex,
+  MapSetKeyType,
+  SizeType,
+  Some,
 } from '../../types.mjs';
 import { isNonEmpty } from './array-utils-length-bounded-array-guard.mjs';
 
@@ -605,11 +605,9 @@ export function join(
     case 1: {
       const [arg] = args;
 
-      if (isString(arg) || isUndefined(arg)) {
-        return (array) => joinImpl(array, arg);
-      }
-
-      return joinImpl(arg, undefined);
+      return isString(arg) || isUndefined(arg)
+        ? (array) => joinImpl(array, arg)
+        : joinImpl(arg, undefined);
     }
 
     case 2: {

package/src/array/impl/array-utils-reducing-value.test.mts

@@ -1,8 +1,8 @@
-import { type Uint32 } from 'ts-type-forge';
+import type { Uint32 } from 'ts-type-forge';
 import { IMap } from '../../collections/index.mjs';
 import { expectType } from '../../expect-type.mjs';
 import { Optional, Result } from '../../functional/index.mjs';
-import { type Some } from '../../types.mjs';
+import type { Some } from '../../types.mjs';
 import {
   count,
   countBy,

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

@@ -1,10 +1,10 @@
 import { expectType } from '../../expect-type.mjs';
 import { Optional, pipe } from '../../functional/index.mjs';
 import { asUint32 } from '../../number/index.mjs';
-import {
-  type ArgArrayIndexWithNegative,
-  type ArrayIndex,
-  type SizeType,
+import type {
+  ArgArrayIndexWithNegative,
+  ArrayIndex,
+  SizeType,
 } from '../../types.mjs';
 
 /**

package/src/array/impl/array-utils-search.test.mts

@@ -1,6 +1,6 @@
 import { expectType } from '../../expect-type.mjs';
 import { Optional } from '../../functional/index.mjs';
-import { type SizeType } from '../../types.mjs';
+import type { SizeType } from '../../types.mjs';
 import {
   find,
   findIndex,
@@ -293,11 +293,13 @@ describe('Arr search operations', () => {
 
       expect(result).toBeGreaterThanOrEqual(0);
 
-      if (result !== -1) {
-        expectType<typeof result, SizeType.Arr>('=');
-
-        expect(result).toBe(1);
+      if (result === -1) {
+        return;
       }
+
+      expectType<typeof result, SizeType.Arr>('=');
+
+      expect(result).toBe(1);
     });
 
     test('should return -1 for non-existent element', () => {
@@ -317,11 +319,13 @@ describe('Arr search operations', () => {
 
       expect(result).toBeGreaterThanOrEqual(0);
 
-      if (result !== -1) {
-        expectType<typeof result, SizeType.Arr>('=');
-
-        expect(result).toBe(3);
+      if (result === -1) {
+        return;
       }
+
+      expectType<typeof result, SizeType.Arr>('=');
+
+      expect(result).toBe(3);
     });
 
     test('should return -1 when element not found from index', () => {
@@ -365,11 +369,13 @@ describe('Arr search operations', () => {
 
       expect(result).toBeGreaterThanOrEqual(0);
 
-      if (result !== -1) {
-        expectType<typeof result, SizeType.Arr>('=');
-
-        expect(result).toBe(3);
+      if (result === -1) {
+        return;
       }
+
+      expectType<typeof result, SizeType.Arr>('=');
+
+      expect(result).toBe(3);
     });
 
     test('should return -1 for non-existent element', () => {
@@ -389,11 +395,13 @@ describe('Arr search operations', () => {
 
       expect(result).toBeGreaterThanOrEqual(0);
 
-      if (result !== -1) {
-        expectType<typeof result, SizeType.Arr>('=');
-
-        expect(result).toBe(1);
+      if (result === -1) {
+        return;
       }
+
+      expectType<typeof result, SizeType.Arr>('=');
+
+      expect(result).toBe(1);
     });
 
     test('should return -1 when element not found before index', () => {

package/src/array/impl/array-utils-set-op.mts

@@ -1,4 +1,4 @@
-import { type Primitive } from 'ts-type-forge';
+import type { Primitive } from 'ts-type-forge';
 
 /**
  * Checks if two arrays are equal by comparing their elements.

package/src/array/impl/array-utils-shape-invariants.test.mts

@@ -1,11 +1,11 @@
-import {
-  type BoundedLengthArray,
-  type FixedLengthArray,
-  type FixedLengthTuple,
-  type MaxLengthArray,
-  type MaxLengthOf,
-  type MinLengthArray,
-  type MinLengthOf,
+import type {
+  BoundedLengthArray,
+  FixedLengthArray,
+  FixedLengthTuple,
+  MaxLengthArray,
+  MaxLengthOf,
+  MinLengthArray,
+  MinLengthOf,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import {

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

@@ -1,7 +1,7 @@
-import {
-  type IntersectBrand,
-  type NonEmptyTuple,
-  type PositiveNumber,
+import type {
+  IntersectBrand,
+  NonEmptyTuple,
+  PositiveNumber,
 } from 'ts-type-forge';
 /**
  * Returns the size (length) of an array.
@@ -22,7 +22,7 @@ import {
  * assert.isTrue(sizeOfLetters === 0);
  * ```
  */
-import { type SizeType } from '../../types.mjs';
+import type { SizeType } from '../../types.mjs';
 
 export const size = <const Ar extends readonly unknown[]>(
   array: Ar,

package/src/array/impl/array-utils-slice-clamped.mts

@@ -1,6 +1,6 @@
-import { type FixedLengthTuple } from 'ts-type-forge';
+import type { FixedLengthTuple } from 'ts-type-forge';
 import { Num } from '../../number/index.mjs';
-import { type ArgArrayIndexWithNegative, type SizeType } from '../../types.mjs';
+import type { ArgArrayIndexWithNegative, SizeType } from '../../types.mjs';
 
 /**
  * Slices an array with automatically clamped start and end indices.

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

@@ -1,13 +1,13 @@
-import {
-  type ConstrainedList,
-  type HasLengthConstraint,
-  type List,
-  type NonEmptyArray,
-  type NonEmptyTuple,
-  type StructuralPrefixLength,
+import type {
+  ConstrainedList,
+  HasLengthConstraint,
+  List,
+  NonEmptyArray,
+  NonEmptyTuple,
+  StructuralPrefixLength,
 } from 'ts-type-forge';
 import { Uint32 } from '../../number/index.mjs';
-import { type SizeType } from '../../types.mjs';
+import type { SizeType } from '../../types.mjs';
 import { isEmpty } from './array-utils-length-bounded-array-guard.mjs';
 import { size } from './array-utils-size.mjs';
 import { sliceClamped } from './array-utils-slice-clamped.mjs';

package/src/array/impl/array-utils-slicing.test.mts

@@ -1,4 +1,4 @@
-import { type MinLengthArray } from 'ts-type-forge';
+import type { MinLengthArray } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { asMinLengthArray } from './array-utils-length-bounded-array-cast.mjs';
 import {

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

@@ -1,29 +1,25 @@
-import {
-  type BoundedLengthArray,
-  type ChangeArrayElement,
-  type ConstrainedList,
-  type FixedLengthTuple,
-  type HasLengthConstraint,
-  type IsFixedLengthList,
-  type NonEmptyArray,
-  type NonEmptyTuple,
-  type PositiveInt,
-  type PositiveUint32,
-  type Primitive,
-  type SafeUintWithSmallInt,
-  type SupportedLength,
-  type UnknownBrand,
-  type WithSmallInt,
+import type {
+  BoundedLengthArray,
+  ChangeArrayElement,
+  ConstrainedList,
+  FixedLengthTuple,
+  HasLengthConstraint,
+  IsFixedLengthList,
+  NonEmptyArray,
+  NonEmptyTuple,
+  PositiveInt,
+  PositiveUint32,
+  Primitive,
+  SafeUintWithSmallInt,
+  SupportedLength,
+  UnknownBrand,
+  WithSmallInt,
 } from 'ts-type-forge';
 import { IMap } from '../../collections/index.mjs';
 import { expectType } from '../../expect-type.mjs';
 import { asPositiveUint32, asUint32, Uint32 } from '../../number/index.mjs';
 import { castMutable, tp } from '../../others/index.mjs';
-import {
-  type ArrayIndex,
-  type MapSetKeyType,
-  type SizeType,
-} from '../../types.mjs';
+import type { ArrayIndex, MapSetKeyType, SizeType } from '../../types.mjs';
 import { newArray, seq } from './array-utils-creation.mjs';
 import { isNonEmpty } from './array-utils-length-bounded-array-guard.mjs';
 import { size } from './array-utils-size.mjs';
@@ -548,7 +544,9 @@ export const uniqBy = <
   return array.filter((val) => {
     const mappedValue = mapFn(val);
 
-    if (mut_mappedValues.has(mappedValue)) return false;
+    if (mut_mappedValues.has(mappedValue)) {
+      return false;
+    }
 
     mut_mappedValues.add(mappedValue);
 
@@ -972,12 +970,16 @@ export const zip = <
 export const cartesianProduct = <T,>(
   arrays: readonly (readonly T[])[],
 ): readonly (readonly T[])[] => {
-  if (!isNonEmpty(arrays)) return [[]];
+  if (!isNonEmpty(arrays)) {
+    return [[]];
+  }
 
   const [first, ...rest] = arrays;
 
   // If first array is empty, the result is empty
-  if (!isNonEmpty(first)) return [];
+  if (!isNonEmpty(first)) {
+    return [];
+  }
 
   const restProduct = cartesianProduct(rest);
 

package/src/array/impl/array-utils-transformation.test.mts

@@ -1,9 +1,9 @@
-import {
-  type BoundedLengthArray,
-  type FixedLengthTuple,
-  type MinLengthArray,
-  type NonEmptyArray,
-  type NonEmptyTuple,
+import type {
+  BoundedLengthArray,
+  FixedLengthTuple,
+  MinLengthArray,
+  NonEmptyArray,
+  NonEmptyTuple,
 } from 'ts-type-forge';
 import { IMap } from '../../collections/index.mjs';
 import { expectType } from '../../expect-type.mjs';
@@ -963,11 +963,13 @@ describe('Arr transformations', () => {
         expect(fruits.value[1]?.name).toBe('banana');
       }
 
-      if (Optional.isSome(vegetables)) {
-        expect(vegetables.value).toHaveLength(1);
-
-        expect(vegetables.value[0]?.name).toBe('carrot');
+      if (!Optional.isSome(vegetables)) {
+        return;
       }
+
+      expect(vegetables.value).toHaveLength(1);
+
+      expect(vegetables.value[0]?.name).toBe('carrot');
     });
 
     test('should work with numeric keys', () => {

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

@@ -1,12 +1,12 @@
-import {
-  type BoolOr,
-  type ChangeArrayElement,
-  type IsAny,
-  type IsUnknown,
-  type UnknownBrand,
+import type {
+  BoolOr,
+  ChangeArrayElement,
+  IsAny,
+  IsUnknown,
+  UnknownBrand,
 } from 'ts-type-forge';
 import { asUint32, Num } from '../../number/index.mjs';
-import { type ArrayIndex, type SizeType } from '../../types.mjs';
+import type { ArrayIndex, SizeType } from '../../types.mjs';
 
 /**
  * Type guard that checks if a value is an array.

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

@@ -1,9 +1,9 @@
-import {
-  type BoundedLengthArray,
-  type FixedLengthArray,
-  type FixedLengthTuple,
-  type MinLengthArray,
-  type ReadonlyRecord,
+import type {
+  BoundedLengthArray,
+  FixedLengthArray,
+  FixedLengthTuple,
+  MinLengthArray,
+  ReadonlyRecord,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import {
@@ -66,22 +66,26 @@ describe('Arr validations', () => {
     test('should work with readonly arrays', () => {
       const readonlyArray: readonly number[] = [1, 2, 3] as const;
 
-      if (isArray(readonlyArray)) {
-        expectType<typeof readonlyArray, readonly number[]>('=');
-
-        expect(readonlyArray).toHaveLength(3);
+      if (!isArray(readonlyArray)) {
+        return;
       }
+
+      expectType<typeof readonlyArray, readonly number[]>('=');
+
+      expect(readonlyArray).toHaveLength(3);
     });
 
     test('should work with mutable arrays', () => {
       // transformer-ignore-next-line convert-to-readonly, append-as-const
       const mutableArray: number[] = [1, 2, 3];
 
-      if (isArray(mutableArray)) {
-        expectType<typeof mutableArray, number[]>('=');
-
-        expect(mutableArray).toHaveLength(3);
+      if (!isArray(mutableArray)) {
+        return;
       }
+
+      expectType<typeof mutableArray, number[]>('=');
+
+      expect(mutableArray).toHaveLength(3);
     });
 
     test('should exclude impossible array types from unions', () => {
@@ -170,11 +174,13 @@ describe('Arr validations', () => {
     test('should work as type guard (additional)', () => {
       const value: unknown = [1, 2, 3] as const;
 
-      if (isArray(value)) {
-        expectType<typeof value, readonly unknown[]>('=');
-
-        expect(value).toHaveLength(3);
+      if (!isArray(value)) {
+        return;
       }
+
+      expectType<typeof value, readonly unknown[]>('=');
+
+      expect(value).toHaveLength(3);
     });
 
     test('should handle array-like objects', () => {
@@ -238,14 +244,9 @@ describe('Arr validations', () => {
       });
 
       test('should work with generic function', () => {
-        const processGeneric = <T,>(value: T | readonly number[]): number => {
-          if (isArray(value)) {
-            // Type is narrowed to array type within this block
-            return value.length;
-          }
-
-          return 0;
-        };
+        const processGeneric = <T,>(value: T | readonly number[]): number =>
+          // Type is narrowed to array type within the first branch
+          isArray(value) ? value.length : 0;
 
         expect(processGeneric([1, 2, 3])).toBe(3);
 
@@ -264,15 +265,12 @@ describe('Arr validations', () => {
       test('should work with conditional types', () => {
         type ArrayOrValue<T> = T extends readonly unknown[] ? T : readonly T[];
 
-        const makeArray = <T,>(value: T): ArrayOrValue<T> => {
-          if (isArray(value)) {
-            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-            return value as ArrayOrValue<T>;
-          }
-
-          // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-          return [value] as ArrayOrValue<T>;
-        };
+        const makeArray = <T,>(value: T): ArrayOrValue<T> =>
+          isArray(value)
+            ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+              (value as ArrayOrValue<T>)
+            : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+              ([value] as ArrayOrValue<T>);
 
         assert.deepStrictEqual(makeArray([1, 2, 3]), [1, 2, 3]);
 
@@ -284,11 +282,13 @@ describe('Arr validations', () => {
 
         const tagged = Object.assign([1, 2, 3], { tag: 'test' }) as TaggedArray;
 
-        if (isArray(tagged)) {
-          expectType<typeof tagged, TaggedArray>('=');
-
-          expect(tagged.tag).toBe('test');
+        if (!isArray(tagged)) {
+          return;
         }
+
+        expectType<typeof tagged, TaggedArray>('=');
+
+        expect(tagged.tag).toBe('test');
       });
 
       test('should work with branded types', () => {

package/src/array/impl/array.test.mts

@@ -26,7 +26,7 @@ describe('Array.some', () => {
   });
 
   test('case 2', () => {
-    assert.isFalse(xs.some((x) => x <= 1 && 3 <= x));
+    assert.isFalse(xs.some((x) => 3 <= x && x <= 1));
   });
 });
 

package/src/collections/imap-mapped.mts

@@ -1,9 +1,9 @@
 /* eslint-disable unicorn/prefer-iterator-to-array-at-end */
-import { type WidenLiteral } from 'ts-type-forge';
+import type { WidenLiteral } from 'ts-type-forge';
 import { Optional, pipe } from '../functional/index.mjs';
 import { asUint32 } from '../number/index.mjs';
 import { tp, unknownToString } from '../others/index.mjs';
-import { type MapSetKeyType, type SizeType } from '../types.mjs';
+import type { MapSetKeyType, SizeType } from '../types.mjs';
 
 /**
  * Interface for an immutable map with custom key mapping and lookup operations.
@@ -1014,10 +1014,10 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
 
   /** @inheritdoc */
   get(key: K | (WidenLiteral<K> & {})): Optional<V> {
-    if (!this.has(key)) return Optional.none;
-
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, total-functions/no-unsafe-type-assertion
-    return Optional.some(this.#map.get(this.#toKey(key as K))!);
+    return this.has(key)
+      ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, total-functions/no-unsafe-type-assertion
+        Optional.some(this.#map.get(this.#toKey(key as K))!)
+      : Optional.none;
   }
 
   /** @inheritdoc */
@@ -1031,7 +1031,9 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
   /** @inheritdoc */
   every(predicate: (value: V, key: K) => boolean): boolean {
     for (const [k, v] of this.entries()) {
-      if (!predicate(v, k)) return false;
+      if (!predicate(v, k)) {
+        return false;
+      }
     }
 
     return true;
@@ -1040,7 +1042,9 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
   /** @inheritdoc */
   some(predicate: (value: V, key: K) => boolean): boolean {
     for (const [k, v] of this.entries()) {
-      if (predicate(v, k)) return true;
+      if (predicate(v, k)) {
+        return true;
+      }
     }
 
     return false;
@@ -1073,7 +1077,9 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
   set(key: K, value: V): IMapMapped<K, V, KM> {
     const curr = this.get(key);
 
-    if (Optional.isSome(curr) && value === curr.value) return this;
+    if (Optional.isSome(curr) && value === curr.value) {
+      return this;
+    }
 
     const keyMapped = this.#toKey(key);
 

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

@@ -1,4 +1,4 @@
-import { type DeepReadonly } from 'ts-type-forge';
+import type { DeepReadonly } from 'ts-type-forge';
 import { Optional, Result } from '../functional/index.mjs';
 import { Num } from '../number/index.mjs';
 import { IMapMapped } from './imap-mapped.mjs';

package/src/collections/imap.mts

@@ -1,9 +1,9 @@
 /* eslint-disable unicorn/prefer-iterator-to-array-at-end */
-import { type WidenLiteral } from 'ts-type-forge';
+import type { WidenLiteral } from 'ts-type-forge';
 import { Optional, pipe } from '../functional/index.mjs';
 import { asUint32 } from '../number/index.mjs';
 import { tp, unknownToString } from '../others/index.mjs';
-import { type MapSetKeyType, type SizeType } from '../types.mjs';
+import type { MapSetKeyType, SizeType } from '../types.mjs';
 
 /**
  * Interface for an immutable map with lookup operations and functional
@@ -759,10 +759,10 @@ class IMapClass<K extends MapSetKeyType, V>
 
   /** @inheritdoc */
   get(key: K | (WidenLiteral<K> & {})): Optional<V> {
-    if (!this.has(key)) return Optional.none;
-
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-non-null-assertion
-    return Optional.some(this.#map.get(key as K)!);
+    return this.has(key)
+      ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-non-null-assertion
+        Optional.some(this.#map.get(key as K)!)
+      : Optional.none;
   }
 
   /** @inheritdoc */
@@ -776,7 +776,9 @@ class IMapClass<K extends MapSetKeyType, V>
   /** @inheritdoc */
   every(predicate: (value: V, key: K) => boolean): boolean {
     for (const [k, v] of this.entries()) {
-      if (!predicate(v, k)) return false;
+      if (!predicate(v, k)) {
+        return false;
+      }
     }
 
     return true;
@@ -785,7 +787,9 @@ class IMapClass<K extends MapSetKeyType, V>
   /** @inheritdoc */
   some(predicate: (value: V, key: K) => boolean): boolean {
     for (const [k, v] of this.entries()) {
-      if (predicate(v, k)) return true;
+      if (predicate(v, k)) {
+        return true;
+      }
     }
 
     return false;
@@ -812,7 +816,9 @@ class IMapClass<K extends MapSetKeyType, V>
   set(key: K, value: V): IMap<K, V> {
     const curr = this.get(key);
 
-    if (Optional.isSome(curr) && value === curr.value) return this; // has no changes
+    if (Optional.isSome(curr) && value === curr.value) {
+      return this; // has no changes
+    }
 
     if (!this.has(key)) {
       return IMap.create([...this.#map, tp(key, value)]);

package/src/collections/imap.test.mts

@@ -656,12 +656,14 @@ describe('IMap.every', () => {
       ['b', 'world'],
     ]);
 
-    if (map.every((value): value is string => typeof value === 'string')) {
-      // Type should be narrowed to IMap<string, string>
-      const firstValue = Optional.unwrap(map.get('a'));
-
-      assert.isTrue(isString(firstValue));
+    if (!map.every((value): value is string => typeof value === 'string')) {
+      return;
     }
+
+    // Type should be narrowed to IMap<string, string>
+    const firstValue = Optional.unwrap(map.get('a'));
+
+    assert.isTrue(isString(firstValue));
   });
 });