ts-data-forge 10.0.0 → 11.0.1

package/dist/guard/is-length-bounded-string.d.mts

@@ -1,163 +0,0 @@
-import { type BoundedLengthString, type FixedLengthString, type MaxLengthString, type MinLengthString, type SupportedLength } from 'ts-type-forge';
-/**
- * Type guard that checks if a string has at least `minLength` characters.
- *
- * The length is measured in UTF-16 code units (the same unit as
- * `String.prototype.length`), so characters outside the Basic Multilingual
- * Plane (e.g. emoji) count as 2.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input to `MinLengthString<MinLength>` while preserving the
- *   original string type (e.g. literal types) via intersection.
- * - The result participates in the length-constraint subtyping relation: for
- *   example, a value narrowed to `MinLengthString<3>` is assignable to
- *   `MinLengthString<1>` (= `NonEmptyString`).
- *
- * @example
- *
- * ```ts
- * const input: string = 'very-secret-password';
- *
- * assert.isTrue(isMinLengthString(input, 12));
- *
- * assert.isFalse(isMinLengthString('short', 12));
- *
- * if (isMinLengthString(input, 12)) {
- *   const password: MinLengthString<12> = input;
- *
- *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)
- * }
- * ```
- *
- * @template S - The input string type (literal types are preserved).
- * @template MinLength - The minimum number of characters (inclusive).
- * @param s - The string to check.
- * @param minLength - The minimum number of characters (inclusive).
- * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,
- *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.
- */
-export declare const isMinLengthString: <S extends string, MinLength extends SupportedLength>(s: S, minLength: MinLength) => s is MinLengthString<MinLength> & S;
-/**
- * Type guard that checks if a string has at most `maxLength` characters.
- *
- * The length is measured in UTF-16 code units (the same unit as
- * `String.prototype.length`), so characters outside the Basic Multilingual
- * Plane (e.g. emoji) count as 2.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input to `MaxLengthString<MaxLength>` while preserving the
- *   original string type (e.g. literal types) via intersection.
- * - The result participates in the length-constraint subtyping relation: for
- *   example, a value narrowed to `MaxLengthString<16>` is assignable to
- *   `MaxLengthString<32>`.
- *
- * @example
- *
- * ```ts
- * const input: string = 'noshiro';
- *
- * assert.isTrue(isMaxLengthString(input, 32));
- *
- * assert.isFalse(isMaxLengthString(input, 3));
- *
- * if (isMaxLengthString(input, 32)) {
- *   const userName: MaxLengthString<32> = input;
- *
- *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)
- * }
- * ```
- *
- * @template S - The input string type (literal types are preserved).
- * @template MaxLength - The maximum number of characters (inclusive).
- * @param s - The string to check.
- * @param maxLength - The maximum number of characters (inclusive).
- * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,
- *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.
- */
-export declare const isMaxLengthString: <S extends string, MaxLength extends SupportedLength>(s: S, maxLength: MaxLength) => s is MaxLengthString<MaxLength> & S;
-/**
- * Type guard that checks if a string's length is within the inclusive range
- * `[minLength, maxLength]`.
- *
- * The length is measured in UTF-16 code units (the same unit as
- * `String.prototype.length`), so characters outside the Basic Multilingual
- * Plane (e.g. emoji) count as 2.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input to `BoundedLengthString<MinLength, MaxLength>` while
- *   preserving the original string type (e.g. literal types) via intersection.
- * - Since `BoundedLengthString` is the intersection of `MinLengthString` and
- *   `MaxLengthString`, the narrowed value is assignable to both, and both
- *   bounds can be weakened independently.
- *
- * @example
- *
- * ```ts
- * const input: string = 'user-12345678';
- *
- * assert.isTrue(isBoundedLengthString(input, 8, 16));
- *
- * assert.isFalse(isBoundedLengthString('user', 8, 16));
- *
- * if (isBoundedLengthString(input, 8, 16)) {
- *   const userId: BoundedLengthString<8, 16> = input;
- *
- *   const relaxed: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])
- * }
- * ```
- *
- * @template S - The input string type (literal types are preserved).
- * @template MinLength - The minimum number of characters (inclusive).
- * @template MaxLength - The maximum number of characters (inclusive).
- * @param s - The string to check.
- * @param minLength - The minimum number of characters (inclusive).
- * @param maxLength - The maximum number of characters (inclusive).
- * @returns `true` if `minLength <= s.length && s.length <= maxLength`, `false`
- *   otherwise. When `true`, TypeScript narrows `s` to
- *   `BoundedLengthString<MinLength, MaxLength> & S`.
- */
-export declare const isBoundedLengthString: <S extends string, MinLength extends SupportedLength, MaxLength extends SupportedLength>(s: S, minLength: MinLength, maxLength: MaxLength) => s is BoundedLengthString<MinLength, MaxLength> & S;
-/**
- * Type guard that checks if a string has exactly `length` characters.
- *
- * The length is measured in UTF-16 code units (the same unit as
- * `String.prototype.length`), so characters outside the Basic Multilingual
- * Plane (e.g. emoji) count as 2.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input to `FixedLengthString<Length>` while preserving the
- *   original string type (e.g. literal types) via intersection.
- * - Since `FixedLengthString<Length>` is defined as
- *   `BoundedLengthString<Length, Length>`, the narrowed value is assignable to
- *   any `MinLengthString<N>` with `N <= Length` and any `MaxLengthString<N>`
- *   with `N >= Length`.
- *
- * @example
- *
- * ```ts
- * const input: string = 'JP';
- *
- * assert.isTrue(isFixedLengthString(input, 2));
- *
- * assert.isFalse(isFixedLengthString(input, 3));
- *
- * if (isFixedLengthString(input, 2)) {
- *   const countryCode: FixedLengthString<2> = input;
- *
- *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)
- * }
- * ```
- *
- * @template S - The input string type (literal types are preserved).
- * @template Length - The exact number of characters.
- * @param s - The string to check.
- * @param length - The exact number of characters.
- * @returns `true` if `s.length === length`, `false` otherwise. When `true`,
- *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.
- */
-export declare const isFixedLengthString: <S extends string, Length extends SupportedLength>(s: S, length: Length) => s is FixedLengthString<Length> & S;
-//# sourceMappingURL=is-length-bounded-string.d.mts.map

package/dist/guard/is-length-bounded-string.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-length-bounded-string.d.mts","sourceRoot":"","sources":["../../src/guard/is-length-bounded-string.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,KACnB,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAA0B,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,KACnB,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAA0B,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,qBAAqB,GAChC,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,EACjC,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,aACT,SAAS,KACnB,CAAC,IAAI,mBAAmB,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,CACJ,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,mBAAmB,GAC9B,CAAC,SAAS,MAAM,EAChB,MAAM,SAAS,eAAe,KAE3B,CAAC,UACI,MAAM,KACb,CAAC,IAAI,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAwB,CAAC"}

package/dist/guard/is-length-bounded-string.mjs

@@ -1,7 +0,0 @@
-const isMinLengthString = (s, minLength) => s.length >= minLength;
-const isMaxLengthString = (s, maxLength) => s.length <= maxLength;
-const isBoundedLengthString = (s, minLength, maxLength) => s.length >= minLength && s.length <= maxLength;
-const isFixedLengthString = (s, length) => s.length === length;
-
-export { isBoundedLengthString, isFixedLengthString, isMaxLengthString, isMinLengthString };
-//# sourceMappingURL=is-length-bounded-string.mjs.map

package/dist/guard/is-length-bounded-string.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-length-bounded-string.mjs","sources":["../../src/guard/is-length-bounded-string.mts"],"sourcesContent":["import {\n  type BoundedLengthString,\n  type FixedLengthString,\n  type MaxLengthString,\n  type MinLengthString,\n  type SupportedLength,\n} from 'ts-type-forge';\n\n/**\n * Type guard that checks if a string has at least `minLength` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MinLengthString<MinLength>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MinLengthString<3>` is assignable to\n *   `MinLengthString<1>` (= `NonEmptyString`).\n *\n * @example\n *\n * ```ts\n * const input: string = 'very-secret-password';\n *\n * assert.isTrue(isMinLengthString(input, 12));\n *\n * assert.isFalse(isMinLengthString('short', 12));\n *\n * if (isMinLengthString(input, 12)) {\n *   const password: MinLengthString<12> = input;\n *\n *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MinLength - The minimum number of characters (inclusive).\n * @param s - The string to check.\n * @param minLength - The minimum number of characters (inclusive).\n * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.\n */\nexport const isMinLengthString = <\n  S extends string,\n  MinLength extends SupportedLength,\n>(\n  s: S,\n  minLength: MinLength,\n): s is MinLengthString<MinLength> & S => s.length >= minLength;\n\n/**\n * Type guard that checks if a string has at most `maxLength` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MaxLengthString<MaxLength>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MaxLengthString<16>` is assignable to\n *   `MaxLengthString<32>`.\n *\n * @example\n *\n * ```ts\n * const input: string = 'noshiro';\n *\n * assert.isTrue(isMaxLengthString(input, 32));\n *\n * assert.isFalse(isMaxLengthString(input, 3));\n *\n * if (isMaxLengthString(input, 32)) {\n *   const userName: MaxLengthString<32> = input;\n *\n *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MaxLength - The maximum number of characters (inclusive).\n * @param s - The string to check.\n * @param maxLength - The maximum number of characters (inclusive).\n * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.\n */\nexport const isMaxLengthString = <\n  S extends string,\n  MaxLength extends SupportedLength,\n>(\n  s: S,\n  maxLength: MaxLength,\n): s is MaxLengthString<MaxLength> & S => s.length <= maxLength;\n\n/**\n * Type guard that checks if a string's length is within the inclusive range\n * `[minLength, maxLength]`.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `BoundedLengthString<MinLength, MaxLength>` while\n *   preserving the original string type (e.g. literal types) via intersection.\n * - Since `BoundedLengthString` is the intersection of `MinLengthString` and\n *   `MaxLengthString`, the narrowed value is assignable to both, and both\n *   bounds can be weakened independently.\n *\n * @example\n *\n * ```ts\n * const input: string = 'user-12345678';\n *\n * assert.isTrue(isBoundedLengthString(input, 8, 16));\n *\n * assert.isFalse(isBoundedLengthString('user', 8, 16));\n *\n * if (isBoundedLengthString(input, 8, 16)) {\n *   const userId: BoundedLengthString<8, 16> = input;\n *\n *   const relaxed: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template MinLength - The minimum number of characters (inclusive).\n * @template MaxLength - The maximum number of characters (inclusive).\n * @param s - The string to check.\n * @param minLength - The minimum number of characters (inclusive).\n * @param maxLength - The maximum number of characters (inclusive).\n * @returns `true` if `minLength <= s.length && s.length <= maxLength`, `false`\n *   otherwise. When `true`, TypeScript narrows `s` to\n *   `BoundedLengthString<MinLength, MaxLength> & S`.\n */\nexport const isBoundedLengthString = <\n  S extends string,\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n>(\n  s: S,\n  minLength: MinLength,\n  maxLength: MaxLength,\n): s is BoundedLengthString<MinLength, MaxLength> & S =>\n  s.length >= minLength && s.length <= maxLength;\n\n/**\n * Type guard that checks if a string has exactly `length` characters.\n *\n * The length is measured in UTF-16 code units (the same unit as\n * `String.prototype.length`), so characters outside the Basic Multilingual\n * Plane (e.g. emoji) count as 2.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `FixedLengthString<Length>` while preserving the\n *   original string type (e.g. literal types) via intersection.\n * - Since `FixedLengthString<Length>` is defined as\n *   `BoundedLengthString<Length, Length>`, the narrowed value is assignable to\n *   any `MinLengthString<N>` with `N <= Length` and any `MaxLengthString<N>`\n *   with `N >= Length`.\n *\n * @example\n *\n * ```ts\n * const input: string = 'JP';\n *\n * assert.isTrue(isFixedLengthString(input, 2));\n *\n * assert.isFalse(isFixedLengthString(input, 3));\n *\n * if (isFixedLengthString(input, 2)) {\n *   const countryCode: FixedLengthString<2> = input;\n *\n *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)\n * }\n * ```\n *\n * @template S - The input string type (literal types are preserved).\n * @template Length - The exact number of characters.\n * @param s - The string to check.\n * @param length - The exact number of characters.\n * @returns `true` if `s.length === length`, `false` otherwise. When `true`,\n *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.\n */\nexport const isFixedLengthString = <\n  S extends string,\n  Length extends SupportedLength,\n>(\n  s: S,\n  length: Length,\n): s is FixedLengthString<Length> & S => s.length === length;\n"],"names":[],"mappings":"AA8CO,MAAM,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACwC,EAAE,MAAA,IAAU;AAwC/C,MAAM,iBAAA,GAAoB,CAI/B,CAAA,EACA,SAAA,KACwC,EAAE,MAAA,IAAU;AA4C/C,MAAM,qBAAA,GAAwB,CAKnC,CAAA,EACA,SAAA,EACA,cAEA,CAAA,CAAE,MAAA,IAAU,SAAA,IAAa,CAAA,CAAE,MAAA,IAAU;AAyChC,MAAM,mBAAA,GAAsB,CAIjC,CAAA,EACA,MAAA,KACuC,EAAE,MAAA,KAAW;;;;"}

package/src/guard/is-length-bounded-string.mts

@@ -1,199 +0,0 @@
-import {
-  type BoundedLengthString,
-  type FixedLengthString,
-  type MaxLengthString,
-  type MinLengthString,
-  type SupportedLength,
-} from 'ts-type-forge';
-
-/**
- * Type guard that checks if a string has at least `minLength` characters.
- *
- * The length is measured in UTF-16 code units (the same unit as
- * `String.prototype.length`), so characters outside the Basic Multilingual
- * Plane (e.g. emoji) count as 2.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input to `MinLengthString<MinLength>` while preserving the
- *   original string type (e.g. literal types) via intersection.
- * - The result participates in the length-constraint subtyping relation: for
- *   example, a value narrowed to `MinLengthString<3>` is assignable to
- *   `MinLengthString<1>` (= `NonEmptyString`).
- *
- * @example
- *
- * ```ts
- * const input: string = 'very-secret-password';
- *
- * assert.isTrue(isMinLengthString(input, 12));
- *
- * assert.isFalse(isMinLengthString('short', 12));
- *
- * if (isMinLengthString(input, 12)) {
- *   const password: MinLengthString<12> = input;
- *
- *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)
- * }
- * ```
- *
- * @template S - The input string type (literal types are preserved).
- * @template MinLength - The minimum number of characters (inclusive).
- * @param s - The string to check.
- * @param minLength - The minimum number of characters (inclusive).
- * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,
- *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.
- */
-export const isMinLengthString = <
-  S extends string,
-  MinLength extends SupportedLength,
->(
-  s: S,
-  minLength: MinLength,
-): s is MinLengthString<MinLength> & S => s.length >= minLength;
-
-/**
- * Type guard that checks if a string has at most `maxLength` characters.
- *
- * The length is measured in UTF-16 code units (the same unit as
- * `String.prototype.length`), so characters outside the Basic Multilingual
- * Plane (e.g. emoji) count as 2.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input to `MaxLengthString<MaxLength>` while preserving the
- *   original string type (e.g. literal types) via intersection.
- * - The result participates in the length-constraint subtyping relation: for
- *   example, a value narrowed to `MaxLengthString<16>` is assignable to
- *   `MaxLengthString<32>`.
- *
- * @example
- *
- * ```ts
- * const input: string = 'noshiro';
- *
- * assert.isTrue(isMaxLengthString(input, 32));
- *
- * assert.isFalse(isMaxLengthString(input, 3));
- *
- * if (isMaxLengthString(input, 32)) {
- *   const userName: MaxLengthString<32> = input;
- *
- *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)
- * }
- * ```
- *
- * @template S - The input string type (literal types are preserved).
- * @template MaxLength - The maximum number of characters (inclusive).
- * @param s - The string to check.
- * @param maxLength - The maximum number of characters (inclusive).
- * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,
- *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.
- */
-export const isMaxLengthString = <
-  S extends string,
-  MaxLength extends SupportedLength,
->(
-  s: S,
-  maxLength: MaxLength,
-): s is MaxLengthString<MaxLength> & S => s.length <= maxLength;
-
-/**
- * Type guard that checks if a string's length is within the inclusive range
- * `[minLength, maxLength]`.
- *
- * The length is measured in UTF-16 code units (the same unit as
- * `String.prototype.length`), so characters outside the Basic Multilingual
- * Plane (e.g. emoji) count as 2.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input to `BoundedLengthString<MinLength, MaxLength>` while
- *   preserving the original string type (e.g. literal types) via intersection.
- * - Since `BoundedLengthString` is the intersection of `MinLengthString` and
- *   `MaxLengthString`, the narrowed value is assignable to both, and both
- *   bounds can be weakened independently.
- *
- * @example
- *
- * ```ts
- * const input: string = 'user-12345678';
- *
- * assert.isTrue(isBoundedLengthString(input, 8, 16));
- *
- * assert.isFalse(isBoundedLengthString('user', 8, 16));
- *
- * if (isBoundedLengthString(input, 8, 16)) {
- *   const userId: BoundedLengthString<8, 16> = input;
- *
- *   const relaxed: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])
- * }
- * ```
- *
- * @template S - The input string type (literal types are preserved).
- * @template MinLength - The minimum number of characters (inclusive).
- * @template MaxLength - The maximum number of characters (inclusive).
- * @param s - The string to check.
- * @param minLength - The minimum number of characters (inclusive).
- * @param maxLength - The maximum number of characters (inclusive).
- * @returns `true` if `minLength <= s.length && s.length <= maxLength`, `false`
- *   otherwise. When `true`, TypeScript narrows `s` to
- *   `BoundedLengthString<MinLength, MaxLength> & S`.
- */
-export const isBoundedLengthString = <
-  S extends string,
-  MinLength extends SupportedLength,
-  MaxLength extends SupportedLength,
->(
-  s: S,
-  minLength: MinLength,
-  maxLength: MaxLength,
-): s is BoundedLengthString<MinLength, MaxLength> & S =>
-  s.length >= minLength && s.length <= maxLength;
-
-/**
- * Type guard that checks if a string has exactly `length` characters.
- *
- * The length is measured in UTF-16 code units (the same unit as
- * `String.prototype.length`), so characters outside the Basic Multilingual
- * Plane (e.g. emoji) count as 2.
- *
- * **Type Narrowing Behavior:**
- *
- * - Narrows the input to `FixedLengthString<Length>` while preserving the
- *   original string type (e.g. literal types) via intersection.
- * - Since `FixedLengthString<Length>` is defined as
- *   `BoundedLengthString<Length, Length>`, the narrowed value is assignable to
- *   any `MinLengthString<N>` with `N <= Length` and any `MaxLengthString<N>`
- *   with `N >= Length`.
- *
- * @example
- *
- * ```ts
- * const input: string = 'JP';
- *
- * assert.isTrue(isFixedLengthString(input, 2));
- *
- * assert.isFalse(isFixedLengthString(input, 3));
- *
- * if (isFixedLengthString(input, 2)) {
- *   const countryCode: FixedLengthString<2> = input;
- *
- *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)
- * }
- * ```
- *
- * @template S - The input string type (literal types are preserved).
- * @template Length - The exact number of characters.
- * @param s - The string to check.
- * @param length - The exact number of characters.
- * @returns `true` if `s.length === length`, `false` otherwise. When `true`,
- *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.
- */
-export const isFixedLengthString = <
-  S extends string,
-  Length extends SupportedLength,
->(
-  s: S,
-  length: Length,
-): s is FixedLengthString<Length> & S => s.length === length;

package/src/guard/is-length-bounded-string.test.mts

@@ -1,170 +0,0 @@
-import {
-  type BoundedLengthString,
-  type FixedLengthString,
-  type MaxLengthString,
-  type MinLengthString,
-  type NonEmptyString,
-} from 'ts-type-forge';
-import { expectType } from '../expect-type.mjs';
-import {
-  isBoundedLengthString,
-  isFixedLengthString,
-  isMaxLengthString,
-  isMinLengthString,
-} from './is-length-bounded-string.mjs';
-
-describe(isMinLengthString, () => {
-  test('should return true when the string is long enough', () => {
-    assert.isTrue(isMinLengthString('hello', 3));
-
-    assert.isTrue(isMinLengthString('hello', 5));
-
-    assert.isTrue(isMinLengthString('', 0));
-
-    assert.isTrue(isMinLengthString(' ', 1)); // Space counts
-  });
-
-  test('should return false when the string is too short', () => {
-    assert.isFalse(isMinLengthString('hi', 3));
-
-    assert.isFalse(isMinLengthString('', 1));
-  });
-
-  test('should measure length in UTF-16 code units', () => {
-    assert.isTrue(isMinLengthString('🎉', 2)); // Surrogate pair
-
-    assert.isFalse(isMinLengthString('🎉', 3));
-  });
-
-  test('should act as a type guard', () => {
-    const value: string = 'very-secret-password';
-
-    if (isMinLengthString(value, 12)) {
-      expectType<typeof value, MinLengthString<12>>('<=');
-
-      expectType<typeof value, NonEmptyString>('<='); // 12 >= 1
-
-      expectType<typeof value, MinLengthString<16>>('!<=');
-
-      expect(value.length).toBeGreaterThanOrEqual(12);
-    }
-  });
-
-  test('should preserve literal string types', () => {
-    const literal = 'hello';
-
-    if (isMinLengthString(literal, 3)) {
-      expectType<typeof literal, 'hello'>('<=');
-
-      expectType<typeof literal, MinLengthString<3>>('<=');
-    }
-  });
-});
-
-describe(isMaxLengthString, () => {
-  test('should return true when the string is short enough', () => {
-    assert.isTrue(isMaxLengthString('hello', 10));
-
-    assert.isTrue(isMaxLengthString('hello', 5));
-
-    assert.isTrue(isMaxLengthString('', 0));
-  });
-
-  test('should return false when the string is too long', () => {
-    assert.isFalse(isMaxLengthString('hello', 3));
-
-    assert.isFalse(isMaxLengthString(' ', 0));
-  });
-
-  test('should measure length in UTF-16 code units', () => {
-    assert.isFalse(isMaxLengthString('🎉', 1)); // Surrogate pair
-
-    assert.isTrue(isMaxLengthString('🎉', 2));
-  });
-
-  test('should act as a type guard', () => {
-    const value: string = 'noshiro';
-
-    if (isMaxLengthString(value, 32)) {
-      expectType<typeof value, MaxLengthString<32>>('<=');
-
-      expectType<typeof value, MaxLengthString<64>>('<='); // 32 <= 64
-
-      expectType<typeof value, MaxLengthString<16>>('!<=');
-
-      expect(value.length).toBeLessThanOrEqual(32);
-    }
-  });
-});
-
-describe(isBoundedLengthString, () => {
-  test('should return true when the length is within the range', () => {
-    assert.isTrue(isBoundedLengthString('user-12345678', 8, 16));
-
-    assert.isTrue(isBoundedLengthString('12345678', 8, 16)); // Lower bound (inclusive)
-
-    assert.isTrue(isBoundedLengthString('1234567890123456', 8, 16)); // Upper bound (inclusive)
-
-    assert.isTrue(isBoundedLengthString('', 0, 0));
-  });
-
-  test('should return false when the length is out of range', () => {
-    assert.isFalse(isBoundedLengthString('user', 8, 16));
-
-    assert.isFalse(isBoundedLengthString('12345678901234567', 8, 16));
-  });
-
-  test('should act as a type guard', () => {
-    const value: string = 'user-12345678';
-
-    if (isBoundedLengthString(value, 8, 16)) {
-      expectType<typeof value, BoundedLengthString<8, 16>>('<=');
-
-      expectType<typeof value, BoundedLengthString<1, 255>>('<='); // [8, 16] ⊆ [1, 255]
-
-      expectType<typeof value, MinLengthString<8>>('<=');
-
-      expectType<typeof value, MaxLengthString<16>>('<=');
-
-      expectType<typeof value, NonEmptyString>('<='); // 8 >= 1
-
-      expectType<typeof value, BoundedLengthString<10, 16>>('!<=');
-    }
-  });
-});
-
-describe(isFixedLengthString, () => {
-  test('should return true only for the exact length', () => {
-    assert.isTrue(isFixedLengthString('JP', 2));
-
-    assert.isTrue(isFixedLengthString('', 0));
-
-    assert.isFalse(isFixedLengthString('JPN', 2));
-
-    assert.isFalse(isFixedLengthString('J', 2));
-  });
-
-  test('should measure length in UTF-16 code units', () => {
-    assert.isTrue(isFixedLengthString('🎉', 2)); // Surrogate pair
-
-    assert.isFalse(isFixedLengthString('🎉', 1));
-  });
-
-  test('should act as a type guard', () => {
-    const value: string = 'JP';
-
-    if (isFixedLengthString(value, 2)) {
-      expectType<typeof value, FixedLengthString<2>>('<=');
-
-      expectType<typeof value, BoundedLengthString<2, 2>>('<=');
-
-      expectType<typeof value, MaxLengthString<5>>('<='); // 2 <= 5
-
-      expectType<typeof value, MinLengthString<1>>('<='); // 2 >= 1
-
-      expectType<typeof value, NonEmptyString>('<=');
-
-      expectType<typeof value, FixedLengthString<3>>('!<=');
-    }
-  });
-});