ts-data-forge 14.6.0 → 14.6.2

package/dist/string/str.mjs

@@ -1,88 +1,255 @@
-var Str;
-((Str2) => {
-  Str2.isMinLengthString = (minLength, s) => s.length >= minLength;
-  Str2.isMaxLengthString = (maxLength, s) => s.length <= maxLength;
-  Str2.isBoundedLengthString = (minLength, maxLength, s) => s.length >= minLength && s.length <= maxLength;
-  Str2.isFixedLengthString = (length, s) => s.length === length;
-  function asMinLengthString(...args) {
-    switch (args.length) {
-      case 2:
-        return asMinLengthStringImpl(...args);
-      case 1:
-        return (s) => asMinLengthStringImpl(args[0], s);
+/**
+ * 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) {
+            case 2:
+                return asMinLengthStringImpl(...args);
+            case 1:
+                return (s) => asMinLengthStringImpl(args[0], s);
+        }
     }
-  }
-  Str2.asMinLengthString = asMinLengthString;
-  const asMinLengthStringImpl = (minLength, s) => {
-    const actualLength = s.length;
-    if (!(0, Str2.isMinLengthString)(minLength, s)) {
-      throw new TypeError(
-        `Expected a string of length >= ${minLength}, got a string of length ${actualLength}`
-      );
+    Str.asMinLengthString = asMinLengthString;
+    const asMinLengthStringImpl = (minLength, s) => {
+        const actualLength = s.length;
+        if (!Str.isMinLengthString(minLength, s)) {
+            throw new TypeError(`Expected a string of length >= ${minLength}, got a string of length ${actualLength}`);
+        }
+        return s;
+    };
+    function asMaxLengthString(...args) {
+        switch (args.length) {
+            case 2:
+                return asMaxLengthStringImpl(...args);
+            case 1:
+                return (s) => asMaxLengthStringImpl(args[0], s);
+        }
     }
-    return s;
-  };
-  function asMaxLengthString(...args) {
-    switch (args.length) {
-      case 2:
-        return asMaxLengthStringImpl(...args);
-      case 1:
-        return (s) => asMaxLengthStringImpl(args[0], s);
+    Str.asMaxLengthString = asMaxLengthString;
+    const asMaxLengthStringImpl = (maxLength, s) => {
+        const actualLength = s.length;
+        if (!Str.isMaxLengthString(maxLength, s)) {
+            throw new TypeError(`Expected a string of length <= ${maxLength}, got a string of length ${actualLength}`);
+        }
+        return s;
+    };
+    function asBoundedLengthString(...args) {
+        switch (args.length) {
+            case 3:
+                return asBoundedLengthStringImpl(...args);
+            case 2:
+                return (s) => asBoundedLengthStringImpl(...args, s);
+        }
     }
-  }
-  Str2.asMaxLengthString = asMaxLengthString;
-  const asMaxLengthStringImpl = (maxLength, s) => {
-    const actualLength = s.length;
-    if (!(0, Str2.isMaxLengthString)(maxLength, s)) {
-      throw new TypeError(
-        `Expected a string of length <= ${maxLength}, got a string of length ${actualLength}`
-      );
+    Str.asBoundedLengthString = asBoundedLengthString;
+    const asBoundedLengthStringImpl = (minLength, maxLength, s) => {
+        const actualLength = s.length;
+        if (!Str.isBoundedLengthString(minLength, maxLength, s)) {
+            throw new TypeError(`Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${actualLength}`);
+        }
+        return s;
+    };
+    function asFixedLengthString(...args) {
+        switch (args.length) {
+            case 2:
+                return asFixedLengthStringImpl(...args);
+            case 1:
+                return (s) => asFixedLengthStringImpl(args[0], s);
+        }
     }
-    return s;
-  };
-  function asBoundedLengthString(...args) {
-    switch (args.length) {
-      case 3:
-        return asBoundedLengthStringImpl(...args);
-      case 2:
-        return (s) => asBoundedLengthStringImpl(...args, s);
-    }
-  }
-  Str2.asBoundedLengthString = asBoundedLengthString;
-  const asBoundedLengthStringImpl = (minLength, maxLength, s) => {
-    const actualLength = s.length;
-    if (!(0, Str2.isBoundedLengthString)(minLength, maxLength, s)) {
-      throw new TypeError(
-        `Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${actualLength}`
-      );
-    }
-    return s;
-  };
-  function asFixedLengthString(...args) {
-    switch (args.length) {
-      case 2:
-        return asFixedLengthStringImpl(...args);
-      case 1:
-        return (s) => asFixedLengthStringImpl(args[0], s);
-    }
-  }
-  Str2.asFixedLengthString = asFixedLengthString;
-  const asFixedLengthStringImpl = (length, s) => {
-    const actualLength = s.length;
-    if (!(0, Str2.isFixedLengthString)(length, s)) {
-      throw new TypeError(
-        `Expected a string of length ${length}, got a string of length ${actualLength}`
-      );
-    }
-    return s;
-  };
-  Str2.asNonEmptyString = (s) => {
-    if (!(0, Str2.isMinLengthString)(1, s)) {
-      throw new TypeError("Expected a non-empty string, got an empty string");
-    }
-    return s;
-  };
+    Str.asFixedLengthString = asFixedLengthString;
+    const asFixedLengthStringImpl = (length, s) => {
+        const actualLength = s.length;
+        if (!Str.isFixedLengthString(length, s)) {
+            throw new TypeError(`Expected a string of length ${length}, got a string of length ${actualLength}`);
+        }
+        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');
+        }
+        return s;
+    };
 })(Str || (Str = {}));
-
-export { Str };
-//# sourceMappingURL=str.mjs.map
+//# sourceMappingURL=str.mjs.map

package/dist/string/str.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"str.mjs","sources":["../../src/string/str.mts"],"sourcesContent":["import {\n  type BoundedLengthString,\n  type FixedLengthString,\n  type MaxLengthString,\n  type MinLengthString,\n  type NonEmptyString,\n  type SupportedLength,\n} from 'ts-type-forge';\n\n/**\n * Namespace providing type guards and runtime-checked casts for the branded\n * length-constrained string types (`MinLengthString`, `MaxLengthString`,\n * `BoundedLengthString`, `FixedLengthString`).\n *\n * Lengths are 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 */\nexport namespace Str {\n  /**\n   * Type guard that checks if a string has at least `minLength` characters.\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(Str.isMinLengthString(12, input));\n   *\n   * assert.isFalse(Str.isMinLengthString(12, 'short'));\n   *\n   * if (Str.isMinLengthString(12, input)) {\n   *   const nonEmpty: NonEmptyString = input; // OK (12 >= 1)\n   *\n   *   assert.isTrue(nonEmpty.length >= 12);\n   * }\n   * ```\n   *\n   * @template MinLength - The minimum number of characters (inclusive).\n   * @template S - The input string type (literal types are preserved).\n   * @param minLength - The minimum number of characters (inclusive).\n   * @param s - The string to check.\n   * @returns `true` if `s.length >= minLength`, `false` otherwise. When `true`,\n   *   TypeScript narrows `s` to `MinLengthString<MinLength> & S`.\n   */\n  export const isMinLengthString = <\n    MinLength extends SupportedLength,\n    S extends string,\n  >(\n    minLength: MinLength,\n    s: S,\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   * **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(Str.isMaxLengthString(32, input));\n   *\n   * assert.isFalse(Str.isMaxLengthString(3, input));\n   *\n   * if (Str.isMaxLengthString(32, input)) {\n   *   const relaxed: MaxLengthString<64> = input; // OK (32 <= 64)\n   *\n   *   assert.isTrue(relaxed.length <= 32);\n   * }\n   * ```\n   *\n   * @template MaxLength - The maximum number of characters (inclusive).\n   * @template S - The input string type (literal types are preserved).\n   * @param maxLength - The maximum number of characters (inclusive).\n   * @param s - The string to check.\n   * @returns `true` if `s.length <= maxLength`, `false` otherwise. When `true`,\n   *   TypeScript narrows `s` to `MaxLengthString<MaxLength> & S`.\n   */\n  export const isMaxLengthString = <\n    MaxLength extends SupportedLength,\n    S extends string,\n  >(\n    maxLength: MaxLength,\n    s: S,\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   * **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(Str.isBoundedLengthString(8, 16, input));\n   *\n   * assert.isFalse(Str.isBoundedLengthString(8, 16, 'user'));\n   *\n   * if (Str.isBoundedLengthString(8, 16, input)) {\n   *   const userId: BoundedLengthString<1, 255> = input; // OK ([8, 16] ⊆ [1, 255])\n   *\n   *   assert.isTrue(userId.length >= 8 && userId.length <= 16);\n   * }\n   * ```\n   *\n   * @template MinLength - The minimum number of characters (inclusive).\n   * @template MaxLength - The maximum number of characters (inclusive).\n   * @template S - The input string type (literal types are preserved).\n   * @param minLength - The minimum number of characters (inclusive).\n   * @param maxLength - The maximum number of characters (inclusive).\n   * @param s - The string to check.\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   */\n  export const isBoundedLengthString = <\n    MinLength extends SupportedLength,\n    MaxLength extends SupportedLength,\n    S extends string,\n  >(\n    minLength: MinLength,\n    maxLength: MaxLength,\n    s: S,\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   * **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(Str.isFixedLengthString(2, input));\n   *\n   * assert.isFalse(Str.isFixedLengthString(3, input));\n   *\n   * if (Str.isFixedLengthString(2, input)) {\n   *   const atMost5: MaxLengthString<5> = input; // OK (2 <= 5)\n   *\n   *   assert.isTrue(atMost5.length === 2);\n   * }\n   * ```\n   *\n   * @template Length - The exact number of characters.\n   * @template S - The input string type (literal types are preserved).\n   * @param length - The exact number of characters.\n   * @param s - The string to check.\n   * @returns `true` if `s.length === length`, `false` otherwise. When `true`,\n   *   TypeScript narrows `s` to `FixedLengthString<Length> & S`.\n   */\n  export const isFixedLengthString = <\n    Length extends SupportedLength,\n    S extends string,\n  >(\n    length: Length,\n    s: S,\n  ): s is FixedLengthString<Length> & S => s.length === length;\n\n  /**\n   * Casts a string to `MinLengthString<MinLength>` after checking that it has\n   * at least `minLength` characters.\n   *\n   * Use this instead of writing `s as unknown as MinLengthString<N>`: the\n   * length is verified at runtime, and the original string type (e.g. literal\n   * types) is preserved via intersection.\n   *\n   * Supports a curried overload: calling it with only `minLength` returns a\n   * function that casts a string, which is convenient for `pipe`/`map`.\n   *\n   * @example\n   *\n   * ```ts\n   * const password = Str.asMinLengthString(12, 'very-secret-password');\n   *\n   * const nonEmpty: NonEmptyString = password; // OK (>= 1)\n   *\n   * assert.isTrue(nonEmpty.length >= 12);\n   *\n   * // curried version\n   * const asPassword = Str.asMinLengthString(12);\n   *\n   * assert.strictEqual(asPassword('another-secret'), 'another-secret');\n   *\n   * assert.throws(() => Str.asMinLengthString(12, 'short')); // length 5 < 12\n   * ```\n   *\n   * @template MinLength - The minimum number of characters (inclusive).\n   * @template S - The input string type (literal types are preserved).\n   * @param minLength - The minimum number of characters (inclusive).\n   * @param s - The string to cast.\n   * @returns `s` typed as `MinLengthString<MinLength> & S`.\n   * @throws {TypeError} If `s.length < minLength`.\n   */\n  export function asMinLengthString<\n    MinLength extends SupportedLength,\n    S extends string,\n  >(minLength: MinLength, s: S): MinLengthString<MinLength> & S;\n\n  // Curried version\n  export function asMinLengthString<MinLength extends SupportedLength>(\n    minLength: MinLength,\n  ): <S extends string>(s: S) => MinLengthString<MinLength> & S;\n\n  export function asMinLengthString(\n    ...args:\n      | readonly [minLength: SupportedLength, s: string]\n      | readonly [minLength: SupportedLength]\n  ): string | ((s: string) => string) {\n    switch (args.length) {\n      case 2:\n        return asMinLengthStringImpl(...args);\n\n      case 1:\n        return (s) => asMinLengthStringImpl(args[0], s);\n    }\n  }\n\n  const asMinLengthStringImpl = (\n    minLength: SupportedLength,\n    s: string,\n  ): string => {\n    const actualLength = s.length;\n\n    if (!isMinLengthString(minLength, s)) {\n      throw new TypeError(\n        `Expected a string of length >= ${minLength}, got a string of length ${actualLength}`,\n      );\n    }\n\n    return s;\n  };\n\n  /**\n   * Casts a string to `MaxLengthString<MaxLength>` after checking that it has\n   * at most `maxLength` characters.\n   *\n   * Use this instead of writing `s as unknown as MaxLengthString<N>`: the\n   * length is verified at runtime, and the original string type (e.g. literal\n   * types) is preserved via intersection.\n   *\n   * Supports a curried overload: calling it with only `maxLength` returns a\n   * function that casts a string, which is convenient for `pipe`/`map`.\n   *\n   * @example\n   *\n   * ```ts\n   * const userName = Str.asMaxLengthString(32, 'noshiro');\n   *\n   * const relaxed: MaxLengthString<64> = userName; // OK (32 <= 64)\n   *\n   * assert.isTrue(relaxed.length <= 32);\n   *\n   * // curried version\n   * const asUserName = Str.asMaxLengthString(32);\n   *\n   * assert.strictEqual(asUserName('another-user'), 'another-user');\n   *\n   * assert.throws(() => Str.asMaxLengthString(3, 'noshiro')); // length 7 > 3\n   * ```\n   *\n   * @template MaxLength - The maximum number of characters (inclusive).\n   * @template S - The input string type (literal types are preserved).\n   * @param maxLength - The maximum number of characters (inclusive).\n   * @param s - The string to cast.\n   * @returns `s` typed as `MaxLengthString<MaxLength> & S`.\n   * @throws {TypeError} If `s.length > maxLength`.\n   */\n  export function asMaxLengthString<\n    MaxLength extends SupportedLength,\n    S extends string,\n  >(maxLength: MaxLength, s: S): MaxLengthString<MaxLength> & S;\n\n  // Curried version\n  export function asMaxLengthString<MaxLength extends SupportedLength>(\n    maxLength: MaxLength,\n  ): <S extends string>(s: S) => MaxLengthString<MaxLength> & S;\n\n  export function asMaxLengthString(\n    ...args:\n      | readonly [maxLength: SupportedLength, s: string]\n      | readonly [maxLength: SupportedLength]\n  ): string | ((s: string) => string) {\n    switch (args.length) {\n      case 2:\n        return asMaxLengthStringImpl(...args);\n\n      case 1:\n        return (s) => asMaxLengthStringImpl(args[0], s);\n    }\n  }\n\n  const asMaxLengthStringImpl = (\n    maxLength: SupportedLength,\n    s: string,\n  ): string => {\n    const actualLength = s.length;\n\n    if (!isMaxLengthString(maxLength, s)) {\n      throw new TypeError(\n        `Expected a string of length <= ${maxLength}, got a string of length ${actualLength}`,\n      );\n    }\n\n    return s;\n  };\n\n  /**\n   * Casts a string to `BoundedLengthString<MinLength, MaxLength>` after\n   * checking that its length is within the inclusive range\n   * `[minLength, maxLength]`.\n   *\n   * Use this instead of writing `s as unknown as BoundedLengthString<M, N>`:\n   * the length is verified at runtime, and the original string type (e.g.\n   * literal types) is preserved via intersection.\n   *\n   * Supports a curried overload: calling it with only `minLength` and\n   * `maxLength` returns a function that casts a string, which is convenient for\n   * `pipe`/`map`.\n   *\n   * @example\n   *\n   * ```ts\n   * const userId = Str.asBoundedLengthString(8, 16, 'user-12345678');\n   *\n   * const relaxed: BoundedLengthString<1, 255> = userId; // OK ([8, 16] ⊆ [1, 255])\n   *\n   * assert.isTrue(relaxed.length >= 8 && relaxed.length <= 16);\n   *\n   * // curried version\n   * const asUserId = Str.asBoundedLengthString(8, 16);\n   *\n   * assert.strictEqual(asUserId('user-87654321'), 'user-87654321');\n   *\n   * assert.throws(() => Str.asBoundedLengthString(8, 16, 'user')); // length 4 < 8\n   * ```\n   *\n   * @template MinLength - The minimum number of characters (inclusive).\n   * @template MaxLength - The maximum number of characters (inclusive).\n   * @template S - The input string type (literal types are preserved).\n   * @param minLength - The minimum number of characters (inclusive).\n   * @param maxLength - The maximum number of characters (inclusive).\n   * @param s - The string to cast.\n   * @returns `s` typed as `BoundedLengthString<MinLength, MaxLength> & S`.\n   * @throws {TypeError} If `s.length < minLength` or `s.length > maxLength`.\n   */\n  export function asBoundedLengthString<\n    MinLength extends SupportedLength,\n    MaxLength extends SupportedLength,\n    S extends string,\n  >(\n    minLength: MinLength,\n    maxLength: MaxLength,\n    s: S,\n  ): BoundedLengthString<MinLength, MaxLength> & S;\n\n  // Curried version\n  export function asBoundedLengthString<\n    MinLength extends SupportedLength,\n    MaxLength extends SupportedLength,\n  >(\n    minLength: MinLength,\n    maxLength: MaxLength,\n  ): <S extends string>(s: S) => BoundedLengthString<MinLength, MaxLength> & S;\n\n  export function asBoundedLengthString(\n    ...args:\n      | readonly [\n          minLength: SupportedLength,\n          maxLength: SupportedLength,\n          s: string,\n        ]\n      | readonly [minLength: SupportedLength, maxLength: SupportedLength]\n  ): string | ((s: string) => string) {\n    switch (args.length) {\n      case 3:\n        return asBoundedLengthStringImpl(...args);\n\n      case 2:\n        return (s) => asBoundedLengthStringImpl(...args, s);\n    }\n  }\n\n  const asBoundedLengthStringImpl = (\n    minLength: SupportedLength,\n    maxLength: SupportedLength,\n    s: string,\n  ): string => {\n    const actualLength = s.length;\n\n    if (!isBoundedLengthString(minLength, maxLength, s)) {\n      throw new TypeError(\n        `Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${actualLength}`,\n      );\n    }\n\n    return s;\n  };\n\n  /**\n   * Casts a string to `FixedLengthString<Length>` after checking that it has\n   * exactly `length` characters.\n   *\n   * Use this instead of writing `s as unknown as FixedLengthString<N>`: the\n   * length is verified at runtime, and the original string type (e.g. literal\n   * types) is preserved via intersection.\n   *\n   * Supports a curried overload: calling it with only `length` returns a\n   * function that casts a string, which is convenient for `pipe`/`map`.\n   *\n   * @example\n   *\n   * ```ts\n   * const countryCode = Str.asFixedLengthString(2, 'JP');\n   *\n   * const atMost5: MaxLengthString<5> = countryCode; // OK (2 <= 5)\n   *\n   * assert.isTrue(atMost5.length === 2);\n   *\n   * // curried version\n   * const asCountryCode = Str.asFixedLengthString(2);\n   *\n   * assert.strictEqual(asCountryCode('US'), 'US');\n   *\n   * assert.throws(() => Str.asFixedLengthString(3, 'JP')); // length 2 !== 3\n   * ```\n   *\n   * @template Length - The exact number of characters.\n   * @template S - The input string type (literal types are preserved).\n   * @param length - The exact number of characters.\n   * @param s - The string to cast.\n   * @returns `s` typed as `FixedLengthString<Length> & S`.\n   * @throws {TypeError} If `s.length !== length`.\n   */\n  export function asFixedLengthString<\n    Length extends SupportedLength,\n    S extends string,\n  >(length: Length, s: S): FixedLengthString<Length> & S;\n\n  // Curried version\n  export function asFixedLengthString<Length extends SupportedLength>(\n    length: Length,\n  ): <S extends string>(s: S) => FixedLengthString<Length> & S;\n\n  export function asFixedLengthString(\n    ...args:\n      | readonly [length: SupportedLength, s: string]\n      | readonly [length: SupportedLength]\n  ): string | ((s: string) => string) {\n    switch (args.length) {\n      case 2:\n        return asFixedLengthStringImpl(...args);\n\n      case 1:\n        return (s) => asFixedLengthStringImpl(args[0], s);\n    }\n  }\n\n  const asFixedLengthStringImpl = (\n    length: SupportedLength,\n    s: string,\n  ): string => {\n    const actualLength = s.length;\n\n    if (!isFixedLengthString(length, s)) {\n      throw new TypeError(\n        `Expected a string of length ${length}, got a string of length ${actualLength}`,\n      );\n    }\n\n    return s;\n  };\n\n  /**\n   * Casts a string to `NonEmptyString` after checking that it has at least one\n   * character.\n   *\n   * `NonEmptyString` is an alias of `MinLengthString<1>`, so this is the\n   * length-1 specialization of {@link asMinLengthString}. Use this instead of\n   * writing `s as unknown as NonEmptyString`: the length is verified at\n   * runtime, and the original string type (e.g. literal types) is preserved\n   * via intersection.\n   *\n   * @example\n   *\n   * ```ts\n   * const name = Str.asNonEmptyString('noshiro');\n   *\n   * const nonEmpty: NonEmptyString = name; // OK\n   *\n   * assert.isTrue(nonEmpty.length >= 1);\n   *\n   * assert.throws(() => Str.asNonEmptyString('')); // length 0 < 1\n   * ```\n   *\n   * @template S - The input string type (literal types are preserved).\n   * @param s - The string to cast.\n   * @returns `s` typed as `NonEmptyString & S`.\n   * @throws {TypeError} If `s` is empty.\n   */\n  export const asNonEmptyString = <S extends string>(\n    s: S,\n  ): NonEmptyString & S => {\n    if (!isMinLengthString(1, s)) {\n      throw new TypeError('Expected a non-empty string, got an empty string');\n    }\n\n    return s;\n  };\n}\n"],"names":["Str"],"mappings":"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"}
+{"version":3,"file":"str.mjs","sourceRoot":"","sources":["../../src/string/str.mts"],"names":[],"mappings":"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"}

package/dist/types.mjs

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

package/dist/types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"types.mjs","sourceRoot":"","sources":["../src/types.mts"],"names":[],"mappings":";AAkIA,oBAAoB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-data-forge",
-  "version": "14.6.0",
+  "version": "14.6.2",
   "private": false,
   "keywords": [
     "typescript",
@@ -46,17 +46,16 @@
     "@types/react": "19.2.18",
     "@vitest/browser-playwright": "4.1.11",
     "dedent": "1.7.2",
-    "eslint-config-typed": "5.10.1",
-    "eslint-plugin-ts-fortress": "1.0.6",
-    "eslint-plugin-ts-type-forge": "0.7.2",
+    "eslint-config-typed": "5.10.5",
+    "eslint-plugin-ts-fortress": "1.1.0",
+    "eslint-plugin-ts-type-forge": "0.8.0",
     "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",
-    "rollup": "4.62.5",
-    "ts-repo-utils": "10.3.3",
+    "ts-repo-utils": "10.5.0",
     "typedoc": "0.28.20",
     "typedoc-github-theme": "0.4.0",
     "vite": "8.2.2"

package/src/array/impl/array-utils-length-constraint-preservation.test.mts

@@ -32,7 +32,7 @@ describe('map preserves length constraints', () => {
   test('a branded input keeps its constraint', () => {
     const input: MinLengthArray<3, number> = asMinLengthArray(3, [0, 1, 2, 3]);
 
-    const result = map(input, (value) => `#${String(value)}`);
+    const result = map(input, (value) => `#${value.toString()}`);
 
     expectType<typeof result, MinLengthArray<3, string>>('~=');
 
@@ -162,7 +162,7 @@ describe('other length-preserving utilities preserve length constraints', () =>
   test('toUpdated keeps the brand and widens only the element type', () => {
     const input: MinLengthArray<3, number> = asMinLengthArray(3, [0, 1, 2]);
 
-    const result = toUpdated(input, 1, (prev) => `#${String(prev)}`);
+    const result = toUpdated(input, 1, (prev) => `#${prev.toString()}`);
 
     expectType<typeof result, MinLengthArray<3, number | `#${string}`>>('~=');
 

package/src/collections/imap-mapped.mts

@@ -2,7 +2,7 @@
 import { type WidenLiteral } from 'ts-type-forge';
 import { Optional, pipe } from '../functional/index.mjs';
 import { asUint32 } from '../number/index.mjs';
-import { tp } from '../others/index.mjs';
+import { tp, unknownToString } from '../others/index.mjs';
 import { type MapSetKeyType, type SizeType } from '../types.mjs';
 
 /**
@@ -1051,7 +1051,7 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
     if (!this.has(key)) {
       if (this.#showNotFoundMessage) {
         console.warn(
-          `IMapMapped.delete: key not found: ${String(this.#toKey(key))}`,
+          `IMapMapped.delete: key not found: ${unknownToString(this.#toKey(key))}`,
         );
       }
 
@@ -1103,7 +1103,7 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
     if (Optional.isNone(curr)) {
       if (this.#showNotFoundMessage) {
         console.warn(
-          `IMapMapped.update: key not found: ${String(this.#toKey(key))}`,
+          `IMapMapped.update: key not found: ${unknownToString(this.#toKey(key))}`,
         );
       }
 
@@ -1160,7 +1160,7 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
           if (curr === undefined || !mut_result.has(key)) {
             if (this.#showNotFoundMessage) {
               console.warn(
-                `IMapMapped.withMutations::update: key not found: ${String(key)}`,
+                `IMapMapped.withMutations::update: key not found: ${unknownToString(key)}`,
               );
             }
 

package/src/collections/imap.mts

@@ -753,7 +753,7 @@ class IMapClass<K extends MapSetKeyType, V>
 
   /** @inheritdoc */
   has(key: K | (WidenLiteral<K> & {})): boolean {
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unnecessary-type-assertion -- unnecessary only under the strict standard library; the stock one types `has` as taking exactly `K`
     return this.#map.has(key as K);
   }
 

package/src/collections/imap.test.mts

@@ -263,7 +263,7 @@ describe('IMap.has', () => {
 
     assert.isTrue(map.has('1'));
 
-    assert.isTrue(map.has(String(1)));
+    assert.isTrue(map.has((1).toString()));
   });
 });
 

package/src/collections/iset-mapped.mts

@@ -5,6 +5,7 @@ import {
   type 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';
 
 /**
@@ -1270,7 +1271,7 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
     if (!this.has(key)) {
       if (this.#showNotFoundMessage) {
         console.warn(
-          `ISetMapped.delete: key not found: ${String(this.#toKey(key))}`,
+          `ISetMapped.delete: key not found: ${unknownToString(this.#toKey(key))}`,
         );
       }
 

package/src/collections/iset.mts

@@ -753,7 +753,7 @@ class ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {
 
   /** @inheritdoc */
   has(key: K | (WidenLiteral<K> & {})): boolean {
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unnecessary-type-assertion -- unnecessary only under the strict standard library; the stock one types `has` as taking exactly `K`
     return this.#set.has(key as K);
   }
 

package/src/functional/async-result.test.mts

@@ -1,6 +1,7 @@
 import { isError } from '@sindresorhus/is';
 import { AsyncResult as AsyncResultFromEntryPoint } from '../entry-point.mjs';
 import { expectType } from '../expect-type.mjs';
+import { unknownToString } from '../others/index.mjs';
 import { AsyncResult } from './async-result/index.mjs';
 import { Result } from './result/index.mjs';
 
@@ -17,7 +18,7 @@ describe('AsyncResult test', () => {
     test('resolved promise becomes Ok', async () => {
       const result = await AsyncResult.fromPromise(
         Promise.resolve(42),
-        (error) => `mapped: ${String(error)}`,
+        (error) => `mapped: ${unknownToString(error)}`,
       );
 
       assert.isTrue(Result.isOk(result));
@@ -61,7 +62,7 @@ describe('AsyncResult test', () => {
     test('resolved async function becomes Ok', async () => {
       const result = await AsyncResult.fromThrowable(
         () => Promise.resolve('data'),
-        (error) => `mapped: ${String(error)}`,
+        (error) => `mapped: ${unknownToString(error)}`,
       );
 
       assert.isTrue(Result.isOk(result));

package/src/functional/optional.test.mts

@@ -1,5 +1,6 @@
 import { expectType } from '../expect-type.mjs';
 import { Num } from '../number/index.mjs';
+import { unknownToString } from '../others/index.mjs';
 import { type None, type Some } from '../types.mjs';
 import { Optional, type UnknownOptional } from './optional/index.mjs';
 import { pipe } from './pipe.mjs';
@@ -872,7 +873,7 @@ describe('Optional test', () => {
       const makeOptional = (): Optional<undefined> => Optional.some(undefined);
 
       const result = Optional.match(makeOptional(), {
-        some: (value) => `some: ${String(value)}`,
+        some: (value) => `some: ${unknownToString(value)}`,
         none: () => 'none',
       });
 

package/src/functional/result.test.mts

@@ -963,14 +963,12 @@ describe('Result test', () => {
 
       const invalidJson = '{invalid json}';
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       const validResult = Result.fromThrowable(() => JSON.parse(validJson));
 
       assert.isTrue(Result.isOk(validResult));
 
       assert.deepStrictEqual(Result.unwrapOk(validResult), { key: 'value' });
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       const invalidResult = Result.fromThrowable(() => JSON.parse(invalidJson));
 
       assert.isTrue(Result.isErr(invalidResult));

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

@@ -61,7 +61,7 @@ describe(isNonEmptyString, () => {
       // TypeScript knows it's a string
       expect(value.length).toBeGreaterThan(0);
 
-      expect(value.charAt(0)).toBe('t');
+      expect(value.at(0)).toBe('t');
     }
   });
 
@@ -109,7 +109,7 @@ describe(isNonEmptyString, () => {
 
   test('should not accept String objects', () => {
     // @ts-expect-error Testing non-string types
-    // eslint-disable-next-line unicorn/new-for-builtins
+    // eslint-disable-next-line unicorn/new-for-builtins, @typescript-eslint/no-deprecated
     assert.isFalse(isNonEmptyString(new String('hello') as unknown));
   });
 });

package/src/guard/is-non-null-object.test.mts

@@ -43,13 +43,13 @@ describe(isNonNullObject, () => {
   });
 
   test('should return true for boxed primitives', () => {
-    // eslint-disable-next-line unicorn/new-for-builtins
+    // eslint-disable-next-line unicorn/new-for-builtins, @typescript-eslint/no-deprecated
     assert.isTrue(isNonNullObject(new String('hello')));
 
-    // eslint-disable-next-line unicorn/new-for-builtins
+    // eslint-disable-next-line unicorn/new-for-builtins, @typescript-eslint/no-deprecated
     assert.isTrue(isNonNullObject(new Number(42)));
 
-    // eslint-disable-next-line unicorn/new-for-builtins
+    // eslint-disable-next-line unicorn/new-for-builtins, @typescript-eslint/no-deprecated
     assert.isTrue(isNonNullObject(new Boolean(true)));
   });