ts-data-forge 12.2.2 → 14.0.0

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

@@ -13,30 +13,44 @@ import { type BoundedLengthArray, type FixedLengthArray, type MaxLengthArray, ty
  *   example, a value narrowed to `MinLengthArray<3, E>` is assignable to
  *   `MinLengthArray<1, E>`.
  *
+ * The length argument comes first, matching the type-parameter order of
+ * `MinLengthArray<MinLength, Elm>`. Omitting the array returns a reusable type
+ * guard, which is convenient for `filter`/`pipe`.
+ *
  * @example
  *
  * ```ts
- * const input: readonly number[] = [0, 1, 2, 3];
+ * const input: readonly number[] = [0, 1, 2, 3] as const;
  *
- * assert.isTrue(Arr.isMinLengthArray(input, 3));
+ * assert.isTrue(Arr.isMinLengthArray(3, input));
  *
- * assert.isFalse(Arr.isMinLengthArray([0], 3));
+ * assert.isFalse(Arr.isMinLengthArray(3, [0]));
  *
- * if (Arr.isMinLengthArray(input, 3)) {
+ * if (Arr.isMinLengthArray(3, input)) {
  *   const history: MinLengthArray<3, number> = input;
  *
  *   const nonEmpty: MinLengthArray<1, number> = input; // OK (3 >= 1)
+ *
+ *   assert.deepStrictEqual(history[0], 0);
+ *
+ *   assert.deepStrictEqual(nonEmpty[0], 0);
  * }
+ *
+ * // curried version
+ * const hasThree = Arr.isMinLengthArray(3);
+ *
+ * assert.isTrue(hasThree(input));
  * ```
  *
- * @template Xs - The input array type (tuple types are preserved).
  * @template MinLength - The minimum number of elements (inclusive).
- * @param xs - The array to check.
+ * @template Xs - The input array type (tuple types are preserved).
  * @param minLength - The minimum number of elements (inclusive).
+ * @param xs - The array to check.
  * @returns `true` if `xs.length >= minLength`, `false` otherwise. When `true`,
  *   TypeScript narrows `xs` to `MinLengthArray<MinLength, Xs[number]> & Xs`.
  */
-export declare const isMinLengthArray: <Xs extends readonly unknown[], MinLength extends SupportedLength>(xs: Xs, minLength: MinLength) => xs is MinLengthArray<MinLength, Xs[number]> & Xs;
+export declare function isMinLengthArray<MinLength extends SupportedLength, Xs extends readonly unknown[]>(minLength: MinLength, xs: Xs): xs is MinLengthArray<MinLength, Xs[number]> & Xs;
+export declare function isMinLengthArray<MinLength extends SupportedLength>(minLength: MinLength): <Xs extends readonly unknown[]>(xs: Xs) => xs is MinLengthArray<MinLength, Xs[number]> & Xs;
 /**
  * Type guard that checks if an array has at most `maxLength` elements.
  *
@@ -51,30 +65,44 @@ export declare const isMinLengthArray: <Xs extends readonly unknown[], MinLength
  *   example, a value narrowed to `MaxLengthArray<8, E>` is assignable to
  *   `MaxLengthArray<16, E>`.
  *
+ * The length argument comes first, matching the type-parameter order of
+ * `MaxLengthArray<MaxLength, Elm>`. Omitting the array returns a reusable type
+ * guard, which is convenient for `filter`/`pipe`.
+ *
  * @example
  *
  * ```ts
- * const input: readonly string[] = ['a', 'b', 'c'];
+ * const input: readonly string[] = ['a', 'b', 'c'] as const;
  *
- * assert.isTrue(Arr.isMaxLengthArray(input, 8));
+ * assert.isTrue(Arr.isMaxLengthArray(8, input));
  *
- * assert.isFalse(Arr.isMaxLengthArray(input, 2));
+ * assert.isFalse(Arr.isMaxLengthArray(2, input));
  *
- * if (Arr.isMaxLengthArray(input, 8)) {
+ * if (Arr.isMaxLengthArray(8, input)) {
  *   const tags: MaxLengthArray<8, string> = input;
  *
  *   const relaxed: MaxLengthArray<16, string> = input; // OK (8 <= 16)
+ *
+ *   assert.deepStrictEqual(tags.length, 3);
+ *
+ *   assert.deepStrictEqual(relaxed.length, 3);
  * }
+ *
+ * // curried version
+ * const fitsInEight = Arr.isMaxLengthArray(8);
+ *
+ * assert.isTrue(fitsInEight(input));
  * ```
  *
- * @template Xs - The input array type (tuple types are preserved).
  * @template MaxLength - The maximum number of elements (inclusive).
- * @param xs - The array to check.
+ * @template Xs - The input array type (tuple types are preserved).
  * @param maxLength - The maximum number of elements (inclusive).
+ * @param xs - The array to check.
  * @returns `true` if `xs.length <= maxLength`, `false` otherwise. When `true`,
  *   TypeScript narrows `xs` to `MaxLengthArray<MaxLength, Xs[number]> & Xs`.
  */
-export declare const isMaxLengthArray: <Xs extends readonly unknown[], MaxLength extends SupportedLength>(xs: Xs, maxLength: MaxLength) => xs is MaxLengthArray<MaxLength, Xs[number]> & Xs;
+export declare function isMaxLengthArray<MaxLength extends SupportedLength, Xs extends readonly unknown[]>(maxLength: MaxLength, xs: Xs): xs is MaxLengthArray<MaxLength, Xs[number]> & Xs;
+export declare function isMaxLengthArray<MaxLength extends SupportedLength>(maxLength: MaxLength): <Xs extends readonly unknown[]>(xs: Xs) => xs is MaxLengthArray<MaxLength, Xs[number]> & Xs;
 /**
  * Type guard that checks if an array's length is within the inclusive range
  * `[minLength, maxLength]`.
@@ -90,33 +118,47 @@ export declare const isMaxLengthArray: <Xs extends readonly unknown[], MaxLength
  *   type checker even when the element type is large — unlike
  *   `isBoundedLengthTuple`, which narrows to a union of tuple types.
  *
+ * The length arguments come first, matching the type-parameter order of
+ * `BoundedLengthArray<MinLength, MaxLength, Elm>`. Omitting the array returns a
+ * reusable type guard, which is convenient for `filter`/`pipe`.
+ *
  * @example
  *
  * ```ts
- * const input: readonly number[] = [1, 2, 3];
+ * const input: readonly number[] = [1, 2, 3] as const;
  *
- * assert.isTrue(Arr.isBoundedLengthArray(input, 1, 5));
+ * assert.isTrue(Arr.isBoundedLengthArray(1, 5, input));
  *
- * assert.isFalse(Arr.isBoundedLengthArray([], 1, 5));
+ * assert.isFalse(Arr.isBoundedLengthArray(1, 5, []));
  *
- * if (Arr.isBoundedLengthArray(input, 1, 5)) {
+ * if (Arr.isBoundedLengthArray(1, 5, input)) {
  *   const selection: BoundedLengthArray<1, 5, number> = input;
  *
  *   const relaxed: BoundedLengthArray<0, 100, number> = input; // OK ([1, 5] ⊆ [0, 100])
+ *
+ *   assert.deepStrictEqual(selection[0], 1);
+ *
+ *   assert.deepStrictEqual(relaxed.length, 3);
  * }
+ *
+ * // curried version
+ * const isSmallSelection = Arr.isBoundedLengthArray(1, 5);
+ *
+ * assert.isTrue(isSmallSelection(input));
  * ```
  *
- * @template Xs - The input array type (tuple types are preserved).
  * @template MinLength - The minimum number of elements (inclusive).
  * @template MaxLength - The maximum number of elements (inclusive).
- * @param xs - The array to check.
+ * @template Xs - The input array type (tuple types are preserved).
  * @param minLength - The minimum number of elements (inclusive).
  * @param maxLength - The maximum number of elements (inclusive).
+ * @param xs - The array to check.
  * @returns `true` if `minLength <= xs.length && xs.length <= maxLength`,
  *   `false` otherwise. When `true`, TypeScript narrows `xs` to
  *   `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.
  */
-export declare const isBoundedLengthArray: <Xs extends readonly unknown[], MinLength extends SupportedLength, MaxLength extends SupportedLength>(xs: Xs, minLength: MinLength, maxLength: MaxLength) => xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
+export declare function isBoundedLengthArray<MinLength extends SupportedLength, MaxLength extends SupportedLength, Xs extends readonly unknown[]>(minLength: MinLength, maxLength: MaxLength, xs: Xs): xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
+export declare function isBoundedLengthArray<MinLength extends SupportedLength, MaxLength extends SupportedLength>(minLength: MinLength, maxLength: MaxLength): <Xs extends readonly unknown[]>(xs: Xs) => xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;
 /**
  * Type guard that checks if an array has exactly `length` elements.
  *
@@ -132,28 +174,84 @@ export declare const isBoundedLengthArray: <Xs extends readonly unknown[], MinLe
  *   type checker even when the element type is large — unlike
  *   `isFixedLengthTuple`, which narrows to a structural tuple type.
  *
+ * The length argument comes first, matching the type-parameter order of
+ * `FixedLengthArray<Length, Elm>`. Omitting the array returns a reusable type
+ * guard, which is convenient for `filter`/`pipe`.
+ *
  * @example
  *
  * ```ts
- * const input: readonly number[] = [255, 128, 0];
+ * const input: readonly number[] = [255, 128, 0] as const;
  *
- * assert.isTrue(Arr.isFixedLengthArray(input, 3));
+ * assert.isTrue(Arr.isFixedLengthArray(3, input));
  *
- * assert.isFalse(Arr.isFixedLengthArray(input, 4));
+ * assert.isFalse(Arr.isFixedLengthArray(4, input));
  *
- * if (Arr.isFixedLengthArray(input, 3)) {
+ * if (Arr.isFixedLengthArray(3, input)) {
  *   const rgb: FixedLengthArray<3, number> = input;
  *
  *   const atMost5: MaxLengthArray<5, number> = input; // OK (3 <= 5)
+ *
+ *   assert.deepStrictEqual(rgb[0], 255);
+ *
+ *   assert.deepStrictEqual(atMost5.length, 3);
  * }
+ *
+ * // curried version
+ * const isRgb = Arr.isFixedLengthArray(3);
+ *
+ * assert.isTrue(isRgb(input));
  * ```
  *
- * @template Xs - The input array type (tuple types are preserved).
  * @template Length - The exact number of elements.
- * @param xs - The array to check.
+ * @template Xs - The input array type (tuple types are preserved).
  * @param length - The exact number of elements.
+ * @param xs - The array to check.
  * @returns `true` if `xs.length === length`, `false` otherwise. When `true`,
  *   TypeScript narrows `xs` to `FixedLengthArray<Length, Xs[number]> & Xs`.
  */
-export declare const isFixedLengthArray: <Xs extends readonly unknown[], Length extends SupportedLength>(xs: Xs, length: Length) => xs is FixedLengthArray<Length, Xs[number]> & Xs;
+export declare function isFixedLengthArray<Length extends SupportedLength, Xs extends readonly unknown[]>(length: Length, xs: Xs): xs is FixedLengthArray<Length, Xs[number]> & Xs;
+export declare function isFixedLengthArray<Length extends SupportedLength>(length: Length): <Xs extends readonly unknown[]>(xs: Xs) => xs is FixedLengthArray<Length, Xs[number]> & Xs;
+/**
+ * Type guard that checks if an array is empty.
+ *
+ * @example
+ *
+ * ```ts
+ * const emptyNumbers: readonly number[] = [] as const;
+ *
+ * const words = ['Ada', 'Lovelace'] as const;
+ *
+ * assert.isTrue(Arr.isEmpty(emptyNumbers));
+ *
+ * assert.isFalse(Arr.isEmpty(words));
+ *
+ * if (Arr.isEmpty(emptyNumbers)) {
+ *   // `isEmpty` narrows to the branded `FixedLengthArray<0, number>`, so the
+ *   // expected value is annotated with the unbranded type.
+ *   assert.deepStrictEqual<readonly number[]>(emptyNumbers, []);
+ * }
+ * ```
+ */
+export declare const isEmpty: <Xs extends readonly unknown[]>(array: Xs) => array is FixedLengthArray<0, Xs[number]> & Xs;
+/**
+ * Type guard that checks if an array is non-empty.
+ *
+ * @example
+ *
+ * ```ts
+ * const users: readonly Readonly<{ id: number }>[] = [{ id: 1 }] as const;
+ *
+ * const emptyUsers: readonly Readonly<{ id: number }>[] = [] as const;
+ *
+ * assert.isTrue(Arr.isNonEmpty(users));
+ *
+ * assert.isFalse(Arr.isNonEmpty(emptyUsers));
+ *
+ * if (Arr.isNonEmpty(users)) {
+ *   assert.deepStrictEqual(users[0], { id: 1 });
+ * }
+ * ```
+ */
+export declare const isNonEmpty: <Xs extends readonly unknown[]>(array: Xs) => array is MinLengthArray<1, Xs[number]> & Xs;
 //# sourceMappingURL=array-utils-length-bounded-array-guard.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"array-utils-length-bounded-array-guard.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-length-bounded-array-guard.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,eAAe,EACrB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,gBAAgB,GAC3B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,MAE7B,EAAE,aACK,SAAS,KACnB,EAAE,IAAI,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAA4B,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,gBAAgB,GAC3B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,SAAS,SAAS,eAAe,MAE7B,EAAE,aACK,SAAS,KACnB,EAAE,IAAI,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAA4B,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;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,EAAE,IAAI,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EACd,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,kBAAkB,GAC7B,EAAE,SAAS,SAAS,OAAO,EAAE,EAC7B,MAAM,SAAS,eAAe,MAE1B,EAAE,UACE,MAAM,KACb,EAAE,IAAI,gBAAgB,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,EAA0B,CAAC"}
+{"version":3,"file":"array-utils-length-bounded-array-guard.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-length-bounded-array-guard.mts"],"names":[],"mappings":"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"}

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

@@ -1,7 +1,41 @@
-const isMinLengthArray = (xs, minLength) => xs.length >= minLength;
-const isMaxLengthArray = (xs, maxLength) => xs.length <= maxLength;
-const isBoundedLengthArray = (xs, minLength, maxLength) => xs.length >= minLength && xs.length <= maxLength;
-const isFixedLengthArray = (xs, length) => xs.length === length;
+function isMinLengthArray(...args) {
+  switch (args.length) {
+    case 2:
+      return hasMinLength(...args);
+    case 1:
+      return (xs) => hasMinLength(args[0], xs);
+  }
+}
+const hasMinLength = (minLength, xs) => xs.length >= minLength;
+function isMaxLengthArray(...args) {
+  switch (args.length) {
+    case 2:
+      return hasMaxLength(...args);
+    case 1:
+      return (xs) => hasMaxLength(args[0], xs);
+  }
+}
+const hasMaxLength = (maxLength, xs) => xs.length <= maxLength;
+function isBoundedLengthArray(...args) {
+  switch (args.length) {
+    case 3:
+      return hasBoundedLength(...args);
+    case 2:
+      return (xs) => hasBoundedLength(args[0], args[1], xs);
+  }
+}
+const hasBoundedLength = (minLength, maxLength, xs) => xs.length >= minLength && xs.length <= maxLength;
+function isFixedLengthArray(...args) {
+  switch (args.length) {
+    case 2:
+      return hasFixedLength(...args);
+    case 1:
+      return (xs) => hasFixedLength(args[0], xs);
+  }
+}
+const hasFixedLength = (length, xs) => xs.length === length;
+const isEmpty = (array) => array.length === 0;
+const isNonEmpty = (array) => array.length > 0;
 
-export { isBoundedLengthArray, isFixedLengthArray, isMaxLengthArray, isMinLengthArray };
+export { isBoundedLengthArray, isEmpty, isFixedLengthArray, isMaxLengthArray, isMinLengthArray, isNonEmpty };
 //# sourceMappingURL=array-utils-length-bounded-array-guard.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"array-utils-length-bounded-array-guard.mjs","sources":["../../../src/array/impl/array-utils-length-bounded-array-guard.mts"],"sourcesContent":["import {\n  type BoundedLengthArray,\n  type FixedLengthArray,\n  type MaxLengthArray,\n  type MinLengthArray,\n  type SupportedLength,\n} from 'ts-type-forge';\n\n/**\n * Type guard that checks if an array has at least `minLength` elements.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MinLengthArray<MinLength, E>` while preserving the\n *   original array type (e.g. tuple types) via intersection.\n * - The length constraint lives only in the brand, so this stays cheap for the\n *   type checker even when the element type is large — unlike\n *   `isMinLengthTuple`, which narrows to a structural tuple type.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MinLengthArray<3, E>` is assignable to\n *   `MinLengthArray<1, E>`.\n *\n * @example\n *\n * ```ts\n * const input: readonly number[] = [0, 1, 2, 3];\n *\n * assert.isTrue(Arr.isMinLengthArray(input, 3));\n *\n * assert.isFalse(Arr.isMinLengthArray([0], 3));\n *\n * if (Arr.isMinLengthArray(input, 3)) {\n *   const history: MinLengthArray<3, number> = input;\n *\n *   const nonEmpty: MinLengthArray<1, number> = input; // OK (3 >= 1)\n * }\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 check.\n * @param minLength - The minimum number of elements (inclusive).\n * @returns `true` if `xs.length >= minLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `xs` to `MinLengthArray<MinLength, Xs[number]> & Xs`.\n */\nexport const isMinLengthArray = <\n  Xs extends readonly unknown[],\n  MinLength extends SupportedLength,\n>(\n  xs: Xs,\n  minLength: MinLength,\n): xs is MinLengthArray<MinLength, Xs[number]> & Xs => xs.length >= minLength;\n\n/**\n * Type guard that checks if an array has at most `maxLength` elements.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MaxLengthArray<MaxLength, E>` while preserving the\n *   original array type (e.g. tuple types) via intersection.\n * - The length constraint lives only in the brand, so this stays cheap for the\n *   type checker even when the element type is large — unlike\n *   `isMaxLengthTuple`, which narrows to a union of tuple types.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MaxLengthArray<8, E>` is assignable to\n *   `MaxLengthArray<16, E>`.\n *\n * @example\n *\n * ```ts\n * const input: readonly string[] = ['a', 'b', 'c'];\n *\n * assert.isTrue(Arr.isMaxLengthArray(input, 8));\n *\n * assert.isFalse(Arr.isMaxLengthArray(input, 2));\n *\n * if (Arr.isMaxLengthArray(input, 8)) {\n *   const tags: MaxLengthArray<8, string> = input;\n *\n *   const relaxed: MaxLengthArray<16, string> = input; // OK (8 <= 16)\n * }\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 check.\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `true` if `xs.length <= maxLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `xs` to `MaxLengthArray<MaxLength, Xs[number]> & Xs`.\n */\nexport const isMaxLengthArray = <\n  Xs extends readonly unknown[],\n  MaxLength extends SupportedLength,\n>(\n  xs: Xs,\n  maxLength: MaxLength,\n): xs is MaxLengthArray<MaxLength, Xs[number]> & Xs => xs.length <= maxLength;\n\n/**\n * Type guard that checks if an array's length is within the inclusive range\n * `[minLength, maxLength]`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `BoundedLengthArray<MinLength, MaxLength, E>` while\n *   preserving the original array type (e.g. tuple types) via intersection.\n * - Since `BoundedLengthArray` is the intersection of `MinLengthArray` and\n *   `MaxLengthArray`, the narrowed value is assignable to both, and both\n *   bounds can be weakened independently.\n * - The length constraint lives only in the brand, so this stays cheap for the\n *   type checker even when the element type is large — unlike\n *   `isBoundedLengthTuple`, which narrows to a union of tuple types.\n *\n * @example\n *\n * ```ts\n * const input: readonly number[] = [1, 2, 3];\n *\n * assert.isTrue(Arr.isBoundedLengthArray(input, 1, 5));\n *\n * assert.isFalse(Arr.isBoundedLengthArray([], 1, 5));\n *\n * if (Arr.isBoundedLengthArray(input, 1, 5)) {\n *   const selection: BoundedLengthArray<1, 5, number> = input;\n *\n *   const relaxed: BoundedLengthArray<0, 100, number> = input; // OK ([1, 5] ⊆ [0, 100])\n * }\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 check.\n * @param minLength - The minimum number of elements (inclusive).\n * @param maxLength - The maximum number of elements (inclusive).\n * @returns `true` if `minLength <= xs.length && xs.length <= maxLength`,\n *   `false` otherwise. When `true`, TypeScript narrows `xs` to\n *   `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.\n */\nexport const isBoundedLengthArray = <\n  Xs extends readonly unknown[],\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n>(\n  xs: Xs,\n  minLength: MinLength,\n  maxLength: MaxLength,\n): xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs =>\n  xs.length >= minLength && xs.length <= maxLength;\n\n/**\n * Type guard that checks if an array has exactly `length` elements.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `FixedLengthArray<Length, E>` while preserving the\n *   original array type (e.g. tuple types) via intersection.\n * - Since `FixedLengthArray<Length, E>` is defined as\n *   `BoundedLengthArray<Length, Length, E>`, the narrowed value is assignable\n *   to any `MinLengthArray<N, E>` with `N <= Length` and any\n *   `MaxLengthArray<N, E>` with `N >= Length`.\n * - The length constraint lives only in the brand, so this stays cheap for the\n *   type checker even when the element type is large — unlike\n *   `isFixedLengthTuple`, which narrows to a structural tuple type.\n *\n * @example\n *\n * ```ts\n * const input: readonly number[] = [255, 128, 0];\n *\n * assert.isTrue(Arr.isFixedLengthArray(input, 3));\n *\n * assert.isFalse(Arr.isFixedLengthArray(input, 4));\n *\n * if (Arr.isFixedLengthArray(input, 3)) {\n *   const rgb: FixedLengthArray<3, number> = input;\n *\n *   const atMost5: MaxLengthArray<5, number> = input; // OK (3 <= 5)\n * }\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 check.\n * @param length - The exact number of elements.\n * @returns `true` if `xs.length === length`, `false` otherwise. When `true`,\n *   TypeScript narrows `xs` to `FixedLengthArray<Length, Xs[number]> & Xs`.\n */\nexport const isFixedLengthArray = <\n  Xs extends readonly unknown[],\n  Length extends SupportedLength,\n>(\n  xs: Xs,\n  length: Length,\n): xs is FixedLengthArray<Length, Xs[number]> & Xs => xs.length === length;\n"],"names":[],"mappings":"AA6CO,MAAM,gBAAA,GAAmB,CAI9B,EAAA,EACA,SAAA,KACqD,GAAG,MAAA,IAAU;AAuC7D,MAAM,gBAAA,GAAmB,CAI9B,EAAA,EACA,SAAA,KACqD,GAAG,MAAA,IAAU;AA2C7D,MAAM,oBAAA,GAAuB,CAKlC,EAAA,EACA,SAAA,EACA,cAEA,EAAA,CAAG,MAAA,IAAU,SAAA,IAAa,EAAA,CAAG,MAAA,IAAU;AAwClC,MAAM,kBAAA,GAAqB,CAIhC,EAAA,EACA,MAAA,KACoD,GAAG,MAAA,KAAW;;;;"}
+{"version":3,"file":"array-utils-length-bounded-array-guard.mjs","sources":["../../../src/array/impl/array-utils-length-bounded-array-guard.mts"],"sourcesContent":["import {\n  type BoundedLengthArray,\n  type FixedLengthArray,\n  type MaxLengthArray,\n  type MinLengthArray,\n  type SupportedLength,\n} from 'ts-type-forge';\n\n/**\n * Type guard that checks if an array has at least `minLength` elements.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MinLengthArray<MinLength, E>` while preserving the\n *   original array type (e.g. tuple types) via intersection.\n * - The length constraint lives only in the brand, so this stays cheap for the\n *   type checker even when the element type is large — unlike\n *   `isMinLengthTuple`, which narrows to a structural tuple type.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MinLengthArray<3, E>` is assignable to\n *   `MinLengthArray<1, E>`.\n *\n * The length argument comes first, matching the type-parameter order of\n * `MinLengthArray<MinLength, Elm>`. Omitting the array returns a reusable type\n * guard, which is convenient for `filter`/`pipe`.\n *\n * @example\n *\n * ```ts\n * const input: readonly number[] = [0, 1, 2, 3] as const;\n *\n * assert.isTrue(Arr.isMinLengthArray(3, input));\n *\n * assert.isFalse(Arr.isMinLengthArray(3, [0]));\n *\n * if (Arr.isMinLengthArray(3, input)) {\n *   const history: MinLengthArray<3, number> = input;\n *\n *   const nonEmpty: MinLengthArray<1, number> = input; // OK (3 >= 1)\n *\n *   assert.deepStrictEqual(history[0], 0);\n *\n *   assert.deepStrictEqual(nonEmpty[0], 0);\n * }\n *\n * // curried version\n * const hasThree = Arr.isMinLengthArray(3);\n *\n * assert.isTrue(hasThree(input));\n * ```\n *\n * @template MinLength - The minimum number of elements (inclusive).\n * @template Xs - The input array type (tuple types are preserved).\n * @param minLength - The minimum number of elements (inclusive).\n * @param xs - The array to check.\n * @returns `true` if `xs.length >= minLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `xs` to `MinLengthArray<MinLength, Xs[number]> & Xs`.\n */\nexport function isMinLengthArray<\n  MinLength extends SupportedLength,\n  Xs extends readonly unknown[],\n>(\n  minLength: MinLength,\n  xs: Xs,\n): xs is MinLengthArray<MinLength, Xs[number]> & Xs;\n\n// Curried version\nexport function isMinLengthArray<MinLength extends SupportedLength>(\n  minLength: MinLength,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => xs is MinLengthArray<MinLength, Xs[number]> & Xs;\n\nexport function isMinLengthArray(\n  ...args:\n    | readonly [minLength: SupportedLength, xs: readonly unknown[]]\n    | readonly [minLength: SupportedLength]\n): boolean | ((xs: readonly unknown[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return hasMinLength(...args);\n\n    case 1:\n      return (xs) => hasMinLength(args[0], xs);\n  }\n}\n\nconst hasMinLength = (\n  minLength: SupportedLength,\n  xs: readonly unknown[],\n): boolean => xs.length >= minLength;\n\n/**\n * Type guard that checks if an array has at most `maxLength` elements.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `MaxLengthArray<MaxLength, E>` while preserving the\n *   original array type (e.g. tuple types) via intersection.\n * - The length constraint lives only in the brand, so this stays cheap for the\n *   type checker even when the element type is large — unlike\n *   `isMaxLengthTuple`, which narrows to a union of tuple types.\n * - The result participates in the length-constraint subtyping relation: for\n *   example, a value narrowed to `MaxLengthArray<8, E>` is assignable to\n *   `MaxLengthArray<16, E>`.\n *\n * The length argument comes first, matching the type-parameter order of\n * `MaxLengthArray<MaxLength, Elm>`. Omitting the array returns a reusable type\n * guard, which is convenient for `filter`/`pipe`.\n *\n * @example\n *\n * ```ts\n * const input: readonly string[] = ['a', 'b', 'c'] as const;\n *\n * assert.isTrue(Arr.isMaxLengthArray(8, input));\n *\n * assert.isFalse(Arr.isMaxLengthArray(2, input));\n *\n * if (Arr.isMaxLengthArray(8, input)) {\n *   const tags: MaxLengthArray<8, string> = input;\n *\n *   const relaxed: MaxLengthArray<16, string> = input; // OK (8 <= 16)\n *\n *   assert.deepStrictEqual(tags.length, 3);\n *\n *   assert.deepStrictEqual(relaxed.length, 3);\n * }\n *\n * // curried version\n * const fitsInEight = Arr.isMaxLengthArray(8);\n *\n * assert.isTrue(fitsInEight(input));\n * ```\n *\n * @template MaxLength - The maximum number of elements (inclusive).\n * @template Xs - The input array type (tuple types are preserved).\n * @param maxLength - The maximum number of elements (inclusive).\n * @param xs - The array to check.\n * @returns `true` if `xs.length <= maxLength`, `false` otherwise. When `true`,\n *   TypeScript narrows `xs` to `MaxLengthArray<MaxLength, Xs[number]> & Xs`.\n */\nexport function isMaxLengthArray<\n  MaxLength extends SupportedLength,\n  Xs extends readonly unknown[],\n>(\n  maxLength: MaxLength,\n  xs: Xs,\n): xs is MaxLengthArray<MaxLength, Xs[number]> & Xs;\n\n// Curried version\nexport function isMaxLengthArray<MaxLength extends SupportedLength>(\n  maxLength: MaxLength,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => xs is MaxLengthArray<MaxLength, Xs[number]> & Xs;\n\nexport function isMaxLengthArray(\n  ...args:\n    | readonly [maxLength: SupportedLength, xs: readonly unknown[]]\n    | readonly [maxLength: SupportedLength]\n): boolean | ((xs: readonly unknown[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return hasMaxLength(...args);\n\n    case 1:\n      return (xs) => hasMaxLength(args[0], xs);\n  }\n}\n\nconst hasMaxLength = (\n  maxLength: SupportedLength,\n  xs: readonly unknown[],\n): boolean => xs.length <= maxLength;\n\n/**\n * Type guard that checks if an array's length is within the inclusive range\n * `[minLength, maxLength]`.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `BoundedLengthArray<MinLength, MaxLength, E>` while\n *   preserving the original array type (e.g. tuple types) via intersection.\n * - Since `BoundedLengthArray` is the intersection of `MinLengthArray` and\n *   `MaxLengthArray`, the narrowed value is assignable to both, and both\n *   bounds can be weakened independently.\n * - The length constraint lives only in the brand, so this stays cheap for the\n *   type checker even when the element type is large — unlike\n *   `isBoundedLengthTuple`, which narrows to a union of tuple types.\n *\n * The length arguments come first, matching the type-parameter order of\n * `BoundedLengthArray<MinLength, MaxLength, Elm>`. Omitting the array returns a\n * reusable type guard, which is convenient for `filter`/`pipe`.\n *\n * @example\n *\n * ```ts\n * const input: readonly number[] = [1, 2, 3] as const;\n *\n * assert.isTrue(Arr.isBoundedLengthArray(1, 5, input));\n *\n * assert.isFalse(Arr.isBoundedLengthArray(1, 5, []));\n *\n * if (Arr.isBoundedLengthArray(1, 5, input)) {\n *   const selection: BoundedLengthArray<1, 5, number> = input;\n *\n *   const relaxed: BoundedLengthArray<0, 100, number> = input; // OK ([1, 5] ⊆ [0, 100])\n *\n *   assert.deepStrictEqual(selection[0], 1);\n *\n *   assert.deepStrictEqual(relaxed.length, 3);\n * }\n *\n * // curried version\n * const isSmallSelection = Arr.isBoundedLengthArray(1, 5);\n *\n * assert.isTrue(isSmallSelection(input));\n * ```\n *\n * @template MinLength - The minimum number of elements (inclusive).\n * @template MaxLength - The maximum number of elements (inclusive).\n * @template Xs - The input array type (tuple types are preserved).\n * @param minLength - The minimum number of elements (inclusive).\n * @param maxLength - The maximum number of elements (inclusive).\n * @param xs - The array to check.\n * @returns `true` if `minLength <= xs.length && xs.length <= maxLength`,\n *   `false` otherwise. When `true`, TypeScript narrows `xs` to\n *   `BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs`.\n */\nexport function isBoundedLengthArray<\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n  Xs extends readonly unknown[],\n>(\n  minLength: MinLength,\n  maxLength: MaxLength,\n  xs: Xs,\n): xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;\n\n// Curried version\nexport function isBoundedLengthArray<\n  MinLength extends SupportedLength,\n  MaxLength extends SupportedLength,\n>(\n  minLength: MinLength,\n  maxLength: MaxLength,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => xs is BoundedLengthArray<MinLength, MaxLength, Xs[number]> & Xs;\n\nexport function isBoundedLengthArray(\n  ...args:\n    | readonly [\n        minLength: SupportedLength,\n        maxLength: SupportedLength,\n        xs: readonly unknown[],\n      ]\n    | readonly [minLength: SupportedLength, maxLength: SupportedLength]\n): boolean | ((xs: readonly unknown[]) => boolean) {\n  switch (args.length) {\n    case 3:\n      return hasBoundedLength(...args);\n\n    case 2:\n      return (xs) => hasBoundedLength(args[0], args[1], xs);\n  }\n}\n\nconst hasBoundedLength = (\n  minLength: SupportedLength,\n  maxLength: SupportedLength,\n  xs: readonly unknown[],\n): boolean => xs.length >= minLength && xs.length <= maxLength;\n\n/**\n * Type guard that checks if an array has exactly `length` elements.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input to `FixedLengthArray<Length, E>` while preserving the\n *   original array type (e.g. tuple types) via intersection.\n * - Since `FixedLengthArray<Length, E>` is defined as\n *   `BoundedLengthArray<Length, Length, E>`, the narrowed value is assignable\n *   to any `MinLengthArray<N, E>` with `N <= Length` and any\n *   `MaxLengthArray<N, E>` with `N >= Length`.\n * - The length constraint lives only in the brand, so this stays cheap for the\n *   type checker even when the element type is large — unlike\n *   `isFixedLengthTuple`, which narrows to a structural tuple type.\n *\n * The length argument comes first, matching the type-parameter order of\n * `FixedLengthArray<Length, Elm>`. Omitting the array returns a reusable type\n * guard, which is convenient for `filter`/`pipe`.\n *\n * @example\n *\n * ```ts\n * const input: readonly number[] = [255, 128, 0] as const;\n *\n * assert.isTrue(Arr.isFixedLengthArray(3, input));\n *\n * assert.isFalse(Arr.isFixedLengthArray(4, input));\n *\n * if (Arr.isFixedLengthArray(3, input)) {\n *   const rgb: FixedLengthArray<3, number> = input;\n *\n *   const atMost5: MaxLengthArray<5, number> = input; // OK (3 <= 5)\n *\n *   assert.deepStrictEqual(rgb[0], 255);\n *\n *   assert.deepStrictEqual(atMost5.length, 3);\n * }\n *\n * // curried version\n * const isRgb = Arr.isFixedLengthArray(3);\n *\n * assert.isTrue(isRgb(input));\n * ```\n *\n * @template Length - The exact number of elements.\n * @template Xs - The input array type (tuple types are preserved).\n * @param length - The exact number of elements.\n * @param xs - The array to check.\n * @returns `true` if `xs.length === length`, `false` otherwise. When `true`,\n *   TypeScript narrows `xs` to `FixedLengthArray<Length, Xs[number]> & Xs`.\n */\nexport function isFixedLengthArray<\n  Length extends SupportedLength,\n  Xs extends readonly unknown[],\n>(length: Length, xs: Xs): xs is FixedLengthArray<Length, Xs[number]> & Xs;\n\n// Curried version\nexport function isFixedLengthArray<Length extends SupportedLength>(\n  length: Length,\n): <Xs extends readonly unknown[]>(\n  xs: Xs,\n) => xs is FixedLengthArray<Length, Xs[number]> & Xs;\n\nexport function isFixedLengthArray(\n  ...args:\n    | readonly [length: SupportedLength, xs: readonly unknown[]]\n    | readonly [length: SupportedLength]\n): boolean | ((xs: readonly unknown[]) => boolean) {\n  switch (args.length) {\n    case 2:\n      return hasFixedLength(...args);\n\n    case 1:\n      return (xs) => hasFixedLength(args[0], xs);\n  }\n}\n\nconst hasFixedLength = (\n  length: SupportedLength,\n  xs: readonly unknown[],\n): boolean => xs.length === length;\n\n/**\n * Type guard that checks if an array is empty.\n *\n * @example\n *\n * ```ts\n * const emptyNumbers: readonly number[] = [] as const;\n *\n * const words = ['Ada', 'Lovelace'] as const;\n *\n * assert.isTrue(Arr.isEmpty(emptyNumbers));\n *\n * assert.isFalse(Arr.isEmpty(words));\n *\n * if (Arr.isEmpty(emptyNumbers)) {\n *   // `isEmpty` narrows to the branded `FixedLengthArray<0, number>`, so the\n *   // expected value is annotated with the unbranded type.\n *   assert.deepStrictEqual<readonly number[]>(emptyNumbers, []);\n * }\n * ```\n */\nexport const isEmpty = <Xs extends readonly unknown[]>(\n  array: Xs,\n): array is FixedLengthArray<0, Xs[number]> & Xs => array.length === 0;\n\n/**\n * Type guard that checks if an array is non-empty.\n *\n * @example\n *\n * ```ts\n * const users: readonly Readonly<{ id: number }>[] = [{ id: 1 }] as const;\n *\n * const emptyUsers: readonly Readonly<{ id: number }>[] = [] as const;\n *\n * assert.isTrue(Arr.isNonEmpty(users));\n *\n * assert.isFalse(Arr.isNonEmpty(emptyUsers));\n *\n * if (Arr.isNonEmpty(users)) {\n *   assert.deepStrictEqual(users[0], { id: 1 });\n * }\n * ```\n */\nexport const isNonEmpty = <Xs extends readonly unknown[]>(\n  array: Xs,\n): array is MinLengthArray<1, Xs[number]> & Xs => array.length > 0;\n"],"names":[],"mappings":"AAyEO,SAAS,oBACX,IAAA,EAG8C;AACjD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,YAAA,CAAa,GAAG,IAAI,CAAA;AAAA,IAE7B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,EAAA,KAAO,YAAA,CAAa,IAAA,CAAK,CAAC,GAAG,EAAE,CAAA;AAAA;AAE7C;AAEA,MAAM,YAAA,GAAe,CACnB,SAAA,EACA,EAAA,KACY,GAAG,MAAA,IAAU,SAAA;AAmEpB,SAAS,oBACX,IAAA,EAG8C;AACjD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,YAAA,CAAa,GAAG,IAAI,CAAA;AAAA,IAE7B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,EAAA,KAAO,YAAA,CAAa,IAAA,CAAK,CAAC,GAAG,EAAE,CAAA;AAAA;AAE7C;AAEA,MAAM,YAAA,GAAe,CACnB,SAAA,EACA,EAAA,KACY,GAAG,MAAA,IAAU,SAAA;AA6EpB,SAAS,wBACX,IAAA,EAO8C;AACjD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,gBAAA,CAAiB,GAAG,IAAI,CAAA;AAAA,IAEjC,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,OAAO,gBAAA,CAAiB,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAA,EAAG,EAAE,CAAA;AAAA;AAE1D;AAEA,MAAM,gBAAA,GAAmB,CACvB,SAAA,EACA,SAAA,EACA,OACY,EAAA,CAAG,MAAA,IAAU,SAAA,IAAa,EAAA,CAAG,MAAA,IAAU,SAAA;AAiE9C,SAAS,sBACX,IAAA,EAG8C;AACjD,EAAA,QAAQ,KAAK,MAAA;AAAQ,IACnB,KAAK,CAAA;AACH,MAAA,OAAO,cAAA,CAAe,GAAG,IAAI,CAAA;AAAA,IAE/B,KAAK,CAAA;AACH,MAAA,OAAO,CAAC,EAAA,KAAO,cAAA,CAAe,IAAA,CAAK,CAAC,GAAG,EAAE,CAAA;AAAA;AAE/C;AAEA,MAAM,cAAA,GAAiB,CACrB,MAAA,EACA,EAAA,KACY,GAAG,MAAA,KAAW,MAAA;AAuBrB,MAAM,OAAA,GAAU,CACrB,KAAA,KACkD,KAAA,CAAM,MAAA,KAAW;AAqB9D,MAAM,UAAA,GAAa,CACxB,KAAA,KACgD,KAAA,CAAM,MAAA,GAAS;;;;"}

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

@@ -0,0 +1,167 @@
+import { type BoundedLengthTuple, type FixedLengthTuple, type MaxLengthTuple, type MinLengthTuple } from 'ts-type-forge';
+import { type SizeType } from '../../types.mjs';
+/**
+ * Casts an array to `FixedLengthTuple<Length, E>` after checking that it has
+ * exactly `length` elements.
+ *
+ * This is the structural counterpart of `asFixedLengthArray`: it produces a
+ * tuple type rather than the branded `FixedLengthArray`. Prefer the branded
+ * one unless you specifically need the structural type — the brand keeps
+ * type-checking cost independent of the element type and of the bound.
+ *
+ * The length argument comes first, matching the type-parameter order of
+ * `FixedLengthTuple<Length, Elm>`. Omitting the array returns a function that
+ * casts one.
+ *
+ * @example
+ *
+ * ```ts
+ * const rgb = Arr.asFixedLengthTuple(3, [255, 128, 0]);
+ *
+ * const red: number = rgb[0]; // OK — no `undefined`
+ *
+ * // curried version
+ * const asRgb = Arr.asFixedLengthTuple(3);
+ *
+ * // Arr.asFixedLengthTuple(3, [255, 128]); // throws TypeError
+ * ```
+ *
+ * @template Length - The exact number of elements.
+ * @template Xs - The input array type (tuple types are preserved).
+ * @param length - The exact number of elements.
+ * @param xs - The array to cast.
+ * @returns `xs` typed as `FixedLengthTuple<Length, Xs[number]> & Xs`.
+ * @throws {TypeError} If `xs.length !== length`.
+ */
+export declare function asFixedLengthTuple<Length extends SizeType.ArgArr, Xs extends readonly unknown[]>(length: Length, xs: Xs): FixedLengthTuple<Length, Xs[number]> & Xs;
+export declare function asFixedLengthTuple<Length extends SizeType.ArgArr>(length: Length): <Xs extends readonly unknown[]>(xs: Xs) => FixedLengthTuple<Length, Xs[number]> & Xs;
+/**
+ * Casts an array to `MinLengthTuple<MinLength, E>` after checking that it has
+ * at least `minLength` elements.
+ *
+ * This is the structural counterpart of `asMinLengthArray`; see
+ * {@link asFixedLengthTuple} for when to prefer which.
+ *
+ * @example
+ *
+ * ```ts
+ * const history = Arr.asMinLengthTuple(3, [0, 1, 2, 3]);
+ *
+ * const first: number = history[0]; // OK — no `undefined`
+ *
+ * // curried version
+ * const asHistory = Arr.asMinLengthTuple(3);
+ *
+ * // Arr.asMinLengthTuple(3, [0, 1]); // throws TypeError
+ * ```
+ *
+ * @template MinLength - The minimum number of elements (inclusive).
+ * @template Xs - The input array type (tuple types are preserved).
+ * @param minLength - The minimum number of elements (inclusive).
+ * @param xs - The array to cast.
+ * @returns `xs` typed as `MinLengthTuple<MinLength, Xs[number]> & Xs`.
+ * @throws {TypeError} If `xs.length < minLength`.
+ */
+export declare function asMinLengthTuple<MinLength extends SizeType.ArgArr, Xs extends readonly unknown[]>(minLength: MinLength, xs: Xs): MinLengthTuple<MinLength, Xs[number]> & Xs;
+export declare function asMinLengthTuple<MinLength extends SizeType.ArgArr>(minLength: MinLength): <Xs extends readonly unknown[]>(xs: Xs) => MinLengthTuple<MinLength, Xs[number]> & Xs;
+/**
+ * Casts an array to `MaxLengthTuple<MaxLength, E>` after checking that it has
+ * at most `maxLength` elements.
+ *
+ * This is the structural counterpart of `asMaxLengthArray`; see
+ * {@link asFixedLengthTuple} for when to prefer which.
+ *
+ * @example
+ *
+ * ```ts
+ * const tags = Arr.asMaxLengthTuple(8, ['a', 'b', 'c']);
+ *
+ * // curried version
+ * const asTags = Arr.asMaxLengthTuple(8);
+ *
+ * // Arr.asMaxLengthTuple(2, ['a', 'b', 'c']); // throws TypeError
+ * ```
+ *
+ * @template MaxLength - The maximum number of elements (inclusive).
+ * @template Xs - The input array type (tuple types are preserved).
+ * @param maxLength - The maximum number of elements (inclusive).
+ * @param xs - The array to cast.
+ * @returns `xs` typed as `MaxLengthTuple<MaxLength, Xs[number]> & Xs`.
+ * @throws {TypeError} If `xs.length > maxLength`.
+ */
+export declare function asMaxLengthTuple<MaxLength extends SizeType.ArgArr, Xs extends readonly unknown[]>(maxLength: MaxLength, xs: Xs): MaxLengthTuple<MaxLength, Xs[number]> & Xs;
+export declare function asMaxLengthTuple<MaxLength extends SizeType.ArgArr>(maxLength: MaxLength): <Xs extends readonly unknown[]>(xs: Xs) => MaxLengthTuple<MaxLength, Xs[number]> & Xs;
+/**
+ * Casts an array to `BoundedLengthTuple<Min, Max, E>` after checking that its
+ * length is within the inclusive range `[min, max]`.
+ *
+ * This is the structural counterpart of `asBoundedLengthArray`; see
+ * {@link asFixedLengthTuple} for when to prefer which.
+ *
+ * @example
+ *
+ * ```ts
+ * const selection = Arr.asBoundedLengthTuple(1, 5, [1, 2, 3]);
+ *
+ * // curried version
+ * const asSelection = Arr.asBoundedLengthTuple(1, 5);
+ *
+ * // Arr.asBoundedLengthTuple(1, 2, [1, 2, 3]); // throws TypeError
+ * ```
+ *
+ * @template Min - The minimum number of elements (inclusive).
+ * @template Max - The maximum number of elements (inclusive).
+ * @template Xs - The input array type (tuple types are preserved).
+ * @param min - The minimum number of elements (inclusive).
+ * @param max - The maximum number of elements (inclusive).
+ * @param xs - The array to cast.
+ * @returns `xs` typed as `BoundedLengthTuple<Min, Max, Xs[number]> & Xs`.
+ * @throws {TypeError} If `xs.length` is outside `[min, max]`.
+ */
+export declare function asBoundedLengthTuple<Min extends SizeType.ArgArr, Max extends SizeType.ArgArr, Xs extends readonly unknown[]>(min: Min, max: Max, xs: Xs): BoundedLengthTuple<Min, Max, Xs[number]> & Xs;
+export declare function asBoundedLengthTuple<Min extends SizeType.ArgArr, Max extends SizeType.ArgArr>(min: Min, max: Max): <Xs extends readonly unknown[]>(xs: Xs) => BoundedLengthTuple<Min, Max, Xs[number]> & Xs;
+/**
+ * Casts an array to the structural empty tuple after checking that it is
+ * empty.
+ *
+ * This is the structural counterpart of `asEmptyArray`, and the length-0
+ * specialization of {@link asFixedLengthTuple}.
+ *
+ * @example
+ *
+ * ```ts
+ * const nothing = Arr.asEmptyTuple([]);
+ *
+ * // Arr.asEmptyTuple([1]); // throws TypeError
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @param xs - The array to cast.
+ * @returns `xs` typed as `readonly [] & Xs`.
+ * @throws {TypeError} If `xs` is not empty.
+ */
+export declare const asEmptyTuple: <Xs extends readonly unknown[]>(xs: Xs) => readonly [] & Xs;
+/**
+ * Casts an array to `MinLengthTuple<1, E>` after checking that it has at least
+ * one element.
+ *
+ * This is the structural counterpart of `asNonEmptyArray`, and the length-1
+ * specialization of {@link asMinLengthTuple}.
+ *
+ * @example
+ *
+ * ```ts
+ * const values = Arr.asNonEmptyTuple([1, 2, 3]);
+ *
+ * const first: number = values[0]; // OK — no `undefined`
+ *
+ * // Arr.asNonEmptyTuple([]); // throws TypeError
+ * ```
+ *
+ * @template Xs - The input array type (tuple types are preserved).
+ * @param xs - The array to cast.
+ * @returns `xs` typed as `MinLengthTuple<1, Xs[number]> & Xs`.
+ * @throws {TypeError} If `xs` is empty.
+ */
+export declare const asNonEmptyTuple: <Xs extends readonly unknown[]>(xs: Xs) => MinLengthTuple<1, Xs[number]> & Xs;
+//# sourceMappingURL=array-utils-length-bounded-tuple-cast.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array-utils-length-bounded-tuple-cast.d.mts","sourceRoot":"","sources":["../../../src/array/impl/array-utils-length-bounded-tuple-cast.mts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,87 @@
+import { isEmptyTuple, isMinLengthTuple, isBoundedLengthTuple, isFixedLengthTuple, isMaxLengthTuple } from './array-utils-length-bounded-tuple-guard.mjs';
+
+function asFixedLengthTuple(...args) {
+  switch (args.length) {
+    case 2:
+      return asFixedLengthTupleImpl(...args);
+    case 1:
+      return (xs) => asFixedLengthTupleImpl(args[0], xs);
+  }
+}
+const asFixedLengthTupleImpl = (length, xs) => {
+  const actualLength = xs.length;
+  if (!isFixedLengthTuple(length, xs)) {
+    throw new TypeError(
+      `Expected an array of length ${length}, got an array of length ${actualLength}`
+    );
+  }
+  return xs;
+};
+function asMinLengthTuple(...args) {
+  switch (args.length) {
+    case 2:
+      return asMinLengthTupleImpl(...args);
+    case 1:
+      return (xs) => asMinLengthTupleImpl(args[0], xs);
+  }
+}
+const asMinLengthTupleImpl = (minLength, xs) => {
+  const actualLength = xs.length;
+  if (!isMinLengthTuple(minLength, xs)) {
+    throw new TypeError(
+      `Expected an array of length >= ${minLength}, got an array of length ${actualLength}`
+    );
+  }
+  return xs;
+};
+function asMaxLengthTuple(...args) {
+  switch (args.length) {
+    case 2:
+      return asMaxLengthTupleImpl(...args);
+    case 1:
+      return (xs) => asMaxLengthTupleImpl(args[0], xs);
+  }
+}
+const asMaxLengthTupleImpl = (maxLength, xs) => {
+  const actualLength = xs.length;
+  if (!isMaxLengthTuple(maxLength, xs)) {
+    throw new TypeError(
+      `Expected an array of length <= ${maxLength}, got an array of length ${actualLength}`
+    );
+  }
+  return xs;
+};
+function asBoundedLengthTuple(...args) {
+  switch (args.length) {
+    case 3:
+      return asBoundedLengthTupleImpl(...args);
+    case 2:
+      return (xs) => asBoundedLengthTupleImpl(...args, xs);
+  }
+}
+const asBoundedLengthTupleImpl = (min, max, xs) => {
+  const actualLength = xs.length;
+  if (!isBoundedLengthTuple(min, max, xs)) {
+    throw new TypeError(
+      `Expected an array of length in [${min}, ${max}], got an array of length ${actualLength}`
+    );
+  }
+  return xs;
+};
+const asEmptyTuple = (xs) => {
+  if (!isEmptyTuple(xs)) {
+    throw new TypeError(
+      `Expected an empty array, got an array of length ${xs.length}`
+    );
+  }
+  return xs;
+};
+const asNonEmptyTuple = (xs) => {
+  if (!isMinLengthTuple(1, xs)) {
+    throw new TypeError("Expected a non-empty array, got an empty array");
+  }
+  return xs;
+};
+
+export { asBoundedLengthTuple, asEmptyTuple, asFixedLengthTuple, asMaxLengthTuple, asMinLengthTuple, asNonEmptyTuple };
+//# sourceMappingURL=array-utils-length-bounded-tuple-cast.mjs.map