ts-data-forge 14.0.0 → 14.1.0

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

@@ -3,11 +3,13 @@ import {
   type FixedLengthTuple,
   type MinLengthArray,
   type NonEmptyArray,
+  type NonEmptyTuple,
 } from 'ts-type-forge';
 import { IMap } from '../../collections/index.mjs';
 import { expectType } from '../../expect-type.mjs';
 import { Optional } from '../../functional/index.mjs';
 import { SafeUint } from '../../number/index.mjs';
+import { asMinLengthArray } from './array-utils-length-bounded-array-cast.mjs';
 import {
   cartesianProduct,
   concat,
@@ -52,7 +54,7 @@ describe('Arr transformations', () => {
 
       const mappedMixed = map(mixed, (x) => typeof x);
 
-      expectType<typeof mappedMixed, readonly [string, string, string]>('<=');
+      expectType<typeof mappedMixed, FixedLengthTuple<3, string>>('<=');
 
       assert.deepStrictEqual(mappedMixed, ['number', 'string', 'boolean']);
     });
@@ -62,12 +64,37 @@ describe('Arr transformations', () => {
 
       const mappedWithIndex = map(tuple, (x, i) => `${i}:${x}`);
 
-      expectType<typeof mappedWithIndex, readonly [string, string, string]>(
-        '<=',
-      );
+      expectType<typeof mappedWithIndex, FixedLengthTuple<3, string>>('<=');
 
       assert.deepStrictEqual(mappedWithIndex, ['0:a', '1:b', '2:c']);
     });
+
+    test('should preserve the tuple shape under a generic parameter', () => {
+      // A caller that is itself generic over the tuple cannot resolve a
+      // conditional return type, so `map` has to report the homomorphic
+      // mapping directly for a parameter that carries no length brand.
+      const mapValues = <const T extends readonly Readonly<{ v: unknown }>[]>(
+        boxes: T,
+      ): Readonly<{ [K in keyof T]: unknown }> => map(boxes, (b) => b.v);
+
+      const result = mapValues([{ v: 1 }, { v: 'a' }] as const);
+
+      expectType<typeof result, FixedLengthTuple<2, unknown>>('=');
+
+      assert.deepStrictEqual<FixedLengthTuple<2, unknown>>(result, [1, 'a']);
+    });
+
+    test('should keep the length brand of a branded array', () => {
+      const lower: MinLengthArray<2, number> = asMinLengthArray(2, [1, 2, 3]);
+
+      const mappedLower = map(lower, String);
+
+      expectType<typeof mappedLower, MinLengthArray<2, string>>('~=');
+
+      // The brand is not part of the runtime value, so compare structurally —
+      // the type argument is what widens it, no intermediate binding needed.
+      assert.deepStrictEqual<readonly string[]>(mappedLower, ['1', '2', '3']);
+    });
   });
 
   describe(scan, () => {
@@ -76,7 +103,7 @@ describe('Arr transformations', () => {
 
       const runningSum = scan(numbers, (acc, curr) => acc + curr, 0);
 
-      expectType<typeof runningSum, readonly [number, ...number[]]>('<=');
+      expectType<typeof runningSum, NonEmptyTuple<number>>('<=');
 
       assert.deepStrictEqual<readonly number[]>(runningSum, [0, 1, 3, 6, 10]);
     });
@@ -134,7 +161,7 @@ describe('Arr transformations', () => {
 
       const result = scan(strings, (acc, curr) => acc + curr.length, 0);
 
-      expectType<typeof result, readonly [number, ...number[]]>('<=');
+      expectType<typeof result, NonEmptyTuple<number>>('<=');
 
       assert.deepStrictEqual<readonly number[]>(result, [0, 1, 2, 3]);
     });
@@ -1015,7 +1042,7 @@ describe('Arr transformations', () => {
 
       const zipped = zip(xs, ys);
 
-      expectType<typeof zipped, readonly (readonly [number, number])[]>('=');
+      expectType<typeof zipped, readonly FixedLengthTuple<2, number>[]>('=');
 
       test('case 2', () => {
         assert.deepStrictEqual(zipped, [[1, 4]]);
@@ -1180,9 +1207,9 @@ describe('Arr transformations', () => {
 
 /* `toReversed` is a known permutation, so the tuple half can be reversed
    alongside the brand. It used to fall back to `ChangeArrayElement`, which kept
-   the length but collapsed the positions to their union. Never called; see the
-   note in `array-utils-modification.test.mts`. */
-export const reversedTypeChecks = (
+   the length but collapsed the positions to their union. Shape-per-parameter;
+   see the note in `array-utils-modification.test.mts`. */
+const reversedTypeChecks = (
   brandedFive: MinLengthArray<5, string>,
   brandedAndTuple: MinLengthArray<3, number> & readonly [1, 2, 3, 4, 5],
 ): void => {
@@ -1208,3 +1235,10 @@ export const reversedTypeChecks = (
 
   expectType<typeof _sortedTuple, FixedLengthTuple<3, 1 | 2 | 3>>('~=');
 };
+
+test('toReversed / toSorted type-level checks', () => {
+  reversedTypeChecks(
+    asMinLengthArray(5, ['a', 'b', 'c', 'd', 'e'] as const),
+    asMinLengthArray(3, [1, 2, 3, 4, 5] as const),
+  );
+});

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

@@ -1,4 +1,10 @@
-import { type BoolOr, type IsAny, type IsUnknown } from 'ts-type-forge';
+import {
+  type BoolOr,
+  type ChangeArrayElement,
+  type IsAny,
+  type IsUnknown,
+  type UnknownBrand,
+} from 'ts-type-forge';
 import { asUint32, Num } from '../../number/index.mjs';
 import { type ArrayIndex, type SizeType } from '../../types.mjs';
 
@@ -55,15 +61,30 @@ type Cast<A, B> = A extends B ? A : never;
  * assert.isFalse(allStartWithA);
  * ```
  */
-// Type guard overloads - narrow the entire array type
-export function every<E, S extends E>(
-  array: readonly E[],
-  predicate: (a: E, index: SizeType.Arr) => a is S,
-): array is readonly S[];
-
-export function every<E, S extends E>(
-  predicate: (a: E, index: SizeType.Arr) => a is S,
-): (array: readonly E[]) => array is readonly S[];
+// Type guard overloads - narrow the entire array type.
+//
+// Both narrowed types are intersected with `Ar`: a type predicate's type has
+// to be assignable to the parameter's type, and neither the deferred
+// conditional `ChangeArrayElement<Ar, S>` nor the mapped type over a generic
+// `Ar` is (TS2677). The intersection also keeps whatever the caller already
+// knew about the array — a branded five-tuple stays a five-tuple.
+export function every<
+  const Ar extends readonly unknown[] & UnknownBrand,
+  S extends Ar[number],
+>(
+  array: Ar,
+  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => a is S,
+): array is ChangeArrayElement<Ar, S> & Ar;
+
+// A plain array or tuple carries no length brand, so the homomorphic mapping
+// is the whole answer — same reasoning as in `map`.
+export function every<
+  const Ar extends readonly unknown[],
+  S extends Ar[number],
+>(
+  array: Ar,
+  predicate: (a: Ar[number], index: ArrayIndex<Ar>) => a is S,
+): array is Readonly<{ [K in keyof Ar]: S }> & Ar;
 
 // Regular boolean predicate overloads
 export function every<const Ar extends readonly unknown[]>(
@@ -71,6 +92,29 @@ export function every<const Ar extends readonly unknown[]>(
   predicate: (a: Ar[number], index: ArrayIndex<Ar>) => boolean,
 ): boolean;
 
+// curried version
+//
+// As in `map`, the branded and the plain case have to be overloads *of the
+// returned function*, not two overloads of `every` itself: both curried
+// signatures take the same single predicate, so overload resolution would
+// always pick the first and the second would be dead — which is what left a
+// plain `readonly unknown[]` unable to satisfy the `UnknownBrand` constraint
+// at the call site of the returned guard.
+//
+// The intersection is also what keeps the group compatible with the
+// implementation signature. A lone `<Ar extends readonly E[] & UnknownBrand>`
+// signature is not something `(array: readonly E[]) => boolean` can implement
+// (TS2394); the unbranded member of the intersection is, and one matching
+// member is enough.
+export function every<E, S extends E>(
+  predicate: (a: E, index: SizeType.Arr) => a is S,
+): (<const Ar extends readonly E[] & UnknownBrand>(
+  array: Ar,
+) => array is ChangeArrayElement<Ar, S> & Ar) &
+  (<const Ar extends readonly E[]>(
+    array: Ar,
+  ) => array is Readonly<{ [K in keyof Ar]: S }> & Ar);
+
 export function every<E>(
   predicate: (a: E, index: SizeType.Arr) => boolean,
 ): (array: readonly E[]) => boolean;

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

@@ -1,4 +1,16 @@
+import {
+  type BoundedLengthArray,
+  type FixedLengthArray,
+  type FixedLengthTuple,
+  type MinLengthArray,
+  type ReadonlyRecord,
+} from 'ts-type-forge';
 import { expectType } from '../../expect-type.mjs';
+import {
+  asBoundedLengthArray,
+  asFixedLengthArray,
+  asMinLengthArray,
+} from './array-utils-length-bounded-array-cast.mjs';
 import {
   every,
   indexIsInRange,
@@ -294,13 +306,12 @@ describe('Arr validations', () => {
         type ComplexUnion =
           | Readonly<
               | { type: 'array'; data: readonly string[] }
-              | { type: 'object'; data: Record<string, unknown> }
+              | { type: 'object'; data: ReadonlyRecord<string, unknown> }
             >
           | readonly number[]
           | string
           | null;
 
-        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
         const processComplex = (value: ComplexUnion): number => {
           if (isArray(value)) {
             expectType<typeof value, readonly number[]>('=');
@@ -324,7 +335,7 @@ describe('Arr validations', () => {
             typeof value,
             Readonly<
               | { type: 'array'; data: readonly string[] }
-              | { type: 'object'; data: Record<string, unknown> }
+              | { type: 'object'; data: ReadonlyRecord<string, unknown> }
             >
           >('=');
 
@@ -436,6 +447,145 @@ describe('Arr validations', () => {
 
       assert.isTrue(indexMatchesValue);
     });
+
+    /* What `every` reports about the array it narrowed, across the shapes the
+       two type-guard overloads have to cope with. It used to answer a bare
+       `readonly S[]` for every one of them, dropping both the tuple length and
+       the length-constraint brand. `assert.isTrue` narrows for the rest of the
+       block, so each case checks the runtime answer and the narrowed type
+       together. */
+    describe('narrowing', () => {
+      const isString = (x: string | number): x is string =>
+        typeof x === 'string';
+
+      const values: readonly (string | number)[] = [
+        'Ada',
+        'Grace',
+        'Katherine',
+      ] as const;
+
+      test('should keep a plain array as a plain array', () => {
+        const shapeArray: readonly (string | number)[] = values;
+
+        assert.isTrue(every(shapeArray, isString));
+
+        expectType<typeof shapeArray, readonly string[]>('~=');
+      });
+
+      test('should keep the length of a tuple', () => {
+        const shapeTuple: FixedLengthTuple<2, string | number> = [
+          'Ada',
+          'Grace',
+        ] as const;
+
+        assert.isTrue(every(shapeTuple, isString));
+
+        expectType<typeof shapeTuple, FixedLengthTuple<2, string>>('~=');
+
+        expectType<(typeof shapeTuple)['length'], 2>('=');
+      });
+
+      test('should keep a MinLengthArray brand', () => {
+        const shapeBranded = asMinLengthArray(3, values);
+
+        assert.isTrue(every(shapeBranded, isString));
+
+        expectType<typeof shapeBranded, MinLengthArray<3, string>>('~=');
+
+        // The brand still rules out `undefined` below the minimum length.
+        expectType<(typeof shapeBranded)[0], string>('=');
+      });
+
+      test('should keep a BoundedLengthArray brand', () => {
+        const shapeBounded = asBoundedLengthArray(2, 5, values);
+
+        assert.isTrue(every(shapeBounded, isString));
+
+        expectType<typeof shapeBounded, BoundedLengthArray<2, 5, string>>('~=');
+      });
+
+      test('should keep a FixedLengthArray brand', () => {
+        const shapeFixed = asFixedLengthArray(3, values);
+
+        assert.isTrue(every(shapeFixed, isString));
+
+        expectType<typeof shapeFixed, FixedLengthArray<3, string>>('~=');
+
+        expectType<(typeof shapeFixed)['length'], 3>('=');
+      });
+
+      /* Brand intersected with an exact tuple — the shape the `as*` casts and
+         the `is*` guards produce. Brand, length and positions all survive. */
+      test('should keep brand, length and positions of a branded tuple', () => {
+        const tuple: readonly [string, string | number] = [
+          'Ada',
+          'Grace',
+        ] as const;
+
+        const shapeBrandedTuple = asMinLengthArray(2, tuple);
+
+        assert.isTrue(every(shapeBrandedTuple, isString));
+
+        expectType<(typeof shapeBrandedTuple)[0], string>('=');
+
+        expectType<(typeof shapeBrandedTuple)[1], string>('=');
+
+        expectType<(typeof shapeBrandedTuple)['length'], 2>('=');
+      });
+
+      /* The curried form has to reach the same conclusions. Its two cases are
+         overloads of the *returned* guard rather than of `every` itself, so a
+         single `every(predicate)` value serves branded and unbranded arrays
+         alike — spelled as two overloads of `every`, the branded one shadowed
+         the other and passing a plain array to the result was an error. */
+      describe('curried', () => {
+        const allStrings = every(isString);
+
+        test('should keep a plain array as a plain array', () => {
+          const shapeArray: readonly (string | number)[] = values;
+
+          assert.isTrue(allStrings(shapeArray));
+
+          expectType<typeof shapeArray, readonly string[]>('~=');
+        });
+
+        test('should keep the length of a tuple', () => {
+          const shapeTuple: FixedLengthTuple<2, string | number> = [
+            'Ada',
+            'Grace',
+          ] as const;
+
+          assert.isTrue(allStrings(shapeTuple));
+
+          expectType<typeof shapeTuple, FixedLengthTuple<2, string>>('~=');
+
+          expectType<(typeof shapeTuple)['length'], 2>('=');
+        });
+
+        test('should keep a MinLengthArray brand', () => {
+          const shapeBranded = asMinLengthArray(3, values);
+
+          assert.isTrue(allStrings(shapeBranded));
+
+          expectType<typeof shapeBranded, MinLengthArray<3, string>>('~=');
+        });
+
+        test('should keep brand, length and positions of a branded tuple', () => {
+          const tuple: readonly [string, string | number] = [
+            'Ada',
+            'Grace',
+          ] as const;
+
+          const shapeBrandedTuple = asMinLengthArray(2, tuple);
+
+          assert.isTrue(allStrings(shapeBrandedTuple));
+
+          expectType<(typeof shapeBrandedTuple)[0], string>('=');
+
+          expectType<(typeof shapeBrandedTuple)['length'], 2>('=');
+        });
+      });
+    });
   });
 
   describe(some, () => {

package/src/collections/imap-mapped.mts

@@ -1157,7 +1157,7 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
         case 'update': {
           const curr = mut_result.get(key);
 
-          if (!mut_result.has(key) || curr === undefined) {
+          if (curr === undefined || !mut_result.has(key)) {
             if (this.#showNotFoundMessage) {
               console.warn(
                 `IMapMapped.withMutations::update: key not found: ${String(key)}`,

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

@@ -13,7 +13,7 @@ const testKeyToString = (key: Readonly<TestKey>): string =>
   `${key.type}_${key.id}` as const;
 
 const stringToTestKey = (str: string): TestKey => {
-  const [type, idStr] = str.split('_');
+  const [type, idStr] = str.split('_', 2);
 
   return {
     type: type ?? '',
@@ -113,7 +113,7 @@ describe('IMapMapped.create', () => {
     ): string => `${key.nested.id}_${key.arr.join(',')}` as const;
 
     const stringToComplexKey = (str: string): ComplexKey => {
-      const [idStr, arrStr] = str.split('_');
+      const [idStr, arrStr] = str.split('_', 2);
 
       return {
         nested: {

package/src/collections/imap.mts

@@ -549,7 +549,7 @@ type IMapInterface<K extends MapSetKeyType, V> = Readonly<{
    * const entries = [
    *   ['k1', 'v1'],
    *   ['k2', 'v2'],
-   * ] as const satisfies readonly (readonly [string, string])[];
+   * ] as const satisfies readonly FixedLengthTuple<2, string>[];
    *
    * const map = IMap.create(entries);
    *
@@ -877,7 +877,7 @@ class IMapClass<K extends MapSetKeyType, V>
 
           const curr = mut_result.get(key);
 
-          if (!mut_result.has(key) || curr === undefined) {
+          if (curr === undefined || !mut_result.has(key)) {
             if (this.#showNotFoundMessage) {
               const keyStr = unknownToString(key);
 

package/src/collections/iset-mapped.mts

@@ -1,5 +1,9 @@
 /* eslint-disable unicorn/prefer-iterator-to-array-at-end */
-import { type ReadonlyRecord, type WidenLiteral } from 'ts-type-forge';
+import {
+  type FixedLengthTuple,
+  type ReadonlyRecord,
+  type WidenLiteral,
+} from 'ts-type-forge';
 import { asUint32 } from '../number/index.mjs';
 import { type MapSetKeyType, type SizeType } from '../types.mjs';
 
@@ -788,7 +792,7 @@ type ISetMappedInterface<K, KM extends MapSetKeyType> = Readonly<{
    *
    * @returns An iterable iterator of entries.
    */
-  entries: () => IterableIterator<readonly [K, K]>;
+  entries: () => IterableIterator<FixedLengthTuple<2, K>>;
 
   // Conversion
 
@@ -1444,7 +1448,7 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
   }
 
   /** @inheritdoc */
-  *entries(): IterableIterator<readonly [K, K]> {
+  *entries(): IterableIterator<FixedLengthTuple<2, K>> {
     for (const km of this.#set) {
       // JavaScript Set's entries() yields [value, value]
       const a = this.#fromKey(km);

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

@@ -13,7 +13,7 @@ const testElementToString = (el: Readonly<TestElement>): string =>
   `${el.type}_${el.id}` as const;
 
 const stringToTestElement = (str: string): TestElement => {
-  const [type, idStr] = str.split('_');
+  const [type, idStr] = str.split('_', 2);
 
   return {
     type: type ?? '',

package/src/collections/iset.mts

@@ -1,5 +1,9 @@
 /* eslint-disable unicorn/prefer-iterator-to-array-at-end */
-import { type ReadonlyRecord, type WidenLiteral } from 'ts-type-forge';
+import {
+  type FixedLengthTuple,
+  type ReadonlyRecord,
+  type WidenLiteral,
+} from 'ts-type-forge';
 import { asUint32 } from '../number/index.mjs';
 import { unknownToString } from '../others/index.mjs';
 import { type MapSetKeyType, type SizeType } from '../types.mjs';
@@ -460,7 +464,7 @@ type ISetInterface<K extends MapSetKeyType> = Readonly<{
    *
    * @returns An iterable iterator of entries.
    */
-  entries: () => IterableIterator<readonly [K, K]>;
+  entries: () => IterableIterator<FixedLengthTuple<2, K>>;
 
   // Conversion
 
@@ -913,7 +917,7 @@ class ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {
   }
 
   /** @inheritdoc */
-  entries(): IterableIterator<readonly [K, K]> {
+  entries(): IterableIterator<FixedLengthTuple<2, K>> {
     return this.#set.entries();
   }
 

package/src/collections/iset.test.mts

@@ -1,4 +1,9 @@
-import { type DeepReadonly, type Primitive } from 'ts-type-forge';
+import {
+  type DeepReadonly,
+  type FixedLengthTuple,
+  type MutableFixedLengthTuple,
+  type Primitive,
+} from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { isString } from '../guard/index.mjs';
 import { type MapSetKeyType } from '../types.mjs';
@@ -974,13 +979,11 @@ describe('ISet.entries', () => {
 
     expectType<
       typeof s0.entries,
-      () => IterableIterator<readonly [1 | 2 | 3, 1 | 2 | 3]>
+      () => IterableIterator<FixedLengthTuple<2, 1 | 2 | 3>>
     >('<=');
 
-    const result: DeepReadonly<[1 | 2 | 3, 1 | 2 | 3][]> = Array.from(
-      s0.entries(),
-      (x) => [x[0], x[1]],
-    );
+    const result: DeepReadonly<MutableFixedLengthTuple<2, 1 | 2 | 3>[]> =
+      Array.from(s0.entries(), (x) => [x[0], x[1]]);
 
     assert.deepStrictEqual(
       result.toSorted((a, b) => a[0] - b[0]),

package/src/functional/match.mts

@@ -121,7 +121,7 @@ expectType<AllCasesCovered<'a' | 'b', Readonly<{ a: 1; b: 2; c: 3 }>>, false>(
   '=',
 );
 
-expectType<AllCasesCovered<string, Record<string, string>>, true>('=');
+expectType<AllCasesCovered<string, ReadonlyRecord<string, string>>, true>('=');
 
 /**
  * @template Case A union of string literal types.
@@ -152,9 +152,10 @@ expectType<
   false
 >('=');
 
-expectType<IsLiteralUnionFullyCovered<string, Record<string, string>>, false>(
-  '=',
-);
+expectType<
+  IsLiteralUnionFullyCovered<string, ReadonlyRecord<string, string>>,
+  false
+>('=');
 
 expectType<
   // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents

package/src/functional/result.test.mts

@@ -407,8 +407,11 @@ describe('Result test', () => {
 
   describe('fromPromise', () => {
     test('handles async functions that resolve', async () => {
-      const asyncFn = async (): Promise<number> =>
-        Promise.resolve().then(() => 42);
+      const asyncFn = async (): Promise<number> => {
+        await Promise.resolve();
+
+        return 42;
+      };
 
       const result = await Result.fromPromise(asyncFn());
 

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

@@ -23,7 +23,7 @@ describe(isPrimitive, () => {
 
     assert.isTrue(isPrimitive(0));
 
-    assert.isTrue(isPrimitive(-3.14));
+    assert.isTrue(isPrimitive(-1.23));
 
     assert.isTrue(isPrimitive(Number.NaN));
 

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

@@ -1,4 +1,4 @@
-import { type UnknownRecord } from 'ts-type-forge';
+import { type ReadonlyRecord, type UnknownRecord } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { hasKey } from './has-key.mjs';
 import { isRecord } from './is-record.mjs';
@@ -31,13 +31,13 @@ describe(isRecord, () => {
   describe('arrays are not records', () => {
     test('type-level: arrays are not assignable to UnknownRecord', () => {
       // Arrays have a number index signature but no string index signature,
-      // so they are assignable to `Record<number, unknown>` but not to
+      // so they are assignable to `ReadonlyRecord<number, unknown>` but not to
       // `UnknownRecord` (= `ReadonlyRecord<string, unknown>`).
-      expectType<readonly number[], Record<number, unknown>>('<=');
+      expectType<readonly number[], ReadonlyRecord<number, unknown>>('<=');
 
       expectType<readonly number[], UnknownRecord>('!<=');
 
-      expectType<readonly string[], Record<number, unknown>>('<=');
+      expectType<readonly string[], ReadonlyRecord<number, unknown>>('<=');
 
       expectType<readonly string[], UnknownRecord>('!<=');
 

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

@@ -157,7 +157,7 @@ describe(isNumber, () => {
 
     assert.isTrue(isNumber(42));
 
-    assert.isTrue(isNumber(-3.14));
+    assert.isTrue(isNumber(-1.23));
 
     assert.isTrue(isNumber(Number.NaN));
 
@@ -322,7 +322,7 @@ describe(isNotNumber, () => {
 
     assert.isFalse(isNotNumber(42));
 
-    assert.isFalse(isNotNumber(-3.14));
+    assert.isFalse(isNotNumber(-1.23));
 
     assert.isFalse(isNotNumber(Number.NaN));
 

package/src/number/branded-types/finite-number.test.mts

@@ -12,7 +12,7 @@ describe('FiniteNumber test', () => {
 
       expect(() => asFiniteNumber(-1)).not.toThrow();
 
-      expect(() => asFiniteNumber(3.14)).not.toThrow();
+      expect(() => asFiniteNumber(1.23)).not.toThrow();
 
       expect(() => asFiniteNumber(-2.5)).not.toThrow();
 
@@ -59,7 +59,7 @@ describe('FiniteNumber test', () => {
 
       assert.isTrue(FiniteNumber.is(-1));
 
-      assert.isTrue(FiniteNumber.is(3.14));
+      assert.isTrue(FiniteNumber.is(1.23));
 
       assert.isTrue(FiniteNumber.is(-2.5));
 

package/src/number/branded-types/non-negative-finite-number.test.mts

@@ -13,7 +13,7 @@ describe('NonNegativeFiniteNumber test', () => {
 
       expect(() => asNonNegativeFiniteNumber(1)).not.toThrow();
 
-      expect(() => asNonNegativeFiniteNumber(3.14)).not.toThrow();
+      expect(() => asNonNegativeFiniteNumber(1.23)).not.toThrow();
 
       expect(() => asNonNegativeFiniteNumber(0.5)).not.toThrow();
 
@@ -71,7 +71,7 @@ describe('NonNegativeFiniteNumber test', () => {
 
       assert.isTrue(isNonNegativeFiniteNumber(1));
 
-      assert.isTrue(isNonNegativeFiniteNumber(3.14));
+      assert.isTrue(isNonNegativeFiniteNumber(1.23));
 
       assert.isTrue(isNonNegativeFiniteNumber(0.5));
 

package/src/number/branded-types/non-positive-finite-number.mts

@@ -23,7 +23,7 @@ const {
   number,
   0
 >({
-  MIN_VALUE: Number.MAX_VALUE * -1,
+  MIN_VALUE: -Number.MAX_VALUE,
   MAX_VALUE: 0,
   typeNameInMessage,
 } as const);