ts-data-forge 14.6.2 → 14.6.3

package/dist/string/str.mjs

@@ -1,158 +1,158 @@
-/**
- * Namespace providing type guards and runtime-checked casts for the branded
- * length-constrained string types (`MinLengthString`, `MaxLengthString`,
- * `BoundedLengthString`, `FixedLengthString`).
- *
- * Lengths are 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.
- */
+
+
+
+
+
+
+
+
+
 export var Str;
 (function (Str) {
-    /**
-     * Type guard that checks if a string has at least `minLength` characters.
-     *
-     * **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(Str.isMinLengthString(12, input));
-     *
-     * assert.isFalse(Str.isMinLengthString(12, 'short'));
-     *
-     * if (Str.isMinLengthString(12, input)) {
-     *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)
-     *
-     *   assert.isTrue(nonEmpty.length >= 12);
-     * }
-     * ```
-     *
-     * @template MinLength - The minimum number of characters (inclusive).
-     * @template S - The input string type (literal types are preserved).
-     * @param minLength - The minimum number of characters (inclusive).
-     * @param s - The string to check.
-     * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,
-     *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.
-     */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     Str.isMinLengthString = (minLength, s) => s.length >= minLength;
-    /**
-     * Type guard that checks if a string has at most `maxLength` characters.
-     *
-     * **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(Str.isMaxLengthString(32, input));
-     *
-     * assert.isFalse(Str.isMaxLengthString(3, input));
-     *
-     * if (Str.isMaxLengthString(32, input)) {
-     *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)
-     *
-     *   assert.isTrue(relaxed.length <= 32);
-     * }
-     * ```
-     *
-     * @template MaxLength - The maximum number of characters (inclusive).
-     * @template S - The input string type (literal types are preserved).
-     * @param maxLength - The maximum number of characters (inclusive).
-     * @param s - The string to check.
-     * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,
-     *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.
-     */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     Str.isMaxLengthString = (maxLength, s) => s.length <= maxLength;
-    /**
-     * Type guard that checks if a string's length is within the inclusive range
-     * `[minLength, maxLength]`.
-     *
-     * **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(Str.isBoundedLengthString(8, 16, input));
-     *
-     * 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);
-     * }
-     * ```
-     *
-     * @template MinLength - The minimum number of characters (inclusive).
-     * @template MaxLength - The maximum number of characters (inclusive).
-     * @template S - The input string type (literal types are preserved).
-     * @param minLength - The minimum number of characters (inclusive).
-     * @param maxLength - The maximum number of characters (inclusive).
-     * @param s - The string to check.
-     * @returns `true` if `minLength <= s.length && s.length <= maxLength`, `false`
-     *   otherwise. When `true`, TypeScript narrows `s` to
-     *   `BoundedLengthString<MinLength, MaxLength> & S`.
-     */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     Str.isBoundedLengthString = (minLength, maxLength, s) => s.length >= minLength && s.length <= maxLength;
-    /**
-     * Type guard that checks if a string has exactly `length` characters.
-     *
-     * **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(Str.isFixedLengthString(2, input));
-     *
-     * assert.isFalse(Str.isFixedLengthString(3, input));
-     *
-     * if (Str.isFixedLengthString(2, input)) {
-     *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)
-     *
-     *   assert.isTrue(atMost5.length === 2);
-     * }
-     * ```
-     *
-     * @template Length - The exact number of characters.
-     * @template S - The input string type (literal types are preserved).
-     * @param length - The exact number of characters.
-     * @param s - The string to check.
-     * @returns `true` if `s.length === length`, `false` otherwise. When `true`,
-     *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.
-     */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     Str.isFixedLengthString = (length, s) => s.length === length;
     function asMinLengthString(...args) {
         switch (args.length) {
@@ -218,33 +218,33 @@ export var Str;
         }
         return s;
     };
-    /**
-     * Casts a string to `NonEmptyString` after checking that it has at least one
-     * character.
-     *
-     * `NonEmptyString` is an alias of `MinLengthString<1>`, so this is the
-     * length-1 specialization of {@link asMinLengthString}. Use this instead of
-     * writing `s as unknown as NonEmptyString`: the length is verified at
-     * runtime, and the original string type (e.g. literal types) is preserved
-     * via intersection.
-     *
-     * @example
-     *
-     * ```ts
-     * const name = Str.asNonEmptyString('noshiro');
-     *
-     * const nonEmpty: NonEmptyString = name; // OK
-     *
-     * assert.isTrue(nonEmpty.length >= 1);
-     *
-     * assert.throws(() => Str.asNonEmptyString('')); // length 0 < 1
-     * ```
-     *
-     * @template S - The input string type (literal types are preserved).
-     * @param s - The string to cast.
-     * @returns `s` typed as `NonEmptyString & S`.
-     * @throws {TypeError} If `s` is empty.
-     */
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     Str.asNonEmptyString = (s) => {
         if (!Str.isMinLengthString(1, s)) {
             throw new TypeError('Expected a non-empty string, got an empty string');

package/dist/types.mjs

@@ -1,3 +1,3 @@
 export {};
-// #endregion Result
+
 //# sourceMappingURL=types.mjs.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "14.6.2",
+  "version": "14.6.3",
   "private": false,
   "keywords": [
     "typescript",
@@ -42,20 +42,20 @@
   "devDependencies": {
     "@emotion/react": "11.14.0",
     "@emotion/styled": "11.14.1",
-    "@mui/material": "9.3.1",
+    "@mui/material": "9.4.0",
     "@types/react": "19.2.18",
     "@vitest/browser-playwright": "4.1.11",
     "dedent": "1.7.2",
-    "eslint-config-typed": "5.10.5",
-    "eslint-plugin-ts-fortress": "1.1.0",
-    "eslint-plugin-ts-type-forge": "0.8.0",
+    "eslint-config-typed": "5.11.1",
+    "eslint-plugin-ts-fortress": "1.2.0",
+    "eslint-plugin-ts-type-forge": "0.8.1",
     "immer": "11.1.18",
     "playwright": "1.62.1",
     "prettier": "3.9.6",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",
     "react": "19.2.8",
-    "ts-repo-utils": "10.5.0",
+    "ts-repo-utils": "10.6.0",
     "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0",
     "vite": "8.2.2"

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

@@ -124,7 +124,7 @@ describe(isString, () => {
 
     assert.isTrue(isString('123'));
 
-    assert.isTrue(isString(`template`));
+    assert.isTrue(isString('template'));
   });
 
   test('should return false for non-strings', () => {
@@ -408,7 +408,7 @@ describe(isNotString, () => {
 
     assert.isFalse(isNotString('123'));
 
-    assert.isFalse(isNotString(`template`));
+    assert.isFalse(isNotString('template'));
   });
 
   test('should return true for non-string values', () => {

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

@@ -42,7 +42,7 @@ describe('FiniteNumber test', () => {
       { name: 'Number.POSITIVE_INFINITY', value: Number.POSITIVE_INFINITY },
       { name: 'Number.NEGATIVE_INFINITY', value: Number.NEGATIVE_INFINITY },
     ] as const)(
-      `asFiniteNumber($name) should throw a TypeError`,
+      'asFiniteNumber($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asFiniteNumber(value)).toThrow(
           new TypeError(`Expected a finite number, got: ${value}`),

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

@@ -47,7 +47,7 @@ describe('Int test', () => {
       { name: 'Number.NEGATIVE_INFINITY', value: Number.NEGATIVE_INFINITY },
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
-    ] as const)(`asInt($name) should throw a TypeError`, ({ value }) => {
+    ] as const)('asInt($name) should throw a TypeError', ({ value }) => {
       expect(() => asInt(value)).toThrow(
         new TypeError(`Expected an integer, got: ${value}`),
       );

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

@@ -57,7 +57,7 @@ describe('Int16 test', () => {
       { name: 'Number.NEGATIVE_INFINITY', value: Number.NEGATIVE_INFINITY },
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
-    ] as const)(`asInt16($name) should throw a TypeError`, ({ value }) => {
+    ] as const)('asInt16($name) should throw a TypeError', ({ value }) => {
       expect(() => asInt16(value)).toThrow(
         new TypeError(`Expected an integer in [-2^15, 2^15), got: ${value}`),
       );

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

@@ -57,7 +57,7 @@ describe('Int32 test', () => {
       { name: 'Number.NEGATIVE_INFINITY', value: Number.NEGATIVE_INFINITY },
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
-    ] as const)(`asInt32($name) should throw a TypeError`, ({ value }) => {
+    ] as const)('asInt32($name) should throw a TypeError', ({ value }) => {
       expect(() => asInt32(value)).toThrow(
         new TypeError(`Expected an integer in [-2^31, 2^31), got: ${value}`),
       );

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

@@ -56,7 +56,7 @@ describe('NonNegativeFiniteNumber test', () => {
       { name: 'Number.NEGATIVE_INFINITY', value: Number.NEGATIVE_INFINITY },
       { name: '-1.2', value: -1.2 },
     ] as const)(
-      `asNonNegativeFiniteNumber($name) should throw a TypeError`,
+      'asNonNegativeFiniteNumber($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asNonNegativeFiniteNumber(value)).toThrow(
           new TypeError(`Expected a non-negative finite number, got: ${value}`),

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

@@ -66,7 +66,7 @@ describe('NonNegativeInt16 test', () => {
       { name: '-1', value: -1 },
       { name: '32768', value: 32_768 },
     ] as const)(
-      `asNonNegativeInt16($name) should throw a TypeError`,
+      'asNonNegativeInt16($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asNonNegativeInt16(value)).toThrow(
           new TypeError(

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

@@ -66,7 +66,7 @@ describe('NonNegativeInt32 test', () => {
       { name: '-1', value: -1 },
       { name: '2147483648', value: 2_147_483_648 },
     ] as const)(
-      `asNonNegativeInt32($name) should throw a TypeError`,
+      'asNonNegativeInt32($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asNonNegativeInt32(value)).toThrow(
           new TypeError(

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

@@ -58,7 +58,7 @@ describe('NonZeroFiniteNumber test', () => {
       { name: 'Number.NEGATIVE_INFINITY', value: Number.NEGATIVE_INFINITY },
       { name: '0', value: 0 },
     ] as const)(
-      `asNonZeroFiniteNumber($name) should throw a TypeError`,
+      'asNonZeroFiniteNumber($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asNonZeroFiniteNumber(value)).toThrow(
           new TypeError(`Expected a non-zero finite number, got: ${value}`),

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

@@ -51,7 +51,7 @@ describe('NonZeroInt test', () => {
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
       { name: '0', value: 0 },
-    ] as const)(`asNonZeroInt($name) should throw a TypeError`, ({ value }) => {
+    ] as const)('asNonZeroInt($name) should throw a TypeError', ({ value }) => {
       expect(() => asNonZeroInt(value)).toThrow(
         new TypeError(`Expected a non-zero integer, got: ${value}`),
       );

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

@@ -64,7 +64,7 @@ describe('NonZeroInt16 test', () => {
       { name: '32768', value: 32_768 },
       { name: '-32769', value: -32_769 },
     ] as const)(
-      `asNonZeroInt16($name) should throw a TypeError`,
+      'asNonZeroInt16($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asNonZeroInt16(value)).toThrow(
           new TypeError(

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

@@ -64,7 +64,7 @@ describe('NonZeroInt32 test', () => {
       { name: '2147483648', value: 2_147_483_648 },
       { name: '-2147483649', value: -2_147_483_649 },
     ] as const)(
-      `asNonZeroInt32($name) should throw a TypeError`,
+      'asNonZeroInt32($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asNonZeroInt32(value)).toThrow(
           new TypeError(

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

@@ -74,7 +74,7 @@ describe('NonZeroSafeInt test', () => {
       { name: '-3.4', value: -3.4 },
       { name: '0', value: 0 },
     ] as const)(
-      `asNonZeroSafeInt($name) should throw a TypeError`,
+      'asNonZeroSafeInt($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asNonZeroSafeInt(value)).toThrow(
           new TypeError(`Expected a non-zero safe integer, got: ${value}`),

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

@@ -68,7 +68,7 @@ describe('NonZeroUint16 test', () => {
       { name: '-1', value: -1 },
       { name: '65536', value: 65_536 },
     ] as const)(
-      `asNonZeroUint16($name) should throw a TypeError`,
+      'asNonZeroUint16($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asNonZeroUint16(value)).toThrow(
           new TypeError(

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

@@ -68,7 +68,7 @@ describe('NonZeroUint32 test', () => {
       { name: '-1', value: -1 },
       { name: '4294967296', value: 4_294_967_296 },
     ] as const)(
-      `asNonZeroUint32($name) should throw a TypeError`,
+      'asNonZeroUint32($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asNonZeroUint32(value)).toThrow(
           new TypeError(

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

@@ -62,7 +62,7 @@ describe('PositiveFiniteNumber test', () => {
       { name: 'Number.NEGATIVE_INFINITY', value: Number.NEGATIVE_INFINITY },
       { name: '-1.2', value: -1.2 },
     ] as const)(
-      `asPositiveFiniteNumber($name) should throw a TypeError`,
+      'asPositiveFiniteNumber($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asPositiveFiniteNumber(value)).toThrow(
           new TypeError(`Expected a positive finite number, got: ${value}`),

package/src/number/branded-types/positive-int.test.mts

@@ -59,7 +59,7 @@ describe('PositiveInt test', () => {
       { name: '0', value: 0 },
       { name: '-1', value: -1 },
     ] as const)(
-      `asPositiveInt($name) should throw a TypeError`,
+      'asPositiveInt($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asPositiveInt(value)).toThrow(
           new TypeError(`Expected a positive integer, got: ${value}`),

package/src/number/branded-types/positive-int16.test.mts

@@ -66,7 +66,7 @@ describe('PositiveInt16 test', () => {
       { name: '-1', value: -1 },
       { name: '32768', value: 32_768 },
     ] as const)(
-      `asPositiveInt16($name) should throw a TypeError`,
+      'asPositiveInt16($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asPositiveInt16(value)).toThrow(
           new TypeError(

package/src/number/branded-types/positive-int32.test.mts

@@ -66,7 +66,7 @@ describe('PositiveInt32 test', () => {
       { name: '-1', value: -1 },
       { name: '2147483648', value: 2_147_483_648 },
     ] as const)(
-      `asPositiveInt32($name) should throw a TypeError`,
+      'asPositiveInt32($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asPositiveInt32(value)).toThrow(
           new TypeError(

package/src/number/branded-types/positive-safe-int.test.mts

@@ -77,7 +77,7 @@ describe('PositiveSafeInt test', () => {
       { name: '0', value: 0 },
       { name: '-1', value: -1 },
     ] as const)(
-      `asPositiveSafeInt($name) should throw a TypeError`,
+      'asPositiveSafeInt($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asPositiveSafeInt(value)).toThrow(
           new TypeError(`Expected a positive safe integer, got: ${value}`),

package/src/number/branded-types/positive-uint16.test.mts

@@ -68,7 +68,7 @@ describe('PositiveUint16 test', () => {
       { name: '-1', value: -1 },
       { name: '65536', value: 65_536 },
     ] as const)(
-      `asPositiveUint16($name) should throw a TypeError`,
+      'asPositiveUint16($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asPositiveUint16(value)).toThrow(
           new TypeError(

package/src/number/branded-types/positive-uint32.test.mts

@@ -68,7 +68,7 @@ describe('PositiveUint32 test', () => {
       { name: '-1', value: -1 },
       { name: '4294967296', value: 4_294_967_296 },
     ] as const)(
-      `asPositiveUint32($name) should throw a TypeError`,
+      'asPositiveUint32($name) should throw a TypeError',
       ({ value }) => {
         expect(() => asPositiveUint32(value)).toThrow(
           new TypeError(

package/src/number/branded-types/safe-int.test.mts

@@ -60,7 +60,7 @@ describe('SafeInt test', () => {
       { name: 'Number.NEGATIVE_INFINITY', value: Number.NEGATIVE_INFINITY },
       { name: '1.2', value: 1.2 },
       { name: '-3.4', value: -3.4 },
-    ] as const)(`asSafeInt($name) should throw a TypeError`, ({ value }) => {
+    ] as const)('asSafeInt($name) should throw a TypeError', ({ value }) => {
       expect(() => asSafeInt(value)).toThrow(
         new TypeError(`Expected a safe integer, got: ${value}`),
       );