ts-data-forge 14.0.1 → 14.2.0

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

@@ -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.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/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/optional/impl/optional-map.mts

@@ -40,9 +40,24 @@ export function map<O extends UnknownOptional, S2>(
 ): Optional<S2>;
 
 // Curried version
+//
+// The returned function is generic over the *whole* optional, mirroring the
+// direct overload above, rather than fixing its parameter to `Optional<S>`.
+// Fixing it makes the curried form unusable from a caller that is itself
+// generic over the optional: with `S` bound to `Unwrap<O>` at currying time
+// the parameter becomes `Optional<Unwrap<O>>`, and TypeScript cannot show a
+// bare `O extends UnknownOptional` is assignable to that — although every
+// concrete instantiation of `O` is.
+//
+// The conditional is what keeps the check: `O` is inferred from the argument
+// and its value type still has to satisfy `S`, so mapping a `(s: string) =>
+// …` over an `Optional<number>` stays an error. The cost is the message it
+// produces — "not assignable to `never`" rather than naming the two optionals.
 export function map<S, S2>(
   mapFn: (value: S) => S2,
-): (optional: Optional<S>) => Optional<S2>;
+): <O extends UnknownOptional>(
+  optional: Unwrap<O> extends S ? O : never,
+) => Optional<S2>;
 
 export function map<O extends UnknownOptional, S2>(
   ...args:

package/src/functional/optional.test.mts

@@ -1,7 +1,7 @@
 import { expectType } from '../expect-type.mjs';
 import { Num } from '../number/index.mjs';
 import { type None, type Some } from '../types.mjs';
-import { Optional } from './optional/index.mjs';
+import { Optional, type UnknownOptional } from './optional/index.mjs';
 import { pipe } from './pipe.mjs';
 import { Result } from './result/index.mjs';
 
@@ -144,6 +144,53 @@ describe('Optional test', () => {
       }
     });
 
+    test('curried form is usable from a caller generic over the optional', () => {
+      // The motivating case: with the curried parameter fixed to
+      // `Optional<S>`, `S` binds to `Optional.Unwrap<O>` here and a bare
+      // `O extends UnknownOptional` is not assignable to
+      // `Optional<Optional.Unwrap<O>>`, so this only compiles because the
+      // returned function is generic over the whole optional.
+      const liftMap =
+        <O extends UnknownOptional, B>(mapFn: (x: Optional.Unwrap<O>) => B) =>
+        (optional: O): Optional<B> =>
+          Optional.map(mapFn)(optional);
+
+      const lengthOf = liftMap<Optional<string>, number>((s) => s.length);
+
+      const mapped = lengthOf(Optional.some('abc'));
+
+      expectType<typeof mapped, Optional<number>>('=');
+
+      assert.deepStrictEqual(mapped, Optional.some(3));
+
+      assert.deepStrictEqual(lengthOf(Optional.none), Optional.none);
+    });
+
+    test('curried form still infers the result precisely', () => {
+      const mapToLength = Optional.map((text: string) => text.length);
+
+      const mapped = mapToLength(Optional.some('abc'));
+
+      expectType<typeof mapped, Optional<number>>('=');
+
+      assert.deepStrictEqual(mapped, Optional.some(3));
+
+      const empty = mapToLength(Optional.none);
+
+      expectType<typeof empty, Optional<number>>('=');
+
+      assert.deepStrictEqual(empty, Optional.none);
+    });
+
+    test('curried form still rejects a mismatched value type', () => {
+      const mapToLength = Optional.map((text: string) => text.length);
+
+      // @ts-expect-error an Optional<number> is not an Optional<string>
+      const rejected = (): unknown => mapToLength(Optional.some(42));
+
+      expect(rejected).toBeTypeOf('function');
+    });
+
     test('should preserve types correctly', () => {
       const some = Optional.some(42);
 

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

@@ -44,9 +44,24 @@ export function mapErr<R extends UnknownResult, E2>(
 ): Result<UnwrapOk<R>, E2>;
 
 // Curried version
+//
+// The returned function is generic over the *whole* result, mirroring the
+// direct overload above, rather than fixing its parameter to `Result<S, E>`.
+// Fixing it makes the curried form unusable from a caller that is itself
+// generic over the result: with `E` bound to `UnwrapErr<R>` at currying time the
+// parameter becomes `Result<...>` in terms of `R`, and TypeScript cannot show
+// a bare `R extends UnknownResult` is assignable to that — although every
+// concrete instantiation of `R` is.
+//
+// The conditional is what keeps the check: `R` is inferred from the argument
+// and its error type still has to satisfy `E`, so the mismatched case stays an
+// error. The cost is the message it produces — "not assignable to `never`"
+// rather than naming the two results.
 export function mapErr<E, E2>(
   mapFn: (error: E) => E2,
-): <S>(result: Result<S, E>) => Result<S, E2>;
+): <R extends UnknownResult>(
+  result: UnwrapErr<R> extends E ? R : never,
+) => Result<UnwrapOk<R>, E2>;
 
 export function mapErr<R extends UnknownResult, E2>(
   ...args:

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

@@ -44,9 +44,24 @@ export function map<R extends UnknownResult, S2>(
 ): Result<S2, UnwrapErr<R>>;
 
 // Curried version
+//
+// The returned function is generic over the *whole* result, mirroring the
+// direct overload above, rather than fixing its parameter to `Result<S, E>`.
+// Fixing it makes the curried form unusable from a caller that is itself
+// generic over the result: with `S` bound to `UnwrapOk<R>` at currying time the
+// parameter becomes `Result<...>` in terms of `R`, and TypeScript cannot show
+// a bare `R extends UnknownResult` is assignable to that — although every
+// concrete instantiation of `R` is.
+//
+// The conditional is what keeps the check: `R` is inferred from the argument
+// and its success type still has to satisfy `S`, so the mismatched case stays an
+// error. The cost is the message it produces — "not assignable to `never`"
+// rather than naming the two results.
 export function map<S, S2>(
   mapFn: (value: S) => S2,
-): <E>(result: Result<S, E>) => Result<S2, E>;
+): <R extends UnknownResult>(
+  result: UnwrapOk<R> extends S ? R : never,
+) => Result<S2, UnwrapErr<R>>;
 
 export function map<R extends UnknownResult, S2>(
   ...args:

package/src/functional/result.test.mts

@@ -3,7 +3,7 @@ import { Num } from '../number/index.mjs';
 import { type Err, type Ok } from '../types.mjs';
 import { Optional } from './optional/index.mjs';
 import { pipe } from './pipe.mjs';
-import { Result } from './result/index.mjs';
+import { Result, type UnknownResult } from './result/index.mjs';
 
 describe('Result test', () => {
   describe('ok', () => {
@@ -174,6 +174,49 @@ describe('Result test', () => {
 
       expect(result.value).toBe('10');
     });
+
+    test('curried form is usable from a caller generic over the result', () => {
+      // The motivating case: with the curried parameter fixed to
+      // `Result<S, E>`, `S` binds to `Result.UnwrapOk<R>` here and a bare
+      // `R extends UnknownResult` is not assignable to that, so this only
+      // compiles because the returned function is generic over the whole
+      // result.
+      const liftMap =
+        <R extends UnknownResult, S2>(mapFn: (x: Result.UnwrapOk<R>) => S2) =>
+        (result: R): Result<S2, Result.UnwrapErr<R>> =>
+          Result.map(mapFn)(result);
+
+      const lengthOf = liftMap<Result<string, 'boom'>, number>((s) => s.length);
+
+      const mapped = lengthOf(Result.ok('abc'));
+
+      expectType<typeof mapped, Result<number, 'boom'>>('=');
+
+      assert.deepStrictEqual(mapped, Result.ok(3));
+
+      assert.deepStrictEqual(lengthOf(Result.err('boom')), Result.err('boom'));
+    });
+
+    test('curried form keeps the error type and rejects a mismatch', () => {
+      const mapToLength = Result.map((text: string) => text.length);
+
+      const mapped = mapToLength(Result.ok('abc'));
+
+      expectType<typeof mapped, Result<number, never>>('=');
+
+      assert.deepStrictEqual(mapped, Result.ok(3));
+
+      const failed = mapToLength(Result.err('boom' as const));
+
+      expectType<typeof failed, Result<number, 'boom'>>('=');
+
+      assert.deepStrictEqual(failed, Result.err('boom'));
+
+      // @ts-expect-error a Result<number, …> is not a Result<string, …>
+      const rejected = (): unknown => mapToLength(Result.ok(42));
+
+      expect(rejected).toBeTypeOf('function');
+    });
   });
 
   describe('mapErr', () => {
@@ -234,6 +277,40 @@ describe('Result test', () => {
 
       expect(result.value).toBe('ERROR: FAILED');
     });
+
+    test('curried form is usable from a caller generic over the result', () => {
+      const liftMapErr =
+        <R extends UnknownResult, E2>(mapFn: (x: Result.UnwrapErr<R>) => E2) =>
+        (result: R): Result<Result.UnwrapOk<R>, E2> =>
+          Result.mapErr(mapFn)(result);
+
+      const shout = liftMapErr<Result<number, string>, string>((e) =>
+        e.toUpperCase(),
+      );
+
+      const mapped = shout(Result.err('failed'));
+
+      expectType<typeof mapped, Result<number, string>>('=');
+
+      assert.deepStrictEqual(mapped, Result.err('FAILED'));
+
+      assert.deepStrictEqual(shout(Result.ok(1)), Result.ok(1));
+    });
+
+    test('curried form keeps the ok type and rejects a mismatch', () => {
+      const shout = Result.mapErr((e: string) => e.toUpperCase());
+
+      const mapped = shout(Result.err('failed'));
+
+      expectType<typeof mapped, Result<never, string>>('=');
+
+      assert.deepStrictEqual(mapped, Result.err('FAILED'));
+
+      // @ts-expect-error a Result<…, number> is not a Result<…, string>
+      const rejected = (): unknown => shout(Result.err(42));
+
+      expect(rejected).toBeTypeOf('function');
+    });
   });
 
   describe('unwrapThrow', () => {
@@ -407,8 +484,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);

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

@@ -13,17 +13,13 @@ describe('NonPositiveFiniteNumber test', () => {
 
       expect(() => asNonPositiveFiniteNumber(-1)).not.toThrow();
 
-      expect(() => asNonPositiveFiniteNumber(-3.14)).not.toThrow();
+      expect(() => asNonPositiveFiniteNumber(-1.23)).not.toThrow();
 
       expect(() => asNonPositiveFiniteNumber(-0.5)).not.toThrow();
 
-      expect(() =>
-        asNonPositiveFiniteNumber(Number.MIN_VALUE * -1),
-      ).not.toThrow();
+      expect(() => asNonPositiveFiniteNumber(-Number.MIN_VALUE)).not.toThrow();
 
-      expect(() =>
-        asNonPositiveFiniteNumber(Number.MAX_VALUE * -1),
-      ).not.toThrow();
+      expect(() => asNonPositiveFiniteNumber(-Number.MAX_VALUE)).not.toThrow();
     });
 
     test('rejects positive numbers', () => {
@@ -63,11 +59,11 @@ describe('NonPositiveFiniteNumber test', () => {
 
       assert.isTrue(isNonPositiveFiniteNumber(-1));
 
-      assert.isTrue(isNonPositiveFiniteNumber(-3.14));
+      assert.isTrue(isNonPositiveFiniteNumber(-1.23));
 
       assert.isTrue(isNonPositiveFiniteNumber(-0.5));
 
-      assert.isTrue(isNonPositiveFiniteNumber(Number.MIN_VALUE * -1));
+      assert.isTrue(isNonPositiveFiniteNumber(-Number.MIN_VALUE));
     });
 
     test('correctly rejects positive numbers', () => {

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

@@ -13,7 +13,7 @@ describe('NonZeroFiniteNumber test', () => {
 
       expect(() => asNonZeroFiniteNumber(-1)).not.toThrow();
 
-      expect(() => asNonZeroFiniteNumber(3.14)).not.toThrow();
+      expect(() => asNonZeroFiniteNumber(1.23)).not.toThrow();
 
       expect(() => asNonZeroFiniteNumber(-2.5)).not.toThrow();
 
@@ -73,7 +73,7 @@ describe('NonZeroFiniteNumber test', () => {
 
       assert.isTrue(isNonZeroFiniteNumber(-1));
 
-      assert.isTrue(isNonZeroFiniteNumber(3.14));
+      assert.isTrue(isNonZeroFiniteNumber(1.23));
 
       assert.isTrue(isNonZeroFiniteNumber(-2.5));