ts-data-forge 14.7.0 → 14.8.0

package/src/number/enum/uint8.mts

@@ -1,7 +1,7 @@
-import {
-  type StrictExclude,
-  type Uint8 as TtfImported_Uint8,
-  type Uint16,
+import type {
+  StrictExclude,
+  Uint8 as TtfImported_Uint8,
+  Uint16,
 } from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
 import { TsDataForgeInternals } from '../refined-number-utils.mjs';

package/src/number/num-arithmetic-types.mts

@@ -1,30 +1,30 @@
-import {
-  type BoolAnd,
-  type BoolOr,
-  type FiniteNumber,
-  type Int,
-  type NegativeFiniteNumber,
-  type NegativeInt,
-  type NegativeNumber,
-  type NegativeSafeInt,
-  type NonNegativeFiniteNumber,
-  type NonNegativeInt,
-  type NonNegativeNumber,
-  type NonPositiveFiniteNumber,
-  type NonPositiveInt,
-  type NonPositiveNumber,
-  type NonPositiveSafeInt,
-  type NonZeroFiniteNumber,
-  type NonZeroInt,
-  type NonZeroNumber,
-  type NonZeroSafeInt,
-  type PositiveFiniteNumber,
-  type PositiveInt,
-  type PositiveNumber,
-  type PositiveSafeInt,
-  type SafeInt,
-  type SafeUint,
-  type Uint,
+import type {
+  BoolAnd,
+  BoolOr,
+  FiniteNumber,
+  Int,
+  NegativeFiniteNumber,
+  NegativeInt,
+  NegativeNumber,
+  NegativeSafeInt,
+  NonNegativeFiniteNumber,
+  NonNegativeInt,
+  NonNegativeNumber,
+  NonPositiveFiniteNumber,
+  NonPositiveInt,
+  NonPositiveNumber,
+  NonPositiveSafeInt,
+  NonZeroFiniteNumber,
+  NonZeroInt,
+  NonZeroNumber,
+  NonZeroSafeInt,
+  PositiveFiniteNumber,
+  PositiveInt,
+  PositiveNumber,
+  PositiveSafeInt,
+  SafeInt,
+  SafeUint,
+  Uint,
 } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 

package/src/number/num-arithmetic-types.test.mts

@@ -1,26 +1,26 @@
-import {
-  type FiniteNumber,
-  type Int,
-  type NegativeFiniteNumber,
-  type NegativeInt,
-  type NonNegativeFiniteNumber,
-  type NonPositiveInt,
-  type NonZeroInt,
-  type PositiveFiniteNumber,
-  type PositiveInt,
-  type PositiveSafeInt,
-  type SafeUint,
-  type Uint,
+import type {
+  FiniteNumber,
+  Int,
+  NegativeFiniteNumber,
+  NegativeInt,
+  NonNegativeFiniteNumber,
+  NonPositiveInt,
+  NonZeroInt,
+  PositiveFiniteNumber,
+  PositiveInt,
+  PositiveSafeInt,
+  SafeUint,
+  Uint,
 } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
-import {
-  type AddResult,
-  type DivIntResult,
-  type DivResult,
-  type LevelOf,
-  type MulResult,
-  type SignOf,
-  type SubResult,
+import type {
+  AddResult,
+  DivIntResult,
+  DivResult,
+  LevelOf,
+  MulResult,
+  SignOf,
+  SubResult,
 } from './num-arithmetic-types.mjs';
 
 describe('NumericArithmetic type-level', () => {

package/src/number/num-arithmetic.test.mts

@@ -1,9 +1,9 @@
-import {
-  type Int,
-  type NegativeInt,
-  type PositiveFiniteNumber,
-  type PositiveInt,
-  type Uint,
+import type {
+  Int,
+  NegativeInt,
+  PositiveFiniteNumber,
+  PositiveInt,
+  Uint,
 } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import {

package/src/number/num.mts

@@ -1,31 +1,31 @@
 import { SafeNumber } from 'ts-std-forge';
-import {
-  type Decrement,
-  type FiniteNumber,
-  type Increment,
-  type Index,
-  type Int,
-  type Min,
-  type NaNType,
-  type NegativeIndex,
-  type NonNegativeNumber,
-  type NonZeroNumber,
-  type PositiveNumber,
-  type PositiveSafeIntWithSmallInt,
-  type RelaxedExclude,
-  type SmallInt,
-  type SmallUint,
-  type UnknownBrand,
+import type {
+  Decrement,
+  FiniteNumber,
+  Increment,
+  Index,
+  Int,
+  Min,
+  NaNType,
+  NegativeIndex,
+  NonNegativeNumber,
+  NonZeroNumber,
+  PositiveNumber,
+  PositiveSafeIntWithSmallInt,
+  RelaxedExclude,
+  SmallInt,
+  SmallUint,
+  UnknownBrand,
 } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { Result } from '../functional/index.mjs';
-import { type SmallPositiveInt } from '../types.mjs';
-import {
-  type AddResult,
-  type DivIntResult,
-  type DivResult,
-  type MulResult,
-  type SubResult,
+import type { SmallPositiveInt } from '../types.mjs';
+import type {
+  AddResult,
+  DivIntResult,
+  DivResult,
+  MulResult,
+  SubResult,
 } from './num-arithmetic-types.mjs';
 
 /**

package/src/number/num.test.mts

@@ -1,4 +1,4 @@
-import { type FixedLengthTuple, type NonZeroNumber } from 'ts-type-forge';
+import type { FixedLengthTuple, NonZeroNumber } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { pipe, Result } from '../functional/index.mjs';
 import { asNonZeroFiniteNumber } from './branded-types/index.mjs';

package/src/number/refined-number-utils.mts

@@ -1,19 +1,19 @@
-import {
-  type Brand,
-  type ChangeBaseBrand,
-  type GetBrandValuePart,
-  type Int,
-  type IntersectBrand,
-  type NonNegativeNumber,
-  type NonZeroNumber,
-  type PositiveNumber,
-  type RelaxedExclude,
-  type StrictPick,
-  type TypeEq,
-  type UnknownBrand,
-  type UnwrapBrandFalseKeys,
-  type UnwrapBrandTrueKeys,
-  type WithSmallInt,
+import type {
+  Brand,
+  ChangeBaseBrand,
+  GetBrandValuePart,
+  Int,
+  IntersectBrand,
+  NonNegativeNumber,
+  NonZeroNumber,
+  PositiveNumber,
+  RelaxedExclude,
+  StrictPick,
+  TypeEq,
+  UnknownBrand,
+  UnwrapBrandFalseKeys,
+  UnwrapBrandTrueKeys,
+  WithSmallInt,
 } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { pipe } from '../functional/index.mjs';
@@ -392,7 +392,7 @@ export namespace TsDataForgeInternals {
         (integerOrSafeInteger === 'Integer'
           ? Number.isInteger(a)
           : Number.isSafeInteger(a)) &&
-        (nonZero === true ? a !== 0 : true) &&
+        (nonZero !== true || a !== 0) &&
         (isFnOrUndefined(MIN_VALUE, MAX_VALUE)?.(a) ?? true);
 
       const castType = castTypeImpl<ElementType>(is, typeNameInMessage);
@@ -469,7 +469,9 @@ export namespace TsDataForgeInternals {
         while (true) {
           const r = randomImpl(min, max);
 
-          if (Num.isNonZero(r)) return clampOrCastFn(r);
+          if (Num.isNonZero(r)) {
+            return clampOrCastFn(r);
+          }
         }
       };
 
@@ -576,7 +578,7 @@ export namespace TsDataForgeInternals {
      *
      * assert.isTrue(coerced >= Number.MIN_VALUE);
      *
-     * assert.isTrue(boundedRandom >= 10 && boundedRandom <= 20);
+     * assert.isTrue(10 <= boundedRandom && boundedRandom <= 20);
      *
      * assert.isTrue(nonZeroRandom > 0);
      * ```
@@ -611,7 +613,7 @@ export namespace TsDataForgeInternals {
     }>): OperatorsForFloat<ElementType, MIN_VALUE, MAX_VALUE> => {
       const is = (a: number): a is ElementType =>
         Number.isFinite(a) &&
-        (nonZero === true ? a !== 0 : true) &&
+        (nonZero !== true || a !== 0) &&
         (isFnOrUndefined(MIN_VALUE, MAX_VALUE)?.(a) ?? true);
 
       const castType = castTypeImpl<ElementType>(is, typeNameInMessage);
@@ -667,7 +669,9 @@ export namespace TsDataForgeInternals {
         while (true) {
           const r = random(min, max);
 
-          if (isNonZero(r)) return r;
+          if (isNonZero(r)) {
+            return r;
+          }
         }
       };
 

package/src/object/object.mts

@@ -1,20 +1,20 @@
-import {
-  type ArrayElement,
-  type Decrement,
-  type DeepOmit,
-  type DeepPick,
-  type IsFixedLengthList,
-  type IsUnion,
-  type List,
-  type ReadonlyRecord,
-  type RelaxedExclude,
-  type RelaxedOmit,
-  type RelaxedPick,
-  type StrictOmit,
-  type StrictPick,
-  type ToString,
-  type TypeEq,
-  type UnknownRecord,
+import type {
+  ArrayElement,
+  Decrement,
+  DeepOmit,
+  DeepPick,
+  IsFixedLengthList,
+  IsUnion,
+  List,
+  ReadonlyRecord,
+  RelaxedExclude,
+  RelaxedOmit,
+  RelaxedPick,
+  StrictOmit,
+  StrictPick,
+  ToString,
+  TypeEq,
+  UnknownRecord,
 } from 'ts-type-forge';
 import { Arr } from '../array/index.mjs';
 import { Optional } from '../functional/index.mjs';
@@ -53,13 +53,10 @@ export namespace Obj {
    *
    * const obj5 = { value: 1.00001 } as const;
    *
-   * const closeEnough = (a: unknown, b: unknown): boolean => {
-   *   if (typeof a === 'number' && typeof b === 'number') {
-   *     return Math.abs(a - b) < 0.001;
-   *   }
-   *
-   *   return Object.is(a, b);
-   * };
+   * const closeEnough = (a: unknown, b: unknown): boolean =>
+   *   typeof a === 'number' && typeof b === 'number'
+   *     ? Math.abs(a - b) < 0.001
+   *     : Object.is(a, b);
    *
    * assert.isTrue(Obj.shallowEq(obj4, obj5, closeEnough));
    * ```
@@ -80,9 +77,10 @@ export namespace Obj {
 
     const bEntries = Object.entries(b);
 
-    if (aEntries.length !== bEntries.length) return false;
-
-    return aEntries.every(([k, v]) => eq(b[k], v));
+    return (
+      aEntries.length === bEntries.length &&
+      aEntries.every(([k, v]) => eq(b[k], v))
+    );
   };
 
   /**
@@ -721,19 +719,27 @@ const deepPickImpl = (
   record: UnknownRecord,
   path: readonly (string | number)[],
 ): UnknownRecord => {
-  if (!Arr.isNonEmpty(path)) return record;
+  if (!Arr.isNonEmpty(path)) {
+    return record;
+  }
 
   const head = path[0];
 
-  if (!hasKey(record, head)) return {};
+  if (!hasKey(record, head)) {
+    return {};
+  }
 
   const value = record[head];
 
   const tail = path.slice(1);
 
-  if (!Arr.isNonEmpty(tail)) return { [head]: value };
+  if (!Arr.isNonEmpty(tail)) {
+    return { [head]: value };
+  }
 
-  if (!isRecord(value)) return { [head]: {} };
+  if (!isRecord(value)) {
+    return { [head]: {} };
+  }
 
   return {
     [head]: deepPickImpl(value, tail),
@@ -744,11 +750,15 @@ const deepOmitImpl = (
   record: UnknownRecord,
   path: readonly (string | number)[],
 ): UnknownRecord => {
-  if (!Arr.isNonEmpty(path)) return record;
+  if (!Arr.isNonEmpty(path)) {
+    return record;
+  }
 
   const head = path[0];
 
-  if (!hasKey(record, head)) return record;
+  if (!hasKey(record, head)) {
+    return record;
+  }
 
   const tail = path.slice(1);
 
@@ -760,7 +770,9 @@ const deepOmitImpl = (
 
   const value = record[head];
 
-  if (!isRecord(value)) return record;
+  if (!isRecord(value)) {
+    return record;
+  }
 
   return {
     ...record,

package/src/object/object.test.mts

@@ -1,8 +1,8 @@
-import {
-  type DeepReadonly,
-  type FixedLengthTuple,
-  type ReadonlyRecord,
-  type UnknownRecord,
+import type {
+  DeepReadonly,
+  FixedLengthTuple,
+  ReadonlyRecord,
+  UnknownRecord,
 } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { Optional, pipe } from '../functional/index.mjs';

package/src/others/cast-mutable.mts

@@ -1,4 +1,4 @@
-import { type DeepMutable, type Mutable } from 'ts-type-forge';
+import type { DeepMutable, Mutable } from 'ts-type-forge';
 
 /**
  * Casts a readonly type `T` to its `Mutable<T>` equivalent.

package/src/others/cast-readonly.mts

@@ -1,4 +1,4 @@
-import { type DeepReadonly } from 'ts-type-forge';
+import type { DeepReadonly } from 'ts-type-forge';
 
 /**
  * Casts a mutable type `T` to its `Readonly<T>` equivalent.

package/src/others/debounce-function.mts

@@ -11,11 +11,7 @@ export const debounce = <Args extends readonly unknown[]>(
   func: (...args: Args) => void,
   waitMilliseconds: number,
 ): ((...args: Args) => void) => {
-  // Not `ReturnType<typeof setTimeout>`: with both the DOM and Node
-  // declarations in scope that resolves to `unknown`, which `clearTimeout`
-  // will not take. Naming what `clearTimeout` accepts says the same thing and
-  // stays true in either environment.
-  let mut_timeoutId: Parameters<typeof clearTimeout>[0];
+  let mut_timeoutId: ReturnType<typeof setTimeout> | undefined = undefined;
 
   return (...args: Args): void => {
     clearTimeout(mut_timeoutId);

package/src/others/fast-deep-equal.test.mts

@@ -4,7 +4,7 @@
 /* eslint-disable no-restricted-globals */
 /* eslint-disable functional/no-class-inheritance */
 import * as React from 'react';
-import { type ReadonlyRecord } from 'ts-type-forge';
+import type { ReadonlyRecord } from 'ts-type-forge';
 import { fastDeepEqual } from './fast-deep-equal.mjs';
 
 const fastDeepEqualUntyped = (a: any, b: any): boolean => fastDeepEqual(a, b);

package/src/others/map-nullable.test.mts

@@ -1,4 +1,4 @@
-import { type DeepReadonly } from 'ts-type-forge';
+import type { DeepReadonly } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { pipe, Result } from '../functional/index.mjs';
 import { Num } from '../number/index.mjs';

package/src/others/memoize-function.mts

@@ -1,4 +1,4 @@
-import { type Primitive } from 'ts-type-forge';
+import type { Primitive } from 'ts-type-forge';
 
 /**
  * Creates a memoized version of a function that caches results based on input

package/src/string/str.mts

@@ -1,10 +1,10 @@
-import {
-  type BoundedLengthString,
-  type FixedLengthString,
-  type MaxLengthString,
-  type MinLengthString,
-  type NonEmptyString,
-  type SupportedLength,
+import type {
+  BoundedLengthString,
+  FixedLengthString,
+  MaxLengthString,
+  MinLengthString,
+  NonEmptyString,
+  SupportedLength,
 } from 'ts-type-forge';
 
 /**
@@ -37,11 +37,13 @@ export namespace Str {
    *
    * assert.isFalse(Str.isMinLengthString(12, 'short'));
    *
-   * if (Str.isMinLengthString(12, input)) {
-   *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)
-   *
-   *   assert.isTrue(nonEmpty.length >= 12);
+   * if (!Str.isMinLengthString(12, input)) {
+   *   return;
    * }
+   *
+   * const nonEmpty: NonEmptyString = input; // OK (12 >= 1)
+   *
+   * assert.isTrue(nonEmpty.length >= 12);
    * ```
    *
    * @template MinLength - The minimum number of characters (inclusive).
@@ -79,11 +81,13 @@ export namespace Str {
    *
    * assert.isFalse(Str.isMaxLengthString(3, input));
    *
-   * if (Str.isMaxLengthString(32, input)) {
-   *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)
-   *
-   *   assert.isTrue(relaxed.length <= 32);
+   * if (!Str.isMaxLengthString(32, input)) {
+   *   return;
    * }
+   *
+   * const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)
+   *
+   * assert.isTrue(relaxed.length <= 32);
    * ```
    *
    * @template MaxLength - The maximum number of characters (inclusive).
@@ -122,11 +126,13 @@ export namespace Str {
    *
    * assert.isFalse(Str.isBoundedLengthString(8, 16, 'user'));
    *
-   * if (Str.isBoundedLengthString(8, 16, input)) {
-   *   const userId: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])
-   *
-   *   assert.isTrue(userId.length >= 8 && userId.length <= 16);
+   * if (!Str.isBoundedLengthString(8, 16, input)) {
+   *   return;
    * }
+   *
+   * const userId: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])
+   *
+   * assert.isTrue(8 <= userId.length && userId.length <= 16);
    * ```
    *
    * @template MinLength - The minimum number of characters (inclusive).
@@ -148,7 +154,7 @@ export namespace Str {
     maxLength: MaxLength,
     s: S,
   ): s is BoundedLengthString<MinLength, MaxLength> & S =>
-    s.length >= minLength && s.length <= maxLength;
+    minLength <= s.length && s.length <= maxLength;
 
   /**
    * Type guard that checks if a string has exactly `length` characters.
@@ -171,11 +177,13 @@ export namespace Str {
    *
    * assert.isFalse(Str.isFixedLengthString(3, input));
    *
-   * if (Str.isFixedLengthString(2, input)) {
-   *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)
-   *
-   *   assert.isTrue(atMost5.length === 2);
+   * if (!Str.isFixedLengthString(2, input)) {
+   *   return;
    * }
+   *
+   * const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)
+   *
+   * assert.isTrue(atMost5.length === 2);
    * ```
    *
    * @template Length - The exact number of characters.
@@ -361,7 +369,7 @@ export namespace Str {
    *
    * const relaxed: BoundedLengthString<1, 255> = userId; // OK ([8, 16] ⊆ [1, 255])
    *
-   * assert.isTrue(relaxed.length >= 8 && relaxed.length <= 16);
+   * assert.isTrue(8 <= relaxed.length && relaxed.length <= 16);
    *
    * // curried version
    * const asUserId = Str.asBoundedLengthString(8, 16);