ts-data-forge 14.7.1 → 14.8.0

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);

package/src/string/str.test.mts

@@ -1,9 +1,9 @@
-import {
-  type BoundedLengthString,
-  type FixedLengthString,
-  type MaxLengthString,
-  type MinLengthString,
-  type NonEmptyString,
+import type {
+  BoundedLengthString,
+  FixedLengthString,
+  MaxLengthString,
+  MinLengthString,
+  NonEmptyString,
 } from 'ts-type-forge';
 import { expectType } from '../expect-type.mjs';
 import { Str } from './str.mjs';
@@ -34,25 +34,29 @@ describe(Str.isMinLengthString, () => {
   test('should act as a type guard', () => {
     const value: string = 'very-secret-password';
 
-    if (Str.isMinLengthString(12, value)) {
-      expectType<typeof value, MinLengthString<12>>('<=');
+    if (!Str.isMinLengthString(12, value)) {
+      return;
+    }
 
-      expectType<typeof value, NonEmptyString>('<='); // 12 >= 1
+    expectType<typeof value, MinLengthString<12>>('<=');
 
-      expectType<typeof value, MinLengthString<16>>('!<=');
+    expectType<typeof value, NonEmptyString>('<='); // 12 >= 1
 
-      expect(value.length).toBeGreaterThanOrEqual(12);
-    }
+    expectType<typeof value, MinLengthString<16>>('!<=');
+
+    expect(value.length).toBeGreaterThanOrEqual(12);
   });
 
   test('should preserve literal string types', () => {
     const literal = 'hello';
 
-    if (Str.isMinLengthString(3, literal)) {
-      expectType<typeof literal, 'hello'>('<=');
-
-      expectType<typeof literal, MinLengthString<3>>('<=');
+    if (!Str.isMinLengthString(3, literal)) {
+      return;
     }
+
+    expectType<typeof literal, 'hello'>('<=');
+
+    expectType<typeof literal, MinLengthString<3>>('<=');
   });
 });
 
@@ -80,15 +84,17 @@ describe(Str.isMaxLengthString, () => {
   test('should act as a type guard', () => {
     const value: string = 'noshiro';
 
-    if (Str.isMaxLengthString(32, value)) {
-      expectType<typeof value, MaxLengthString<32>>('<=');
+    if (!Str.isMaxLengthString(32, value)) {
+      return;
+    }
 
-      expectType<typeof value, MaxLengthString<64>>('<='); // 32 <= 64
+    expectType<typeof value, MaxLengthString<32>>('<=');
 
-      expectType<typeof value, MaxLengthString<16>>('!<=');
+    expectType<typeof value, MaxLengthString<64>>('<='); // 32 <= 64
 
-      expect(value.length).toBeLessThanOrEqual(32);
-    }
+    expectType<typeof value, MaxLengthString<16>>('!<=');
+
+    expect(value.length).toBeLessThanOrEqual(32);
   });
 });
 
@@ -112,19 +118,21 @@ describe(Str.isBoundedLengthString, () => {
   test('should act as a type guard', () => {
     const value: string = 'user-12345678';
 
-    if (Str.isBoundedLengthString(8, 16, value)) {
-      expectType<typeof value, BoundedLengthString<8, 16>>('<=');
+    if (!Str.isBoundedLengthString(8, 16, value)) {
+      return;
+    }
+
+    expectType<typeof value, BoundedLengthString<8, 16>>('<=');
 
-      expectType<typeof value, BoundedLengthString<1, 255>>('<='); // [8, 16] ⊆ [1, 255]
+    expectType<typeof value, BoundedLengthString<1, 255>>('<='); // [8, 16] ⊆ [1, 255]
 
-      expectType<typeof value, MinLengthString<8>>('<=');
+    expectType<typeof value, MinLengthString<8>>('<=');
 
-      expectType<typeof value, MaxLengthString<16>>('<=');
+    expectType<typeof value, MaxLengthString<16>>('<=');
 
-      expectType<typeof value, NonEmptyString>('<='); // 8 >= 1
+    expectType<typeof value, NonEmptyString>('<='); // 8 >= 1
 
-      expectType<typeof value, BoundedLengthString<10, 16>>('!<=');
-    }
+    expectType<typeof value, BoundedLengthString<10, 16>>('!<=');
   });
 });
 
@@ -148,19 +156,21 @@ describe(Str.isFixedLengthString, () => {
   test('should act as a type guard', () => {
     const value: string = 'JP';
 
-    if (Str.isFixedLengthString(2, value)) {
-      expectType<typeof value, FixedLengthString<2>>('<=');
+    if (!Str.isFixedLengthString(2, value)) {
+      return;
+    }
 
-      expectType<typeof value, BoundedLengthString<2, 2>>('<=');
+    expectType<typeof value, FixedLengthString<2>>('<=');
 
-      expectType<typeof value, MaxLengthString<5>>('<='); // 2 <= 5
+    expectType<typeof value, BoundedLengthString<2, 2>>('<=');
 
-      expectType<typeof value, MinLengthString<1>>('<='); // 2 >= 1
+    expectType<typeof value, MaxLengthString<5>>('<='); // 2 <= 5
 
-      expectType<typeof value, NonEmptyString>('<=');
+    expectType<typeof value, MinLengthString<1>>('<='); // 2 >= 1
 
-      expectType<typeof value, FixedLengthString<3>>('!<=');
-    }
+    expectType<typeof value, NonEmptyString>('<=');
+
+    expectType<typeof value, FixedLengthString<3>>('!<=');
   });
 });
 

package/src/types.mts

@@ -1,17 +1,17 @@
-import {
-  type IndexOfTuple,
-  type IntersectBrand,
-  type IsFixedLengthList,
-  type NegativeIndexOfTuple,
-  type NegativeInt32,
-  type NormalizeBrandUnion,
-  type PositiveInt,
-  type PositiveNumber,
-  type Primitive,
-  type SafeInt,
-  type SafeUint,
-  type Uint32,
-  type WithSmallInt,
+import type {
+  IndexOfTuple,
+  IntersectBrand,
+  IsFixedLengthList,
+  NegativeIndexOfTuple,
+  NegativeInt32,
+  NormalizeBrandUnion,
+  PositiveInt,
+  PositiveNumber,
+  Primitive,
+  SafeInt,
+  SafeUint,
+  Uint32,
+  WithSmallInt,
 } from 'ts-type-forge';
 
 export type SmallPositiveInt = WithSmallInt<PositiveInt>;