ts-data-forge 14.7.1 → 14.8.0

package/src/collections/iset-mapped.mts

@@ -1,12 +1,12 @@
 /* eslint-disable unicorn/prefer-iterator-to-array-at-end */
-import {
-  type FixedLengthTuple,
-  type ReadonlyRecord,
-  type WidenLiteral,
+import type {
+  FixedLengthTuple,
+  ReadonlyRecord,
+  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';
+import type { MapSetKeyType, SizeType } from '../types.mjs';
 
 /**
  * Interface for an immutable set with custom element mapping and membership
@@ -1240,7 +1240,9 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
   /** @inheritdoc */
   every(predicate: (key: K) => boolean): boolean {
     for (const key of this.values()) {
-      if (!predicate(key)) return false;
+      if (!predicate(key)) {
+        return false;
+      }
     }
 
     return true;
@@ -1249,7 +1251,9 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
   /** @inheritdoc */
   some(predicate: (key: K) => boolean): boolean {
     for (const key of this.values()) {
-      if (predicate(key)) return true;
+      if (predicate(key)) {
+        return true;
+      }
     }
 
     return false;
@@ -1257,7 +1261,9 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
 
   /** @inheritdoc */
   add(key: K): ISetMapped<K, KM> {
-    if (this.has(key)) return this;
+    if (this.has(key)) {
+      return this;
+    }
 
     return ISetMapped.create(
       [...this.#set, this.#toKey(key)].map(this.#fromKey),

package/src/collections/iset.mts

@@ -1,12 +1,12 @@
 /* eslint-disable unicorn/prefer-iterator-to-array-at-end */
-import {
-  type FixedLengthTuple,
-  type ReadonlyRecord,
-  type WidenLiteral,
+import type {
+  FixedLengthTuple,
+  ReadonlyRecord,
+  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';
+import type { MapSetKeyType, SizeType } from '../types.mjs';
 
 /**
  * Interface for an immutable set with membership testing and set operation
@@ -766,7 +766,9 @@ class ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {
   /** @inheritdoc */
   every(predicate: (key: K) => boolean): boolean {
     for (const key of this.values()) {
-      if (!predicate(key)) return false;
+      if (!predicate(key)) {
+        return false;
+      }
     }
 
     return true;
@@ -775,7 +777,9 @@ class ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {
   /** @inheritdoc */
   some(predicate: (key: K) => boolean): boolean {
     for (const key of this.values()) {
-      if (predicate(key)) return true;
+      if (predicate(key)) {
+        return true;
+      }
     }
 
     return false;
@@ -783,9 +787,7 @@ class ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {
 
   /** @inheritdoc */
   add(key: K): ISet<K> {
-    if (this.has(key)) return this;
-
-    return ISet.create([...this.#set, key]);
+    return this.has(key) ? this : ISet.create([...this.#set, key]);
   }
 
   /** @inheritdoc */

package/src/collections/iset.test.mts

@@ -1,12 +1,12 @@
-import {
-  type DeepReadonly,
-  type FixedLengthTuple,
-  type MutableFixedLengthTuple,
-  type Primitive,
+import type {
+  DeepReadonly,
+  FixedLengthTuple,
+  MutableFixedLengthTuple,
+  Primitive,
 } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { isString } from '../guard/index.mjs';
-import { type MapSetKeyType } from '../types.mjs';
+import type { MapSetKeyType } from '../types.mjs';
 import { ISet } from './iset.mjs';
 
 describe('ISet.create', () => {
@@ -188,13 +188,15 @@ describe('every method as type guard', () => {
   test('should narrow type when used as type guard', () => {
     const set = ISet.create<string | number>(['hello', 'world']);
 
-    if (set.every((value): value is string => typeof value === 'string')) {
-      // Type should be narrowed to ISet<string>
-      const values = set.toArray();
+    if (!set.every((value): value is string => typeof value === 'string')) {
+      return;
+    }
+
+    // Type should be narrowed to ISet<string>
+    const values = set.toArray();
 
-      for (const value of values) {
-        assert.isTrue(isString(value));
-      }
+    for (const value of values) {
+      assert.isTrue(isString(value));
     }
   });
 

package/src/collections/queue.mts

@@ -1,7 +1,7 @@
 import { Optional } from '../functional/index.mjs';
 import { range } from '../iterator/index.mjs';
 import { asSafeUint, asUint32 } from '../number/index.mjs';
-import { type SizeType } from '../types.mjs';
+import type { SizeType } from '../types.mjs';
 
 /**
  * Interface for a high-performance queue with FIFO (First-In, First-Out)

package/src/collections/stack.mts

@@ -1,7 +1,7 @@
 import { Optional } from '../functional/index.mjs';
 import { range } from '../iterator/index.mjs';
 import { asUint32, Uint32 } from '../number/index.mjs';
-import { type SizeType } from '../types.mjs';
+import type { SizeType } from '../types.mjs';
 
 /**
  * Interface for a high-performance stack with LIFO (Last-In, First-Out)

package/src/collections/stack.test.mts

@@ -2,7 +2,7 @@ import { expectType } from '../expect-type.mjs';
 import { Optional } from '../functional/index.mjs';
 import { range } from '../iterator/index.mjs';
 import { asPositiveSafeInt, asSafeInt } from '../number/index.mjs';
-import { type SizeType } from '../types.mjs';
+import type { SizeType } from '../types.mjs';
 import { createStack, type Stack } from './stack.mjs';
 
 describe('Stack test', () => {
@@ -263,12 +263,14 @@ describe('Stack test', () => {
     for (const i of range(100)) {
       stack.push(i);
 
-      if (i % 2 === 1) {
-        // Pop every other time
-        const result = stack.pop();
-
-        expect(Optional.unwrap(result)).toBe(i);
+      if (i % 2 !== 1) {
+        continue;
       }
+
+      // Pop every other time
+      const result = stack.pop();
+
+      expect(Optional.unwrap(result)).toBe(i);
     }
 
     // Should have 50 elements remaining (0, 2, 4, ..., 98)

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

@@ -111,11 +111,13 @@ describe('isError from @sindresorhus/is', () => {
   test('should act as a type guard', () => {
     const value: Error | string = new Error('test');
 
-    if (isErrorBySindreSorhus(value)) {
-      expectType<typeof value, Error>('=');
-
-      expect(value.message).toBe('test');
+    if (!isErrorBySindreSorhus(value)) {
+      return;
     }
+
+    expectType<typeof value, Error>('=');
+
+    expect(value.message).toBe('test');
   });
 
   test('should work with AggregateError', () => {

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

@@ -1,4 +1,4 @@
-import { type NonEmptyString, type RelaxedExclude } from 'ts-type-forge';
+import type { NonEmptyString, RelaxedExclude } from 'ts-type-forge';
 
 /**
  * Type guard that checks if a value is a non-empty string.

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

@@ -1,4 +1,4 @@
-import { type NonEmptyString } from 'ts-type-forge';
+import type { NonEmptyString } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { isNonEmptyString } from './is-non-empty-string.mjs';
 
@@ -55,24 +55,28 @@ describe(isNonEmptyString, () => {
     const value: unknown = 'test';
 
     // @ts-expect-error Testing non-string types
-    if (isNonEmptyString(value)) {
-      expectType<typeof value, NonEmptyString>('=');
+    if (!isNonEmptyString(value)) {
+      return;
+    }
 
-      // TypeScript knows it's a string
-      expect(value.length).toBeGreaterThan(0);
+    expectType<typeof value, NonEmptyString>('=');
 
-      expect(value.at(0)).toBe('t');
-    }
+    // TypeScript knows it's a string
+    expect(value.length).toBeGreaterThan(0);
+
+    expect(value.at(0)).toBe('t');
   });
 
   test('should narrow string | undefined | null types', () => {
     const maybeString: string | undefined | null = 'hello';
 
-    if (isNonEmptyString(maybeString)) {
-      expectType<typeof maybeString, NonEmptyString>('=');
-
-      expect(maybeString.toUpperCase()).toBe('HELLO');
+    if (!isNonEmptyString(maybeString)) {
+      return;
     }
+
+    expectType<typeof maybeString, NonEmptyString>('=');
+
+    expect(maybeString.toUpperCase()).toBe('HELLO');
   });
 
   test('should work in filter operations', () => {

package/src/guard/is-primitive.mts

@@ -1,4 +1,4 @@
-import { type Primitive } from 'ts-type-forge';
+import type { Primitive } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 
 /**

package/src/guard/is-type.mts

@@ -1,4 +1,4 @@
-import { type RelaxedExclude } from 'ts-type-forge';
+import type { RelaxedExclude } from 'ts-type-forge';
 
 /**
  * Type guard that checks if a value is `undefined`.

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

@@ -143,11 +143,13 @@ describe(isString, () => {
   test('should act as a type guard', () => {
     const value: unknown = 'test';
 
-    if (isString(value)) {
-      expectType<typeof value, string>('=');
-
-      expect(value).toHaveLength(4);
+    if (!isString(value)) {
+      return;
     }
+
+    expectType<typeof value, string>('=');
+
+    expect(value).toHaveLength(4);
   });
 });
 
@@ -182,11 +184,13 @@ describe(isNumber, () => {
   test('should act as a type guard', () => {
     const value: unknown = 42;
 
-    if (isNumber(value)) {
-      expectType<typeof value, number>('=');
-
-      expect(value + 1).toBe(43);
+    if (!isNumber(value)) {
+      return;
     }
+
+    expectType<typeof value, number>('=');
+
+    expect(value + 1).toBe(43);
   });
 });
 
@@ -212,11 +216,13 @@ describe(isBigint, () => {
   test('should act as a type guard', () => {
     const value: unknown = 123n;
 
-    if (isBigint(value)) {
-      expectType<typeof value, bigint>('=');
-
-      expect(value + 1n).toBe(124n);
+    if (!isBigint(value)) {
+      return;
     }
+
+    expectType<typeof value, bigint>('=');
+
+    expect(value + 1n).toBe(124n);
   });
 });
 
@@ -243,11 +249,13 @@ describe(isBoolean, () => {
   test('should act as a type guard', () => {
     const value: unknown = true;
 
-    if (isBoolean(value)) {
-      expectType<typeof value, boolean>('=');
-
-      assert.isTrue(value);
+    if (!isBoolean(value)) {
+      return;
     }
+
+    expectType<typeof value, boolean>('=');
+
+    assert.isTrue(value);
   });
 });
 
@@ -271,11 +279,13 @@ describe(isSymbol, () => {
   test('should act as a type guard', () => {
     const value: unknown = Symbol('test');
 
-    if (isSymbol(value)) {
-      expectType<typeof value, symbol>('=');
-
-      expect(value.toString()).toContain('Symbol');
+    if (!isSymbol(value)) {
+      return;
     }
+
+    expectType<typeof value, symbol>('=');
+
+    expect(value.toString()).toContain('Symbol');
   });
 });
 
@@ -307,12 +317,14 @@ describe(isNotBoolean, () => {
   test('should act as a type guard', () => {
     const value: string | number | boolean = 'test';
 
-    if (isNotBoolean(value)) {
-      expectType<typeof value, string | number>('<=');
-
-      // Should not have boolean methods
-      assert.isTrue(typeof value === 'string' || typeof value === 'number');
+    if (!isNotBoolean(value)) {
+      return;
     }
+
+    expectType<typeof value, string | number>('<=');
+
+    // Should not have boolean methods
+    assert.isTrue(typeof value === 'string' || typeof value === 'number');
   });
 });
 
@@ -354,11 +366,13 @@ describe(isNotNumber, () => {
   test('should act as a type guard', () => {
     const value: string | number | boolean = 'test';
 
-    if (isNotNumber(value)) {
-      expectType<typeof value, string | boolean>('<=');
-
-      assert.isTrue(typeof value === 'string' || typeof value === 'boolean');
+    if (!isNotNumber(value)) {
+      return;
     }
+
+    expectType<typeof value, string | boolean>('<=');
+
+    assert.isTrue(typeof value === 'string' || typeof value === 'boolean');
   });
 });
 
@@ -392,11 +406,13 @@ describe(isNotBigint, () => {
   test('should act as a type guard', () => {
     const value: number | bigint = 123;
 
-    if (isNotBigint(value)) {
-      expectType<typeof value, number>('<=');
-
-      expectTypeOf(value).toBeNumber();
+    if (!isNotBigint(value)) {
+      return;
     }
+
+    expectType<typeof value, number>('<=');
+
+    expectTypeOf(value).toBeNumber();
   });
 });
 
@@ -434,11 +450,13 @@ describe(isNotString, () => {
   test('should act as a type guard', () => {
     const value: string | number | boolean = 42;
 
-    if (isNotString(value)) {
-      expectType<typeof value, number | boolean>('<=');
-
-      assert.isTrue(typeof value === 'number' || typeof value === 'boolean');
+    if (!isNotString(value)) {
+      return;
     }
+
+    expectType<typeof value, number | boolean>('<=');
+
+    assert.isTrue(typeof value === 'number' || typeof value === 'boolean');
   });
 });
 
@@ -474,11 +492,13 @@ describe(isNotSymbol, () => {
   test('should act as a type guard', () => {
     const value: string | number | symbol = 'test';
 
-    if (isNotSymbol(value)) {
-      expectType<typeof value, string | number>('<=');
-
-      assert.isTrue(typeof value === 'string' || typeof value === 'number');
+    if (!isNotSymbol(value)) {
+      return;
     }
+
+    expectType<typeof value, string | number>('<=');
+
+    assert.isTrue(typeof value === 'string' || typeof value === 'number');
   });
 });
 
@@ -510,12 +530,14 @@ describe(isNullish, () => {
   test('should act as a type guard', () => {
     const value: string | null | undefined = null;
 
-    if (isNullish(value)) {
-      expectType<typeof value, null | undefined>('<=');
-
-      // Value is guaranteed to be null or undefined in this branch
-      expect(true).toBe(true);
+    if (!isNullish(value)) {
+      return;
     }
+
+    expectType<typeof value, null | undefined>('<=');
+
+    // Value is guaranteed to be null or undefined in this branch
+    expect(true).toBe(true);
   });
 
   test('should handle edge cases', () => {
@@ -558,11 +580,13 @@ describe(isNonNullish, () => {
   test('should act as a type guard', () => {
     const value: string | null | undefined = 'test';
 
-    if (isNonNullish(value)) {
-      expectType<typeof value, string>('<=');
-
-      expect(value).toHaveLength(4);
+    if (!isNonNullish(value)) {
+      return;
     }
+
+    expectType<typeof value, string>('<=');
+
+    expect(value).toHaveLength(4);
   });
 
   test('should work with array filtering', () => {
@@ -588,12 +612,14 @@ describe(isNonNullish, () => {
 
     const value: ComplexType = 42;
 
-    if (isNonNullish(value)) {
-      expectType<typeof value, string | number | boolean>('<=');
-
-      // Value is guaranteed to be non-nullish in this branch
-      expect(true).toBe(true);
+    if (!isNonNullish(value)) {
+      return;
     }
+
+    expectType<typeof value, string | number | boolean>('<=');
+
+    // Value is guaranteed to be non-nullish in this branch
+    expect(true).toBe(true);
   });
 });
 
@@ -601,11 +627,13 @@ describe('type guard behavior in complex scenarios', () => {
   test('should work with nested conditions', () => {
     const value: string | number | boolean | null | undefined = 'test';
 
-    if (isNonNullish(value) && isNotBoolean(value) && isNotNumber(value)) {
-      expectType<typeof value, string>('<=');
-
-      expectTypeOf(value).toBeString();
+    if (!(isNonNullish(value) && isNotBoolean(value) && isNotNumber(value))) {
+      return;
     }
+
+    expectType<typeof value, string>('<=');
+
+    expectTypeOf(value).toBeString();
   });
 
   test('should work with array operations', () => {

package/src/iterator/range.mts

@@ -1,9 +1,4 @@
-import {
-  type NonZeroSafeInt,
-  type PositiveSafeInt,
-  type SafeUint,
-  type WithSmallInt,
-} from 'ts-type-forge';
+import type { NonZeroSafeInt, SafeUint, WithSmallInt } from 'ts-type-forge';
 import { SafeInt, asSafeInt } from '../number/index.mjs';
 
 /**
@@ -18,8 +13,9 @@ import { SafeInt, asSafeInt } from '../number/index.mjs';
  *
  * The function has two overloaded signatures:
  *
- * 1. For non-negative ranges: accepts SafeUint parameters and optional positive
- *    step
+ * 1. For non-negative ranges: accepts SafeUint parameters and an optional
+ *    non-zero step. Every value lies between `start` and `end`, so a negative
+ *    step still yields only non-negative numbers
  * 2. For general ranges: accepts SafeInt parameters and optional non-zero step
  *
  * **Generator Behavior:**
@@ -75,7 +71,7 @@ export function range(
   start: WithSmallInt<SafeUint, MaxInt>,
   end: WithSmallInt<SafeUint, MaxInt>,
   // eslint-disable-next-line @typescript-eslint/unified-signatures
-  step?: WithSmallInt<PositiveSafeInt, MaxInt>,
+  step?: WithSmallInt<NonZeroSafeInt, MaxInt>,
 ): Generator<SafeUint, void, unknown>;
 
 export function range(

package/src/iterator/range.test.mts

@@ -1,3 +1,6 @@
+import type { SafeInt, SafeUint } from 'ts-type-forge';
+import { expectType } from '../expect-type.mjs';
+import { asNonZeroSafeInt, asSafeUint } from '../number/index.mjs';
 import { range } from './range.mjs';
 
 describe(range, () => {
@@ -49,4 +52,30 @@ describe(range, () => {
   test('range(1, 12, 2)', () => {
     assert.deepStrictEqual(Array.from(range(1, 12, 2)), [1, 3, 5, 7, 9, 11]);
   });
+
+  // A negative step from non-negative bounds only counts down to `end`, so
+  // every value stays non-negative.
+  test('a negative step from non-negative bounds yields SafeUint', () => {
+    const xs = Array.from(range(asSafeUint(3), asSafeUint(0), -1));
+
+    expectType<(typeof xs)[number], SafeUint>('=');
+
+    assert.deepStrictEqual(xs, [3, 2, 1]);
+
+    const ys = Array.from(
+      range(asSafeUint(3), asSafeUint(0), asNonZeroSafeInt(-2)),
+    );
+
+    expectType<(typeof ys)[number], SafeUint>('=');
+
+    assert.deepStrictEqual(ys, [3, 1]);
+  });
+
+  test('a negative bound still yields SafeInt', () => {
+    const xs = Array.from(range(0, -2, -1));
+
+    expectType<(typeof xs)[number], SafeInt>('=');
+
+    assert.deepStrictEqual(xs, [0, -1]);
+  });
 });