ts-data-forge 12.0.0 → 12.1.0

package/dist/array/impl/array-utils-length-bounded-array-cast.d.mts

@@ -1,4 +1,4 @@
-import { type BoundedLengthArray, type FixedLengthArray, type MaxLengthArray, type MinLengthArray, type SupportedLength } from 'ts-type-forge';
+import { type BoundedLengthArray, type FixedLengthArray, type MaxLengthArray, type MinLengthArray, type NonEmptyArray, type SupportedLength } from 'ts-type-forge';
 /**
  * Casts an array to `FixedLengthArray<Length, E>` after checking that it has
  * exactly `length` elements.
@@ -9,6 +9,9 @@ import { type BoundedLengthArray, type FixedLengthArray, type MaxLengthArray, ty
  * structural tuple prefix (in-range indexed access without `undefined` under
  * `noUncheckedIndexedAccess`).
  *
+ * Supports a curried overload: calling it with only `length` returns a
+ * function that casts an array, which is convenient for `pipe`/`map`.
+ *
  * @example
  *
  * ```ts
@@ -17,6 +20,10 @@ import { type BoundedLengthArray, type FixedLengthArray, type MaxLengthArray, ty
  * const atMost5: MaxLengthArray<5, number> = rgb; // OK (3 <= 5)
  * const red: number = rgb[0]; // OK — no `undefined`
  *
+ * // curried version
+ * const asRgb = Arr.asFixedLengthArray(3);
+ * const green = asRgb([0, 255, 0]);
+ *
  * // Arr.asFixedLengthArray([255, 128], 3); // throws TypeError
  * ```
  *
@@ -27,7 +34,8 @@ import { type BoundedLengthArray, type FixedLengthArray, type MaxLengthArray, ty
  * @returns `xs` typed as `FixedLengthArray<Length, Xs[number]> & Xs`.
  * @throws {TypeError} If `xs.length !== length`.
  */
-export declare const asFixedLengthArray: <Xs extends readonly unknown[], Length extends SupportedLength>(xs: Xs, length: Length) => FixedLengthArray<Length, Xs[number]> & Xs;
+export declare function asFixedLengthArray<Xs extends readonly unknown[], Length extends SupportedLength>(xs: Xs, length: Length): FixedLengthArray<Length, Xs[number]> & Xs;
+export declare function asFixedLengthArray<Length extends SupportedLength>(length: Length): <Xs extends readonly unknown[]>(xs: Xs) => FixedLengthArray<Length, Xs[number]> & Xs;
 /**
  * Casts an array to `MinLengthArray<MinLength, E>` after checking that it has
  * at least `minLength` elements.
@@ -38,6 +46,9 @@ export declare const asFixedLengthArray: <Xs extends readonly unknown[], Length
  * structural tuple prefix (indexed access below `min(N, 10)` without
  * `undefined` under `noUncheckedIndexedAccess`).
  *
+ * Supports a curried overload: calling it with only `minLength` returns a
+ * function that casts an array, which is convenient for `pipe`/`map`.
+ *
  * @example
  *
  * ```ts
@@ -46,6 +57,10 @@ export declare const asFixedLengthArray: <Xs extends readonly unknown[], Length
  * const nonEmpty: MinLengthArray<1, number> = history; // OK (3 >= 1)
  * const first: number = history[0]; // OK — no `undefined`
  *
+ * // curried version
+ * const asHistory = Arr.asMinLengthArray(3);
+ * const next = asHistory([4, 5, 6, 7]);
+ *
  * // Arr.asMinLengthArray([0], 3); // throws TypeError
  * ```
  *
@@ -56,7 +71,8 @@ export declare const asFixedLengthArray: <Xs extends readonly unknown[], Length
  * @returns `xs` typed as `MinLengthArray<MinLength, Xs[number]> & Xs`.
  * @throws {TypeError} If `xs.length < minLength`.
  */
-export declare const asMinLengthArray: <Xs extends readonly unknown[], MinLength extends SupportedLength>(xs: Xs, minLength: MinLength) => MinLengthArray<MinLength, Xs[number]> & Xs;
+export declare function asMinLengthArray<Xs extends readonly unknown[], MinLength extends SupportedLength>(xs: Xs, minLength: MinLength): MinLengthArray<MinLength, Xs[number]> & Xs;
+export declare function asMinLengthArray<MinLength extends SupportedLength>(minLength: MinLength): <Xs extends readonly unknown[]>(xs: Xs) => MinLengthArray<MinLength, Xs[number]> & Xs;
 /**
  * Casts an array to `MaxLengthArray<MaxLength, E>` after checking that it has
  * at most `maxLength` elements.
@@ -65,6 +81,9 @@ export declare const asMinLengthArray: <Xs extends readonly unknown[], MinLength
  * length is verified at runtime, and the original array type (e.g. tuple
  * types) is preserved via intersection.
  *
+ * Supports a curried overload: calling it with only `maxLength` returns a
+ * function that casts an array, which is convenient for `pipe`/`map`.
+ *
  * @example
  *
  * ```ts
@@ -72,6 +91,10 @@ export declare const asMinLengthArray: <Xs extends readonly unknown[], MinLength
  *
  * const relaxed: MaxLengthArray<16, string> = tags; // OK (8 <= 16)
  *
+ * // curried version
+ * const asTags = Arr.asMaxLengthArray(8);
+ * const more = asTags(['d', 'e']);
+ *
  * // Arr.asMaxLengthArray(['a', 'b', 'c'], 2); // throws TypeError
  * ```
  *
@@ -82,7 +105,8 @@ export declare const asMinLengthArray: <Xs extends readonly unknown[], MinLength
  * @returns `xs` typed as `MaxLengthArray<MaxLength, Xs[number]> & Xs`.
  * @throws {TypeError} If `xs.length > maxLength`.
  */
-export declare const asMaxLengthArray: <Xs extends readonly unknown[], MaxLength extends SupportedLength>(xs: Xs, maxLength: MaxLength) => MaxLengthArray<MaxLength, Xs[number]> & Xs;
+export declare function asMaxLengthArray<Xs extends readonly unknown[], MaxLength extends SupportedLength>(xs: Xs, maxLength: MaxLength): MaxLengthArray<MaxLength, Xs[number]> & Xs;
+export declare function asMaxLengthArray<MaxLength extends SupportedLength>(maxLength: MaxLength): <Xs extends readonly unknown[]>(xs: Xs) => MaxLengthArray<MaxLength, Xs[number]> & Xs;
 /**
  * Casts an array to `BoundedLengthArray<MinLength, MaxLength, E>` after
  * checking that its length is within the inclusive range
@@ -93,6 +117,10 @@ export declare const asMaxLengthArray: <Xs extends readonly unknown[], MaxLength
  * at runtime, and the original array type (e.g. tuple types) is preserved via
  * intersection.
  *
+ * Supports a curried overload: calling it with only `minLength` and
+ * `maxLength` returns a function that casts an array, which is convenient for
+ * `pipe`/`map`.
+ *
  * @example
  *
  * ```ts
@@ -100,6 +128,10 @@ export declare const asMaxLengthArray: <Xs extends readonly unknown[], MaxLength
  *
  * const relaxed: BoundedLengthArray<0, 100, number> = selection; // OK
  *
+ * // curried version
+ * const asSelection = Arr.asBoundedLengthArray(1, 5);
+ * const next = asSelection([4, 5]);
+ *
  * // Arr.asBoundedLengthArray([], 1, 5); // throws TypeError
  * ```
  *
@@ -113,5 +145,33 @@ export declare const asMaxLengthArray: <Xs extends readonly unknown[], MaxLength
  *   `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.
  * @throws {TypeError} If `xs.length < minLength || xs.length > maxLength`.
  */
-export declare const asBoundedLengthArray: <Xs extends readonly unknown[], MinLength extends SupportedLength, MaxLength extends SupportedLength>(xs: Xs, minLength: MinLength, maxLength: MaxLength) => BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
+export declare function asBoundedLengthArray<Xs extends readonly unknown[], MinLength extends SupportedLength, MaxLength extends SupportedLength>(xs: Xs, minLength: MinLength, maxLength: MaxLength): BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
+export declare function asBoundedLengthArray<MinLength extends SupportedLength, MaxLength extends SupportedLength>(minLength: MinLength, maxLength: MaxLength): <Xs extends readonly unknown[]>(xs: Xs) => BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
+/**
+ * Casts an array to `NonEmptyArray<E>` after checking that it has at least one
+ * element.
+ *
+ * `NonEmptyArray<E>` is an alias of `MinLengthArray<1, E>`, so this is the
+ * length-1 specialization of {@link asMinLengthArray}. Use this instead of
+ * writing `xs as unknown as NonEmptyArray<E>`: the length is verified at
+ * runtime, and the original array type (e.g. tuple types) is preserved via
+ * intersection, so the result also benefits from the structural tuple prefix
+ * (`xs[0]` without `undefined` under `noUncheckedIndexedAccess`).
+ *
+ * @example
+ *
+ * ```ts
+ * const history = Arr.asNonEmptyArray([0, 1, 2, 3]);
+ *
+ * const first: number = history[0]; // OK — no `undefined`
+ *
+ * // Arr.asNonEmptyArray([]); // throws TypeError
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @param xs - The array to cast.
+ * @returns `xs` typed as `NonEmptyArray<Xs[number]> & Xs`.
+ * @throws {TypeError} If `xs` is empty.
+ */
+export declare const asNonEmptyArray: <Xs extends readonly unknown[]>(xs: Xs) => NonEmptyArray<Xs[number]> & Xs;
 //# sourceMappingURL=array-utils-length-bounded-array-cast.d.mts.map

package/dist/array/impl/array-utils-length-bounded-array-cast.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-length-bounded-array-cast.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-length-bounded-array-cast.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAQvB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,kBAAkB,GAC7B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,MAAM,SAAS,eAAe,MAE1B,EAAE,UACE,MAAM,KACb,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAQzC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,gBAAgB,GAC3B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,MAE7B,EAAE,aACK,SAAS,KACnB,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAQ1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,gBAAgB,GAC3B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,MAE7B,EAAE,aACK,SAAS,KACnB,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAQ1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,oBAAoB,GAC/B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,EACjC,SAAS,SAAS,eAAe,MAE7B,EAAE,aACK,SAAS,aACT,SAAS,KACnB,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAQzD,CAAC"}
+{"version":3,"file":"array-utils-length-bounded-array-cast.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-length-bounded-array-cast.mts"],"names":[],"mappings":"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"}

package/dist/array/impl/array-utils-length-bounded-array-cast.mjs

@@ -1,37 +1,79 @@
 import { isBoundedLengthArray, isFixedLengthArray, isMaxLengthArray, isMinLengthArray } from './array-utils-length-bounded-array-guard.mjs';
 
-const asFixedLengthArray = (xs, length) => {
-  if (!isFixedLengthArray(xs, length)) {
-    throw new TypeError(
-      `Expected an array of length ${length}, got an array of length ${xs.length}`
-    );
+function asFixedLengthArray(...args) {
+  switch (args.length) {
+    case 2: {
+      const [xs, length] = args;
+      if (!isFixedLengthArray(xs, length)) {
+        throw new TypeError(
+          `Expected an array of length ${length}, got an array of length ${xs.length}`
+        );
+      }
+      return xs;
+    }
+    case 1: {
+      const [length] = args;
+      return (xs) => asFixedLengthArray(xs, length);
+    }
   }
-  return xs;
-};
-const asMinLengthArray = (xs, minLength) => {
-  if (!isMinLengthArray(xs, minLength)) {
-    throw new TypeError(
-      `Expected an array of length >= ${minLength}, got an array of length ${xs.length}`
-    );
+}
+function asMinLengthArray(...args) {
+  switch (args.length) {
+    case 2: {
+      const [xs, minLength] = args;
+      if (!isMinLengthArray(xs, minLength)) {
+        throw new TypeError(
+          `Expected an array of length >= ${minLength}, got an array of length ${xs.length}`
+        );
+      }
+      return xs;
+    }
+    case 1: {
+      const [minLength] = args;
+      return (xs) => asMinLengthArray(xs, minLength);
+    }
   }
-  return xs;
-};
-const asMaxLengthArray = (xs, maxLength) => {
-  if (!isMaxLengthArray(xs, maxLength)) {
-    throw new TypeError(
-      `Expected an array of length <= ${maxLength}, got an array of length ${xs.length}`
-    );
+}
+function asMaxLengthArray(...args) {
+  switch (args.length) {
+    case 2: {
+      const [xs, maxLength] = args;
+      if (!isMaxLengthArray(xs, maxLength)) {
+        throw new TypeError(
+          `Expected an array of length <= ${maxLength}, got an array of length ${xs.length}`
+        );
+      }
+      return xs;
+    }
+    case 1: {
+      const [maxLength] = args;
+      return (xs) => asMaxLengthArray(xs, maxLength);
+    }
   }
-  return xs;
-};
-const asBoundedLengthArray = (xs, minLength, maxLength) => {
-  if (!isBoundedLengthArray(xs, minLength, maxLength)) {
-    throw new TypeError(
-      `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${xs.length}`
-    );
+}
+function asBoundedLengthArray(...args) {
+  switch (args.length) {
+    case 3: {
+      const [xs, minLength, maxLength] = args;
+      if (!isBoundedLengthArray(xs, minLength, maxLength)) {
+        throw new TypeError(
+          `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${xs.length}`
+        );
+      }
+      return xs;
+    }
+    case 2: {
+      const [minLength, maxLength] = args;
+      return (xs) => asBoundedLengthArray(xs, minLength, maxLength);
+    }
+  }
+}
+const asNonEmptyArray = (xs) => {
+  if (!isMinLengthArray(xs, 1)) {
+    throw new TypeError("Expected a non-empty array, got an empty array");
   }
   return xs;
 };
 
-export { asBoundedLengthArray, asFixedLengthArray, asMaxLengthArray, asMinLengthArray };
+export { asBoundedLengthArray, asFixedLengthArray, asMaxLengthArray, asMinLengthArray, asNonEmptyArray };
 //# sourceMappingURL=array-utils-length-bounded-array-cast.mjs.map

package/dist/array/impl/array-utils-length-bounded-array-cast.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-utils-length-bounded-array-cast.mjs","sources":["../../../src/array/impl/array-utils-length-bounded-array-cast.mts"],"sourcesContent":["import {\n  type BoundedLengthArray,\n  type FixedLengthArray,\n  type MaxLengthArray,\n  type MinLengthArray,\n  type SupportedLength,\n} from 'ts-type-forge';\nimport {\n  isBoundedLengthArray,\n  isFixedLengthArray,\n  isMaxLengthArray,\n  isMinLengthArray,\n} from './array-utils-length-bounded-array-guard.mjs';\n\n/**\n * Casts an array to `FixedLengthArray<Length, E>` after checking that it has\n * exactly `length` elements.\n *\n * Use this instead of writing `xs as unknown as FixedLengthArray<N, E>`: the\n * length is verified at runtime, and the original array type (e.g. tuple\n * types) is preserved via intersection, so the result also benefits from the\n * structural tuple prefix (in-range indexed access without `undefined` under\n * `noUncheckedIndexedAccess`).\n *\n * @example\n *\n * ```ts\n * const rgb = Arr.asFixedLengthArray([255, 128, 0], 3);\n *\n * const atMost5: MaxLengthArray<5, number> = rgb; // OK (3 <= 5)\n * const red: number = rgb[0]; // OK — no `undefined`\n *\n * // Arr.asFixedLengthArray([255, 128], 3); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template Length - The exact number of elements.\n * @param xs - The array to cast.\n * @param length - The exact number of elements.\n * @returns `xs` typed as `FixedLengthArray<Length, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length !== length`.\n */\nexport const asFixedLengthArray = <\n  Xs extends readonly unknown[],\n  Length extends SupportedLength,\n>(\n  xs: Xs,\n  length: Length,\n): FixedLengthArray<Length, Xs[number]> & Xs => {\n  if (!isFixedLengthArray(xs, length)) {\n    throw new TypeError(\n      `Expected an array of length ${length}, got an array of length ${xs.length}`,\n    );\n  }\n\n  return xs;\n};\n\n/**\n * Casts an array to `MinLengthArray<MinLength, E>` after checking that it has\n * at least `minLength` elements.\n *\n * Use this instead of writing `xs as unknown as MinLengthArray<N, E>`: the\n * length is verified at runtime, and the original array type (e.g. tuple\n * types) is preserved via intersection, so the result also benefits from the\n * structural tuple prefix (indexed access below `min(N, 10)` without\n * `undefined` under `noUncheckedIndexedAccess`).\n *\n * @example\n *\n * ```ts\n * const history = Arr.asMinLengthArray([0, 1, 2, 3], 3);\n *\n * const nonEmpty: MinLengthArray<1, number> = history; // OK (3 >= 1)\n * const first: number = history[0]; // OK — no `undefined`\n *\n * // Arr.asMinLengthArray([0], 3); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template MinLength - The minimum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param minLength - The minimum number of elements (inclusive).\n * @returns `xs` typed as `MinLengthArray<MinLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length < minLength`.\n */\nexport const asMinLengthArray = <\n  Xs extends readonly unknown[],\n  MinLength extends SupportedLength,\n>(\n  xs: Xs,\n  minLength: MinLength,\n): MinLengthArray<MinLength, Xs[number]> & Xs => {\n  if (!isMinLengthArray(xs, minLength)) {\n    throw new TypeError(\n      `Expected an array of length >= ${minLength}, got an array of length ${xs.length}`,\n    );\n  }\n\n  return xs;\n};\n\n/**\n * Casts an array to `MaxLengthArray<MaxLength, E>` after checking that it has\n * at most `maxLength` elements.\n *\n * Use this instead of writing `xs as unknown as MaxLengthArray<N, E>`: the\n * length is verified at runtime, and the original array type (e.g. tuple\n * types) is preserved via intersection.\n *\n * @example\n *\n * ```ts\n * const tags = Arr.asMaxLengthArray(['a', 'b', 'c'], 8);\n *\n * const relaxed: MaxLengthArray<16, string> = tags; // OK (8 <= 16)\n *\n * // Arr.asMaxLengthArray(['a', 'b', 'c'], 2); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `xs` typed as `MaxLengthArray<MaxLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length > maxLength`.\n */\nexport const asMaxLengthArray = <\n  Xs extends readonly unknown[],\n  MaxLength extends SupportedLength,\n>(\n  xs: Xs,\n  maxLength: MaxLength,\n): MaxLengthArray<MaxLength, Xs[number]> & Xs => {\n  if (!isMaxLengthArray(xs, maxLength)) {\n    throw new TypeError(\n      `Expected an array of length <= ${maxLength}, got an array of length ${xs.length}`,\n    );\n  }\n\n  return xs;\n};\n\n/**\n * Casts an array to `BoundedLengthArray<MinLength, MaxLength, E>` after\n * checking that its length is within the inclusive range\n * `[minLength, maxLength]`.\n *\n * Use this instead of writing\n * `xs as unknown as BoundedLengthArray<Min, Max, E>`: the length is verified\n * at runtime, and the original array type (e.g. tuple types) is preserved via\n * intersection.\n *\n * @example\n *\n * ```ts\n * const selection = Arr.asBoundedLengthArray([1, 2, 3], 1, 5);\n *\n * const relaxed: BoundedLengthArray<0, 100, number> = selection; // OK\n *\n * // Arr.asBoundedLengthArray([], 1, 5); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template MinLength - The minimum number of elements (inclusive).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param minLength - The minimum number of elements (inclusive).\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `xs` typed as\n *   `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length < minLength || xs.length > maxLength`.\n */\nexport const asBoundedLengthArray = <\n  Xs extends readonly unknown[],\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n>(\n  xs: Xs,\n  minLength: MinLength,\n  maxLength: MaxLength,\n): BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs => {\n  if (!isBoundedLengthArray(xs, minLength, maxLength)) {\n    throw new TypeError(\n      `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${xs.length}`,\n    );\n  }\n\n  return xs;\n};\n"],"names":[],"mappings":";;AA0CO,MAAM,kBAAA,GAAqB,CAIhC,EAAA,EACA,MAAA,KAC8C;AAC9C,EAAA,IAAI,CAAC,kBAAA,CAAmB,EAAA,EAAI,MAAM,CAAA,EAAG;AACnC,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,CAAA,4BAAA,EAA+B,MAAM,CAAA,yBAAA,EAA4B,EAAA,CAAG,MAAM,CAAA;AAAA,KAC5E;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT;AA8BO,MAAM,gBAAA,GAAmB,CAI9B,EAAA,EACA,SAAA,KAC+C;AAC/C,EAAA,IAAI,CAAC,gBAAA,CAAiB,EAAA,EAAI,SAAS,CAAA,EAAG;AACpC,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,CAAA,+BAAA,EAAkC,SAAS,CAAA,yBAAA,EAA4B,EAAA,CAAG,MAAM,CAAA;AAAA,KAClF;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT;AA2BO,MAAM,gBAAA,GAAmB,CAI9B,EAAA,EACA,SAAA,KAC+C;AAC/C,EAAA,IAAI,CAAC,gBAAA,CAAiB,EAAA,EAAI,SAAS,CAAA,EAAG;AACpC,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,CAAA,+BAAA,EAAkC,SAAS,CAAA,yBAAA,EAA4B,EAAA,CAAG,MAAM,CAAA;AAAA,KAClF;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT;AAgCO,MAAM,oBAAA,GAAuB,CAKlC,EAAA,EACA,SAAA,EACA,SAAA,KAC8D;AAC9D,EAAA,IAAI,CAAC,oBAAA,CAAqB,EAAA,EAAI,SAAA,EAAW,SAAS,CAAA,EAAG;AACnD,IAAA,MAAM,IAAI,SAAA;AAAA,MACR,mCAAmC,SAAS,CAAA,EAAA,EAAK,SAAS,CAAA,0BAAA,EAA6B,GAAG,MAAM,CAAA;AAAA,KAClG;AAAA,EACF;AAEA,EAAA,OAAO,EAAA;AACT;;;;"}
+{"version":3,"file":"array-utils-length-bounded-array-cast.mjs","sources":["../../../src/array/impl/array-utils-length-bounded-array-cast.mts"],"sourcesContent":["import {\n  type BoundedLengthArray,\n  type FixedLengthArray,\n  type MaxLengthArray,\n  type MinLengthArray,\n  type NonEmptyArray,\n  type SupportedLength,\n} from 'ts-type-forge';\nimport {\n  isBoundedLengthArray,\n  isFixedLengthArray,\n  isMaxLengthArray,\n  isMinLengthArray,\n} from './array-utils-length-bounded-array-guard.mjs';\n\n/**\n * Casts an array to `FixedLengthArray<Length, E>` after checking that it has\n * exactly `length` elements.\n *\n * Use this instead of writing `xs as unknown as FixedLengthArray<N, E>`: the\n * length is verified at runtime, and the original array type (e.g. tuple\n * types) is preserved via intersection, so the result also benefits from the\n * structural tuple prefix (in-range indexed access without `undefined` under\n * `noUncheckedIndexedAccess`).\n *\n * Supports a curried overload: calling it with only `length` returns a\n * function that casts an array, which is convenient for `pipe`/`map`.\n *\n * @example\n *\n * ```ts\n * const rgb = Arr.asFixedLengthArray([255, 128, 0], 3);\n *\n * const atMost5: MaxLengthArray<5, number> = rgb; // OK (3 <= 5)\n * const red: number = rgb[0]; // OK — no `undefined`\n *\n * // curried version\n * const asRgb = Arr.asFixedLengthArray(3);\n * const green = asRgb([0, 255, 0]);\n *\n * // Arr.asFixedLengthArray([255, 128], 3); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template Length - The exact number of elements.\n * @param xs - The array to cast.\n * @param length - The exact number of elements.\n * @returns `xs` typed as `FixedLengthArray<Length, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length !== length`.\n */\nexport function asFixedLengthArray<\n  Xs extends readonly unknown[],\n  Length extends SupportedLength,\n>(xs: Xs, length: Length): FixedLengthArray<Length, Xs[number]> & Xs;\n\n// Curried version\nexport function asFixedLengthArray<Length extends SupportedLength>(\n  length: Length,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => FixedLengthArray<Length, Xs[number]> & Xs;\n\nexport function asFixedLengthArray<E>(\n  ...args:\n    | readonly [xs: readonly E[], length: SupportedLength]\n    | readonly [length: SupportedLength]\n): readonly E[] | ((xs: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [xs, length] = args;\n\n      if (!isFixedLengthArray(xs, length)) {\n        throw new TypeError(\n          `Expected an array of length ${length}, got an array of length ${xs.length}`,\n        );\n      }\n\n      return xs;\n    }\n\n    case 1: {\n      const [length] = args;\n\n      return (xs) => asFixedLengthArray(xs, length);\n    }\n  }\n}\n\n/**\n * Casts an array to `MinLengthArray<MinLength, E>` after checking that it has\n * at least `minLength` elements.\n *\n * Use this instead of writing `xs as unknown as MinLengthArray<N, E>`: the\n * length is verified at runtime, and the original array type (e.g. tuple\n * types) is preserved via intersection, so the result also benefits from the\n * structural tuple prefix (indexed access below `min(N, 10)` without\n * `undefined` under `noUncheckedIndexedAccess`).\n *\n * Supports a curried overload: calling it with only `minLength` returns a\n * function that casts an array, which is convenient for `pipe`/`map`.\n *\n * @example\n *\n * ```ts\n * const history = Arr.asMinLengthArray([0, 1, 2, 3], 3);\n *\n * const nonEmpty: MinLengthArray<1, number> = history; // OK (3 >= 1)\n * const first: number = history[0]; // OK — no `undefined`\n *\n * // curried version\n * const asHistory = Arr.asMinLengthArray(3);\n * const next = asHistory([4, 5, 6, 7]);\n *\n * // Arr.asMinLengthArray([0], 3); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template MinLength - The minimum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param minLength - The minimum number of elements (inclusive).\n * @returns `xs` typed as `MinLengthArray<MinLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length < minLength`.\n */\nexport function asMinLengthArray<\n  Xs extends readonly unknown[],\n  MinLength extends SupportedLength,\n>(xs: Xs, minLength: MinLength): MinLengthArray<MinLength, Xs[number]> & Xs;\n\n// Curried version\nexport function asMinLengthArray<MinLength extends SupportedLength>(\n  minLength: MinLength,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => MinLengthArray<MinLength, Xs[number]> & Xs;\n\nexport function asMinLengthArray<E>(\n  ...args:\n    | readonly [xs: readonly E[], minLength: SupportedLength]\n    | readonly [minLength: SupportedLength]\n): readonly E[] | ((xs: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [xs, minLength] = args;\n\n      if (!isMinLengthArray(xs, minLength)) {\n        throw new TypeError(\n          `Expected an array of length >= ${minLength}, got an array of length ${xs.length}`,\n        );\n      }\n\n      return xs;\n    }\n\n    case 1: {\n      const [minLength] = args;\n\n      return (xs) => asMinLengthArray(xs, minLength);\n    }\n  }\n}\n\n/**\n * Casts an array to `MaxLengthArray<MaxLength, E>` after checking that it has\n * at most `maxLength` elements.\n *\n * Use this instead of writing `xs as unknown as MaxLengthArray<N, E>`: the\n * length is verified at runtime, and the original array type (e.g. tuple\n * types) is preserved via intersection.\n *\n * Supports a curried overload: calling it with only `maxLength` returns a\n * function that casts an array, which is convenient for `pipe`/`map`.\n *\n * @example\n *\n * ```ts\n * const tags = Arr.asMaxLengthArray(['a', 'b', 'c'], 8);\n *\n * const relaxed: MaxLengthArray<16, string> = tags; // OK (8 <= 16)\n *\n * // curried version\n * const asTags = Arr.asMaxLengthArray(8);\n * const more = asTags(['d', 'e']);\n *\n * // Arr.asMaxLengthArray(['a', 'b', 'c'], 2); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `xs` typed as `MaxLengthArray<MaxLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length > maxLength`.\n */\nexport function asMaxLengthArray<\n  Xs extends readonly unknown[],\n  MaxLength extends SupportedLength,\n>(xs: Xs, maxLength: MaxLength): MaxLengthArray<MaxLength, Xs[number]> & Xs;\n\n// Curried version\nexport function asMaxLengthArray<MaxLength extends SupportedLength>(\n  maxLength: MaxLength,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => MaxLengthArray<MaxLength, Xs[number]> & Xs;\n\nexport function asMaxLengthArray<E>(\n  ...args:\n    | readonly [xs: readonly E[], maxLength: SupportedLength]\n    | readonly [maxLength: SupportedLength]\n): readonly E[] | ((xs: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 2: {\n      const [xs, maxLength] = args;\n\n      if (!isMaxLengthArray(xs, maxLength)) {\n        throw new TypeError(\n          `Expected an array of length <= ${maxLength}, got an array of length ${xs.length}`,\n        );\n      }\n\n      return xs;\n    }\n\n    case 1: {\n      const [maxLength] = args;\n\n      return (xs) => asMaxLengthArray(xs, maxLength);\n    }\n  }\n}\n\n/**\n * Casts an array to `BoundedLengthArray<MinLength, MaxLength, E>` after\n * checking that its length is within the inclusive range\n * `[minLength, maxLength]`.\n *\n * Use this instead of writing\n * `xs as unknown as BoundedLengthArray<Min, Max, E>`: the length is verified\n * at runtime, and the original array type (e.g. tuple types) is preserved via\n * intersection.\n *\n * Supports a curried overload: calling it with only `minLength` and\n * `maxLength` returns a function that casts an array, which is convenient for\n * `pipe`/`map`.\n *\n * @example\n *\n * ```ts\n * const selection = Arr.asBoundedLengthArray([1, 2, 3], 1, 5);\n *\n * const relaxed: BoundedLengthArray<0, 100, number> = selection; // OK\n *\n * // curried version\n * const asSelection = Arr.asBoundedLengthArray(1, 5);\n * const next = asSelection([4, 5]);\n *\n * // Arr.asBoundedLengthArray([], 1, 5); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @template MinLength - The minimum number of elements (inclusive).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @param xs - The array to cast.\n * @param minLength - The minimum number of elements (inclusive).\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `xs` typed as\n *   `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.\n * @throws {TypeError} If `xs.length < minLength || xs.length > maxLength`.\n */\nexport function asBoundedLengthArray<\n  Xs extends readonly unknown[],\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n>(\n  xs: Xs,\n  minLength: MinLength,\n  maxLength: MaxLength,\n): BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;\n\n// Curried version\nexport function asBoundedLengthArray<\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n>(\n  minLength: MinLength,\n  maxLength: MaxLength,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;\n\nexport function asBoundedLengthArray<E>(\n  ...args:\n    | readonly [\n        xs: readonly E[],\n        minLength: SupportedLength,\n        maxLength: SupportedLength,\n      ]\n    | readonly [minLength: SupportedLength, maxLength: SupportedLength]\n): readonly E[] | ((xs: readonly E[]) => readonly E[]) {\n  switch (args.length) {\n    case 3: {\n      const [xs, minLength, maxLength] = args;\n\n      if (!isBoundedLengthArray(xs, minLength, maxLength)) {\n        throw new TypeError(\n          `Expected an array of length in [${minLength}, ${maxLength}], got an array of length ${xs.length}`,\n        );\n      }\n\n      return xs;\n    }\n\n    case 2: {\n      const [minLength, maxLength] = args;\n\n      return (xs) => asBoundedLengthArray(xs, minLength, maxLength);\n    }\n  }\n}\n\n/**\n * Casts an array to `NonEmptyArray<E>` after checking that it has at least one\n * element.\n *\n * `NonEmptyArray<E>` is an alias of `MinLengthArray<1, E>`, so this is the\n * length-1 specialization of {@link asMinLengthArray}. Use this instead of\n * writing `xs as unknown as NonEmptyArray<E>`: the length is verified at\n * runtime, and the original array type (e.g. tuple types) is preserved via\n * intersection, so the result also benefits from the structural tuple prefix\n * (`xs[0]` without `undefined` under `noUncheckedIndexedAccess`).\n *\n * @example\n *\n * ```ts\n * const history = Arr.asNonEmptyArray([0, 1, 2, 3]);\n *\n * const first: number = history[0]; // OK — no `undefined`\n *\n * // Arr.asNonEmptyArray([]); // throws TypeError\n * ```\n *\n * @template Xs - The input array type (tuple types are preserved).\n * @param xs - The array to cast.\n * @returns `xs` typed as `NonEmptyArray<Xs[number]> & Xs`.\n * @throws {TypeError} If `xs` is empty.\n */\nexport const asNonEmptyArray = <Xs extends readonly unknown[]>(\n  xs: Xs,\n): NonEmptyArray<Xs[number]> & Xs => {\n  if (!isMinLengthArray(xs, 1)) {\n    throw new TypeError('Expected a non-empty array, got an empty array');\n  }\n\n  return xs;\n};\n"],"names":[],"mappings":";;AA8DO,SAAS,sBACX,IAAA,EAGkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,EAAA,EAAI,MAAM,CAAA,GAAI,IAAA;AAErB,MAAA,IAAI,CAAC,kBAAA,CAAmB,EAAA,EAAI,MAAM,CAAA,EAAG;AACnC,QAAA,MAAM,IAAI,SAAA;AAAA,UACR,CAAA,4BAAA,EAA+B,MAAM,CAAA,yBAAA,EAA4B,EAAA,CAAG,MAAM,CAAA;AAAA,SAC5E;AAAA,MACF;AAEA,MAAA,OAAO,EAAA;AAAA,IACT;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,MAAM,CAAA,GAAI,IAAA;AAEjB,MAAA,OAAO,CAAC,EAAA,KAAO,kBAAA,CAAmB,EAAA,EAAI,MAAM,CAAA;AAAA,IAC9C;AAAA;AAEJ;AAiDO,SAAS,oBACX,IAAA,EAGkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,EAAA,EAAI,SAAS,CAAA,GAAI,IAAA;AAExB,MAAA,IAAI,CAAC,gBAAA,CAAiB,EAAA,EAAI,SAAS,CAAA,EAAG;AACpC,QAAA,MAAM,IAAI,SAAA;AAAA,UACR,CAAA,+BAAA,EAAkC,SAAS,CAAA,yBAAA,EAA4B,EAAA,CAAG,MAAM,CAAA;AAAA,SAClF;AAAA,MACF;AAEA,MAAA,OAAO,EAAA;AAAA,IACT;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,EAAA,KAAO,gBAAA,CAAiB,EAAA,EAAI,SAAS,CAAA;AAAA,IAC/C;AAAA;AAEJ;AA8CO,SAAS,oBACX,IAAA,EAGkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,EAAA,EAAI,SAAS,CAAA,GAAI,IAAA;AAExB,MAAA,IAAI,CAAC,gBAAA,CAAiB,EAAA,EAAI,SAAS,CAAA,EAAG;AACpC,QAAA,MAAM,IAAI,SAAA;AAAA,UACR,CAAA,+BAAA,EAAkC,SAAS,CAAA,yBAAA,EAA4B,EAAA,CAAG,MAAM,CAAA;AAAA,SAClF;AAAA,MACF;AAEA,MAAA,OAAO,EAAA;AAAA,IACT;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAS,CAAA,GAAI,IAAA;AAEpB,MAAA,OAAO,CAAC,EAAA,KAAO,gBAAA,CAAiB,EAAA,EAAI,SAAS,CAAA;AAAA,IAC/C;AAAA;AAEJ;AA6DO,SAAS,wBACX,IAAA,EAOkD;AACrD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,EAAA,EAAI,SAAA,EAAW,SAAS,CAAA,GAAI,IAAA;AAEnC,MAAA,IAAI,CAAC,oBAAA,CAAqB,EAAA,EAAI,SAAA,EAAW,SAAS,CAAA,EAAG;AACnD,QAAA,MAAM,IAAI,SAAA;AAAA,UACR,mCAAmC,SAAS,CAAA,EAAA,EAAK,SAAS,CAAA,0BAAA,EAA6B,GAAG,MAAM,CAAA;AAAA,SAClG;AAAA,MACF;AAEA,MAAA,OAAO,EAAA;AAAA,IACT;AAAA,IAEA,KAAK,CAAA,EAAG;AACN,MAAA,MAAM,CAAC,SAAA,EAAW,SAAS,CAAA,GAAI,IAAA;AAE/B,MAAA,OAAO,CAAC,EAAA,KAAO,oBAAA,CAAqB,EAAA,EAAI,WAAW,SAAS,CAAA;AAAA,IAC9D;AAAA;AAEJ;AA4BO,MAAM,eAAA,GAAkB,CAC7B,EAAA,KACmC;AACnC,EAAA,IAAI,CAAC,gBAAA,CAAiB,EAAA,EAAI,CAAC,CAAA,EAAG;AAC5B,IAAA,MAAM,IAAI,UAAU,gDAAgD,CAAA;AAAA,EACtE;AAEA,EAAA,OAAO,EAAA;AACT;;;;"}

package/dist/array/impl/index.mjs

@@ -1,7 +1,7 @@
 export { copy, create, generate, generateAsync, newArray, range, seq, zeros } from './array-utils-creation.mjs';
 export { at, first, head, last } from './array-utils-element-access.mjs';
 export { entries, indices, keys, values } from './array-utils-iterators.mjs';
-export { asBoundedLengthArray, asFixedLengthArray, asMaxLengthArray, asMinLengthArray } from './array-utils-length-bounded-array-cast.mjs';
+export { asBoundedLengthArray, asFixedLengthArray, asMaxLengthArray, asMinLengthArray, asNonEmptyArray } from './array-utils-length-bounded-array-cast.mjs';
 export { isBoundedLengthArray, isFixedLengthArray, isMaxLengthArray, isMinLengthArray } from './array-utils-length-bounded-array-guard.mjs';
 export { set, toFilled, toInserted, toPushed, toRangeFilled, toRemoved, toUnshifted, toUpdated } from './array-utils-modification.mjs';
 export { count, countBy, foldl, foldr, join, max, maxBy, min, minBy, reduce, reduceRight, sum, sumBy } from './array-utils-reducing-value.mjs';

package/dist/string/str.d.mts

@@ -1,4 +1,4 @@
-import { type BoundedLengthString, type FixedLengthString, type MaxLengthString, type MinLengthString, type SupportedLength } from 'ts-type-forge';
+import { type BoundedLengthString, type FixedLengthString, type MaxLengthString, type MinLengthString, type NonEmptyString, type SupportedLength } from 'ts-type-forge';
 /**
  * Namespace providing type guards and runtime-checked casts for the branded
  * length-constrained string types (`MinLengthString`, `MaxLengthString`,
@@ -162,6 +162,9 @@ export declare namespace Str {
      * length is verified at runtime, and the original string type (e.g. literal
      * types) is preserved via intersection.
      *
+     * Supports a curried overload: calling it with only `minLength` returns a
+     * function that casts a string, which is convenient for `pipe`/`map`.
+     *
      * @example
      *
      * ```ts
@@ -171,6 +174,11 @@ export declare namespace Str {
      *
      * assert.isTrue(nonEmpty.length >= 12);
      *
+     * // curried version
+     * const asPassword = Str.asMinLengthString(12);
+     *
+     * assert.strictEqual(asPassword('another-secret'), 'another-secret');
+     *
      * assert.throws(() => Str.asMinLengthString('short', 12)); // length 5 < 12
      * ```
      *
@@ -181,7 +189,8 @@ export declare namespace Str {
      * @returns `s` typed as `MinLengthString<MinLength> & S`.
      * @throws {TypeError} If `s.length < minLength`.
      */
-    const asMinLengthString: <S extends string, MinLength extends SupportedLength>(s: S, minLength: MinLength) => MinLengthString<MinLength> & S;
+    function asMinLengthString<S extends string, MinLength extends SupportedLength>(s: S, minLength: MinLength): MinLengthString<MinLength> & S;
+    function asMinLengthString<MinLength extends SupportedLength>(minLength: MinLength): <S extends string>(s: S) => MinLengthString<MinLength> & S;
     /**
      * Casts a string to `MaxLengthString<MaxLength>` after checking that it has
      * at most `maxLength` characters.
@@ -190,6 +199,9 @@ export declare namespace Str {
      * length is verified at runtime, and the original string type (e.g. literal
      * types) is preserved via intersection.
      *
+     * Supports a curried overload: calling it with only `maxLength` returns a
+     * function that casts a string, which is convenient for `pipe`/`map`.
+     *
      * @example
      *
      * ```ts
@@ -199,6 +211,11 @@ export declare namespace Str {
      *
      * assert.isTrue(relaxed.length <= 32);
      *
+     * // curried version
+     * const asUserName = Str.asMaxLengthString(32);
+     *
+     * assert.strictEqual(asUserName('another-user'), 'another-user');
+     *
      * assert.throws(() => Str.asMaxLengthString('noshiro', 3)); // length 7 > 3
      * ```
      *
@@ -209,7 +226,8 @@ export declare namespace Str {
      * @returns `s` typed as `MaxLengthString<MaxLength> & S`.
      * @throws {TypeError} If `s.length > maxLength`.
      */
-    const asMaxLengthString: <S extends string, MaxLength extends SupportedLength>(s: S, maxLength: MaxLength) => MaxLengthString<MaxLength> & S;
+    function asMaxLengthString<S extends string, MaxLength extends SupportedLength>(s: S, maxLength: MaxLength): MaxLengthString<MaxLength> & S;
+    function asMaxLengthString<MaxLength extends SupportedLength>(maxLength: MaxLength): <S extends string>(s: S) => MaxLengthString<MaxLength> & S;
     /**
      * Casts a string to `BoundedLengthString<MinLength, MaxLength>` after
      * checking that its length is within the inclusive range
@@ -219,6 +237,10 @@ export declare namespace Str {
      * the length is verified at runtime, and the original string type (e.g.
      * literal types) is preserved via intersection.
      *
+     * Supports a curried overload: calling it with only `minLength` and
+     * `maxLength` returns a function that casts a string, which is convenient for
+     * `pipe`/`map`.
+     *
      * @example
      *
      * ```ts
@@ -228,6 +250,11 @@ export declare namespace Str {
      *
      * assert.isTrue(relaxed.length >= 8 && relaxed.length <= 16);
      *
+     * // curried version
+     * const asUserId = Str.asBoundedLengthString(8, 16);
+     *
+     * assert.strictEqual(asUserId('user-87654321'), 'user-87654321');
+     *
      * assert.throws(() => Str.asBoundedLengthString('user', 8, 16)); // length 4 < 8
      * ```
      *
@@ -240,7 +267,8 @@ export declare namespace Str {
      * @returns `s` typed as `BoundedLengthString<MinLength, MaxLength> & S`.
      * @throws {TypeError} If `s.length < minLength` or `s.length > maxLength`.
      */
-    const asBoundedLengthString: <S extends string, MinLength extends SupportedLength, MaxLength extends SupportedLength>(s: S, minLength: MinLength, maxLength: MaxLength) => BoundedLengthString<MinLength, MaxLength> & S;
+    function asBoundedLengthString<S extends string, MinLength extends SupportedLength, MaxLength extends SupportedLength>(s: S, minLength: MinLength, maxLength: MaxLength): BoundedLengthString<MinLength, MaxLength> & S;
+    function asBoundedLengthString<MinLength extends SupportedLength, MaxLength extends SupportedLength>(minLength: MinLength, maxLength: MaxLength): <S extends string>(s: S) => BoundedLengthString<MinLength, MaxLength> & S;
     /**
      * Casts a string to `FixedLengthString<Length>` after checking that it has
      * exactly `length` characters.
@@ -249,6 +277,9 @@ export declare namespace Str {
      * length is verified at runtime, and the original string type (e.g. literal
      * types) is preserved via intersection.
      *
+     * Supports a curried overload: calling it with only `length` returns a
+     * function that casts a string, which is convenient for `pipe`/`map`.
+     *
      * @example
      *
      * ```ts
@@ -258,6 +289,11 @@ export declare namespace Str {
      *
      * assert.isTrue(atMost5.length === 2);
      *
+     * // curried version
+     * const asCountryCode = Str.asFixedLengthString(2);
+     *
+     * assert.strictEqual(asCountryCode('US'), 'US');
+     *
      * assert.throws(() => Str.asFixedLengthString('JP', 3)); // length 2 !== 3
      * ```
      *
@@ -268,6 +304,35 @@ export declare namespace Str {
      * @returns `s` typed as `FixedLengthString<Length> & S`.
      * @throws {TypeError} If `s.length !== length`.
      */
-    const asFixedLengthString: <S extends string, Length extends SupportedLength>(s: S, length: Length) => FixedLengthString<Length> & S;
+    function asFixedLengthString<S extends string, Length extends SupportedLength>(s: S, length: Length): FixedLengthString<Length> & S;
+    function asFixedLengthString<Length extends SupportedLength>(length: Length): <S extends string>(s: S) => FixedLengthString<Length> & 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.
+     */
+    const asNonEmptyString: <S extends string>(s: S) => NonEmptyString & S;
 }
 //# sourceMappingURL=str.d.mts.map

package/dist/string/str.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"str.d.mts","sourceRoot":"","sources":["../../src/string/str.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;;;;;;;;GAQG;AACH,yBAAiB,GAAG,CAAC;IACnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACI,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,KACnB,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAA0B,CAAC;IAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACI,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,KACnB,CAAC,IAAI,eAAe,CAAC,SAAS,CAAC,GAAG,CAA0B,CAAC;IAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACI,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;IAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACI,MAAM,mBAAmB,GAC9B,CAAC,SAAS,MAAM,EAChB,MAAM,SAAS,eAAe,KAE3B,CAAC,UACI,MAAM,KACb,CAAC,IAAI,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAwB,CAAC;IAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACI,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,KACnB,eAAe,CAAC,SAAS,CAAC,GAAG,CAQ/B,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACI,MAAM,iBAAiB,GAC5B,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,KACnB,eAAe,CAAC,SAAS,CAAC,GAAG,CAQ/B,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACI,MAAM,qBAAqB,GAChC,CAAC,SAAS,MAAM,EAChB,SAAS,SAAS,eAAe,EACjC,SAAS,SAAS,eAAe,KAE9B,CAAC,aACO,SAAS,aACT,SAAS,KACnB,mBAAmB,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,CAQ9C,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACI,MAAM,mBAAmB,GAC9B,CAAC,SAAS,MAAM,EAChB,MAAM,SAAS,eAAe,KAE3B,CAAC,UACI,MAAM,KACb,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAQ9B,CAAC;CACH"}
+{"version":3,"file":"str.d.mts","sourceRoot":"","sources":["../../src/string/str.mts"],"names":[],"mappings":"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"}

package/dist/string/str.mjs

@@ -4,35 +4,81 @@ var Str;
   Str2.isMaxLengthString = (s, maxLength) => s.length <= maxLength;
   Str2.isBoundedLengthString = (s, minLength, maxLength) => s.length >= minLength && s.length <= maxLength;
   Str2.isFixedLengthString = (s, length) => s.length === length;
-  Str2.asMinLengthString = (s, minLength) => {
-    if (!(0, Str2.isMinLengthString)(s, minLength)) {
-      throw new TypeError(
-        `Expected a string of length >= ${minLength}, got a string of length ${s.length}`
-      );
+  function asMinLengthString(...args) {
+    switch (args.length) {
+      case 2: {
+        const [s, minLength] = args;
+        if (!(0, Str2.isMinLengthString)(s, minLength)) {
+          throw new TypeError(
+            `Expected a string of length >= ${minLength}, got a string of length ${s.length}`
+          );
+        }
+        return s;
+      }
+      case 1: {
+        const [minLength] = args;
+        return (s) => asMinLengthString(s, minLength);
+      }
     }
-    return s;
-  };
-  Str2.asMaxLengthString = (s, maxLength) => {
-    if (!(0, Str2.isMaxLengthString)(s, maxLength)) {
-      throw new TypeError(
-        `Expected a string of length <= ${maxLength}, got a string of length ${s.length}`
-      );
+  }
+  Str2.asMinLengthString = asMinLengthString;
+  function asMaxLengthString(...args) {
+    switch (args.length) {
+      case 2: {
+        const [s, maxLength] = args;
+        if (!(0, Str2.isMaxLengthString)(s, maxLength)) {
+          throw new TypeError(
+            `Expected a string of length <= ${maxLength}, got a string of length ${s.length}`
+          );
+        }
+        return s;
+      }
+      case 1: {
+        const [maxLength] = args;
+        return (s) => asMaxLengthString(s, maxLength);
+      }
     }
-    return s;
-  };
-  Str2.asBoundedLengthString = (s, minLength, maxLength) => {
-    if (!(0, Str2.isBoundedLengthString)(s, minLength, maxLength)) {
-      throw new TypeError(
-        `Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${s.length}`
-      );
+  }
+  Str2.asMaxLengthString = asMaxLengthString;
+  function asBoundedLengthString(...args) {
+    switch (args.length) {
+      case 3: {
+        const [s, minLength, maxLength] = args;
+        if (!(0, Str2.isBoundedLengthString)(s, minLength, maxLength)) {
+          throw new TypeError(
+            `Expected a string of length in [${minLength}, ${maxLength}], got a string of length ${s.length}`
+          );
+        }
+        return s;
+      }
+      case 2: {
+        const [minLength, maxLength] = args;
+        return (s) => asBoundedLengthString(s, minLength, maxLength);
+      }
     }
-    return s;
-  };
-  Str2.asFixedLengthString = (s, length) => {
-    if (!(0, Str2.isFixedLengthString)(s, length)) {
-      throw new TypeError(
-        `Expected a string of length ${length}, got a string of length ${s.length}`
-      );
+  }
+  Str2.asBoundedLengthString = asBoundedLengthString;
+  function asFixedLengthString(...args) {
+    switch (args.length) {
+      case 2: {
+        const [s, length] = args;
+        if (!(0, Str2.isFixedLengthString)(s, length)) {
+          throw new TypeError(
+            `Expected a string of length ${length}, got a string of length ${s.length}`
+          );
+        }
+        return s;
+      }
+      case 1: {
+        const [length] = args;
+        return (s) => asFixedLengthString(s, length);
+      }
+    }
+  }
+  Str2.asFixedLengthString = asFixedLengthString;
+  Str2.asNonEmptyString = (s) => {
+    if (!(0, Str2.isMinLengthString)(s, 1)) {
+      throw new TypeError("Expected a non-empty string, got an empty string");
     }
     return s;
   };