ts-fortress 9.2.0 → 10.0.0

package/README.md

@@ -1042,10 +1042,10 @@ type ValidationError = Readonly<{
 - `t.array(elementType)` - Array validation
 - `t.nonEmptyArray(elementType)` - Non-empty array validation
 - `t.tuple([t1, t2, ..., tN])` - Fixed-length tuple validation
-- `t.arrayOfLength(size, elementType)` - Fixed-length array validation
-- `t.arrayAtLeastLength(size, elementType)` - Array validation with a minimum length
-- `t.arrayAtMostLength(size, elementType)` - Array validation with a maximum length
-- `t.arrayBoundedLength(min, max, elementType)` - Array validation with a length between `min` and `max` (inclusive)
+- `t.fixedLengthTuple(size, elementType)` - Fixed-length array validation
+- `t.minLengthTuple(size, elementType)` - Array validation with a minimum length
+- `t.maxLengthTuple(size, elementType)` - Array validation with a maximum length
+- `t.boundedLengthTuple(min, max, elementType)` - Array validation with a length between `min` and `max` (inclusive)
 
 ### Objects
 

package/dist/array/array.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array.d.mts","sourceRoot":"","sources":["../../src/array/array.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAUxC,eAAO,MAAM,KAAK,GAAI,CAAC,EACrB,aAAa,IAAI,CAAC,CAAC,CAAC,EACpB,UAAU,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,SAAS,CAAC,EAAE,CAAC;CAC5B,CAAC,CACH,KACA,IAAI,CAAC,SAAS,CAAC,EAAE,CAsDnB,CAAC"}
+{"version":3,"file":"array.d.mts","sourceRoot":"","sources":["../../src/array/array.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAUxC,eAAO,MAAM,KAAK,GAAI,CAAC,eACR,IAAI,CAAC,CAAC,CAAC,YACV,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,SAAS,CAAC,EAAE,CAAC;CAC5B,CAAC,CACH,KACA,IAAI,CAAC,SAAS,CAAC,EAAE,CAsDnB,CAAC"}

package/dist/array/array.mjs

@@ -5,47 +5,46 @@ import { createIsFn } from '../utils/create-is-fn.mjs';
 import { createPrimitiveValidationError, prependIndexToValidationErrors } from '../utils/validation-error.mjs';
 
 const array = (elementType, options) => {
-    const typeName = options?.typeName ?? `${elementType.typeName}[]`;
-    const getDefaultValue = memoizeFunction(() => options?.defaultValue ?? []);
-    const validate = (a) => {
-        if (!Arr.isArray(a)) {
-            return Result.err([
-                createPrimitiveValidationError({
-                    actualValue: a,
-                    expectedType: 'array',
-                    typeName,
-                    details: undefined,
-                }),
-            ]);
+  const typeName = options?.typeName ?? `${elementType.typeName}[]`;
+  const getDefaultValue = memoizeFunction(() => options?.defaultValue ?? []);
+  const validate = (a) => {
+    if (!Arr.isArray(a)) {
+      return Result.err([
+        createPrimitiveValidationError({
+          actualValue: a,
+          expectedType: "array",
+          typeName,
+          details: void 0
+        })
+      ]);
+    }
+    const errors = Arr.generate(function* () {
+      for (const [index, el] of a.entries()) {
+        const res = elementType.validate(el);
+        if (Result.isErr(res)) {
+          yield* prependIndexToValidationErrors(res.value, index);
         }
-        const errors = Arr.generate(function* () {
-            for (const [index, el] of a.entries()) {
-                const res = elementType.validate(el);
-                if (Result.isErr(res)) {
-                    yield* prependIndexToValidationErrors(res.value, index);
-                }
-            }
-        });
-        if (Arr.isNonEmpty(errors)) {
-            return Result.err(errors);
-        }
-        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-        return Result.ok(a);
-    };
-    const fill = (a) => !Arr.isArray(a) ? getDefaultValue() : a.map((e) => elementType.fill(e));
-    const prune = (a) => a.map((e) => elementType.prune(e));
-    return {
-        typeName,
-        get defaultValue() {
-            return getDefaultValue();
-        },
-        fill,
-        prune,
-        validate,
-        is: createIsFn(validate),
-        assertIs: createAssertFn(validate),
-        cast: createCastFn(validate),
-    };
+      }
+    });
+    if (Arr.isNonEmpty(errors)) {
+      return Result.err(errors);
+    }
+    return Result.ok(a);
+  };
+  const fill = (a) => !Arr.isArray(a) ? getDefaultValue() : a.map((e) => elementType.fill(e));
+  const prune = (a) => a.map((e) => elementType.prune(e));
+  return {
+    typeName,
+    get defaultValue() {
+      return getDefaultValue();
+    },
+    fill,
+    prune,
+    validate,
+    is: createIsFn(validate),
+    assertIs: createAssertFn(validate),
+    cast: createCastFn(validate)
+  };
 };
 
 export { array };

package/dist/array/array.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array.mjs","sources":["../../src/array/array.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;MAWa,KAAK,GAAG,CACnB,WAAoB,EACpB,OAKC,KACqB;IAGtB,MAAM,QAAQ,GAAG,OAAO,EAAE,QAAQ,IAAI,CAAA,EAAG,WAAW,CAAC,QAAQ,CAAA,EAAA,CAAI;AAEjE,IAAA,MAAM,eAAe,GAAG,eAAe,CAAC,MAAS,OAAO,EAAE,YAAY,IAAI,EAAE,CAAC;AAE7E,IAAA,MAAM,QAAQ,GAAwB,CAAC,CAAC,KAAI;QAC1C,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;YACnB,OAAO,MAAM,CAAC,GAAG,CAAC;AAChB,gBAAA,8BAA8B,CAAC;AAC7B,oBAAA,WAAW,EAAE,CAAC;AACd,oBAAA,YAAY,EAAE,OAAO;oBACrB,QAAQ;AACR,oBAAA,OAAO,EAAE,SAAS;iBACnB,CAAC;AACH,aAAA,CAAC;QACJ;AAEA,QAAA,MAAM,MAAM,GAA+B,GAAG,CAAC,QAAQ,CAAC,aAAS;AAC/D,YAAA,KAAK,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE;gBACrC,MAAM,GAAG,GAAG,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;AAEpC,gBAAA,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;oBACrB,OAAO,8BAA8B,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC;gBACzD;YACF;AACF,QAAA,CAAC,CAAC;AAEF,QAAA,IAAI,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;AAC1B,YAAA,OAAO,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC;QAC3B;;AAGA,QAAA,OAAO,MAAM,CAAC,EAAE,CAAC,CAAM,CAAC;AAC1B,IAAA,CAAC;AAED,IAAA,MAAM,IAAI,GAAoB,CAAC,CAAC,KAC9B,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,eAAe,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAEzE,MAAM,KAAK,GAAG,CAAC,CAAI,KAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAE7D,OAAO;QACL,QAAQ;AACR,QAAA,IAAI,YAAY,GAAA;YACd,OAAO,eAAe,EAAE;QAC1B,CAAC;QACD,IAAI;QACJ,KAAK;QACL,QAAQ;AACR,QAAA,EAAE,EAAE,UAAU,CAAC,QAAQ,CAAC;AACxB,QAAA,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC;AAClC,QAAA,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC;KAC7B;AACH;;;;"}
+{"version":3,"file":"array.mjs","sources":["../../src/array/array.mts"],"sourcesContent":["import { Arr, memoizeFunction, Result } from 'ts-data-forge';\nimport { type Type } from '../type.mjs';\nimport {\n  createAssertFn,\n  createCastFn,\n  createIsFn,\n  createPrimitiveValidationError,\n  prependIndexToValidationErrors,\n  type ValidationError,\n} from '../utils/index.mjs';\n\nexport const array = <A,>(\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]> => {\n  type T = readonly A[];\n\n  const typeName = options?.typeName ?? `${elementType.typeName}[]`;\n\n  const getDefaultValue = memoizeFunction((): T => options?.defaultValue ?? []);\n\n  const validate: Type<T>['validate'] = (a) => {\n    if (!Arr.isArray(a)) {\n      return Result.err([\n        createPrimitiveValidationError({\n          actualValue: a,\n          expectedType: 'array',\n          typeName,\n          details: undefined,\n        }),\n      ]);\n    }\n\n    const errors: readonly ValidationError[] = Arr.generate(function* () {\n      for (const [index, el] of a.entries()) {\n        const res = elementType.validate(el);\n\n        if (Result.isErr(res)) {\n          yield* prependIndexToValidationErrors(res.value, index);\n        }\n      }\n    });\n\n    if (Arr.isNonEmpty(errors)) {\n      return Result.err(errors);\n    }\n\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return Result.ok(a as T);\n  };\n\n  const fill: Type<T>['fill'] = (a) =>\n    !Arr.isArray(a) ? getDefaultValue() : a.map((e) => elementType.fill(e));\n\n  const prune = (a: T): T => a.map((e) => elementType.prune(e));\n\n  return {\n    typeName,\n    get defaultValue() {\n      return getDefaultValue();\n    },\n    fill,\n    prune,\n    validate,\n    is: createIsFn(validate),\n    assertIs: createAssertFn(validate),\n    cast: createCastFn(validate),\n  };\n};\n"],"names":[],"mappings":";;;;;;AAWO,MAAM,KAAA,GAAQ,CACnB,WAAA,EACA,OAAA,KAMuB;AAGvB,EAAA,MAAM,QAAA,GAAW,OAAA,EAAS,QAAA,IAAY,CAAA,EAAG,YAAY,QAAQ,CAAA,EAAA,CAAA;AAE7D,EAAA,MAAM,kBAAkB,eAAA,CAAgB,MAAS,OAAA,EAAS,YAAA,IAAgB,EAAE,CAAA;AAE5E,EAAA,MAAM,QAAA,GAAgC,CAAC,CAAA,KAAM;AAC3C,IAAA,IAAI,CAAC,GAAA,CAAI,OAAA,CAAQ,CAAC,CAAA,EAAG;AACnB,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB,8BAAA,CAA+B;AAAA,UAC7B,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,OAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,SACV;AAAA,OACF,CAAA;AAAA,IACH;AAEA,IAAA,MAAM,MAAA,GAAqC,GAAA,CAAI,QAAA,CAAS,aAAa;AACnE,MAAA,KAAA,MAAW,CAAC,KAAA,EAAO,EAAE,CAAA,IAAK,CAAA,CAAE,SAAQ,EAAG;AACrC,QAAA,MAAM,GAAA,GAAM,WAAA,CAAY,QAAA,CAAS,EAAE,CAAA;AAEnC,QAAA,IAAI,MAAA,CAAO,KAAA,CAAM,GAAG,CAAA,EAAG;AACrB,UAAA,OAAO,8BAAA,CAA+B,GAAA,CAAI,KAAA,EAAO,KAAK,CAAA;AAAA,QACxD;AAAA,MACF;AAAA,IACF,CAAC,CAAA;AAED,IAAA,IAAI,GAAA,CAAI,UAAA,CAAW,MAAM,CAAA,EAAG;AAC1B,MAAA,OAAO,MAAA,CAAO,IAAI,MAAM,CAAA;AAAA,IAC1B;AAGA,IAAA,OAAO,MAAA,CAAO,GAAG,CAAM,CAAA;AAAA,EACzB,CAAA;AAEA,EAAA,MAAM,OAAwB,CAAC,CAAA,KAC7B,CAAC,GAAA,CAAI,QAAQ,CAAC,CAAA,GAAI,eAAA,EAAgB,GAAI,EAAE,GAAA,CAAI,CAAC,MAAM,WAAA,CAAY,IAAA,CAAK,CAAC,CAAC,CAAA;AAExE,EAAA,MAAM,KAAA,GAAQ,CAAC,CAAA,KAAY,CAAA,CAAE,GAAA,CAAI,CAAC,CAAA,KAAM,WAAA,CAAY,KAAA,CAAM,CAAC,CAAC,CAAA;AAE5D,EAAA,OAAO;AAAA,IACL,QAAA;AAAA,IACA,IAAI,YAAA,GAAe;AACjB,MAAA,OAAO,eAAA,EAAgB;AAAA,IACzB,CAAA;AAAA,IACA,IAAA;AAAA,IACA,KAAA;AAAA,IACA,QAAA;AAAA,IACA,EAAA,EAAI,WAAW,QAAQ,CAAA;AAAA,IACvB,QAAA,EAAU,eAAe,QAAQ,CAAA;AAAA,IACjC,IAAA,EAAM,aAAa,QAAQ;AAAA,GAC7B;AACF;;;;"}

package/dist/array/bounded-length-tuple.d.mts

@@ -0,0 +1,20 @@
+import { type BoundedLengthTuple, type MaxLengthTuple, type MinLengthTuple, type StructuralPrefixLength } from 'ts-type-forge';
+import { type Type } from '../type.mjs';
+export type { BoundedLengthTuple } from 'ts-type-forge';
+export declare function boundedLengthTuple<A, Min extends StructuralPrefixLength, Max extends StructuralPrefixLength>(min: Min, max: Max, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: BoundedLengthTuple<Min, Max, A>;
+}>>): Type<BoundedLengthTuple<Min, Max, A>>;
+export declare function boundedLengthTuple<A, Min extends StructuralPrefixLength>(min: Min, max: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: MinLengthTuple<Min, A>;
+}>>): Type<MinLengthTuple<Min, A>>;
+export declare function boundedLengthTuple<A, Max extends StructuralPrefixLength>(min: number, max: Max, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: MaxLengthTuple<Max, A>;
+}>>): Type<MaxLengthTuple<Max, A>>;
+export declare function boundedLengthTuple<A>(min: number, max: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: readonly A[];
+}>>): Type<readonly A[]>;
+//# sourceMappingURL=bounded-length-tuple.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-length-tuple.d.mts","sourceRoot":"","sources":["../../src/array/bounded-length-tuple.mts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC5B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAUxC,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD,wBAAgB,kBAAkB,CAChC,CAAC,EACD,GAAG,SAAS,sBAAsB,EAClC,GAAG,SAAS,sBAAsB,EAElC,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;CAC/C,CAAC,CACH,GACA,IAAI,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAIzC,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,SAAS,sBAAsB,EACtE,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;CACtC,CAAC,CACH,GACA,IAAI,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAIhC,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,SAAS,sBAAsB,EACtE,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;CACtC,CAAC,CACH,GACA,IAAI,CAAC,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;AAGhC,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,SAAS,CAAC,EAAE,CAAC;CAC5B,CAAC,CACH,GACA,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC"}

package/dist/array/bounded-length-tuple.mjs

@@ -0,0 +1,79 @@
+import { memoizeFunction, Arr, asUint32, Result } from 'ts-data-forge';
+import { createAssertFn } from '../utils/create-assert-fn.mjs';
+import { createCastFn } from '../utils/create-cast-fn.mjs';
+import { createIsFn } from '../utils/create-is-fn.mjs';
+import { createPrimitiveValidationError, prependIndexToValidationErrors } from '../utils/validation-error.mjs';
+
+function boundedLengthTuple(min, max, elementType, options) {
+  const typeName = options?.typeName ?? `BoundedLengthTuple<${min}, ${max}, ${elementType.typeName}>`;
+  const getDefaultValue = memoizeFunction(
+    () => options?.defaultValue ?? // An array of the minimum length is the shortest value within the range.
+    Arr.create(asUint32(min), elementType.defaultValue)
+  );
+  const validate = (a) => {
+    if (!Arr.isArray(a)) {
+      return Result.err([
+        createPrimitiveValidationError({
+          actualValue: a,
+          expectedType: "array",
+          typeName,
+          details: void 0
+        })
+      ]);
+    }
+    if (a.length < min || max < a.length) {
+      return Result.err([
+        {
+          path: [],
+          actualValue: a,
+          expectedType: typeName,
+          typeName,
+          details: {
+            kind: "array-range-length",
+            minLength: min,
+            maxLength: max,
+            actualLength: a.length
+          }
+        }
+      ]);
+    }
+    const errors = Arr.generate(function* () {
+      for (const [index, el] of a.entries()) {
+        const res = elementType.validate(el);
+        if (Result.isErr(res)) {
+          yield* prependIndexToValidationErrors(res.value, index);
+        }
+      }
+    });
+    if (Arr.isNonEmpty(errors)) {
+      return Result.err(errors);
+    }
+    return Result.ok(a);
+  };
+  const fill = (a) => {
+    if (!Arr.isArray(a)) {
+      return getDefaultValue();
+    }
+    const capped = Arr.take(a, asUint32(max));
+    return capped.length >= min ? Arr.map(capped, (el) => elementType.fill(el)) : Arr.map(
+      Arr.seq(asUint32(min)),
+      (i) => elementType.fill(capped[i])
+    );
+  };
+  const prune = (a) => a.map((el) => elementType.prune(el));
+  return {
+    typeName,
+    get defaultValue() {
+      return getDefaultValue();
+    },
+    fill,
+    prune,
+    validate,
+    is: createIsFn(validate),
+    cast: createCastFn(validate),
+    assertIs: createAssertFn(validate)
+  };
+}
+
+export { boundedLengthTuple };
+//# sourceMappingURL=bounded-length-tuple.mjs.map

package/dist/array/bounded-length-tuple.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounded-length-tuple.mjs","sources":["../../src/array/bounded-length-tuple.mts"],"sourcesContent":["import { Arr, asUint32, memoizeFunction, Result } from 'ts-data-forge';\nimport {\n  type BoundedLengthTuple,\n  type MaxLengthTuple,\n  type MinLengthTuple,\n  type StructuralPrefixLength,\n} from 'ts-type-forge';\nimport { type Type } from '../type.mjs';\nimport {\n  createAssertFn,\n  createCastFn,\n  createIsFn,\n  createPrimitiveValidationError,\n  prependIndexToValidationErrors,\n  type ValidationError,\n} from '../utils/index.mjs';\n\nexport type { BoundedLengthTuple } from 'ts-type-forge';\n\nexport function boundedLengthTuple<\n  A,\n  Min extends StructuralPrefixLength,\n  Max extends StructuralPrefixLength,\n>(\n  min: Min,\n  max: Max,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: BoundedLengthTuple<Min, Max, A>;\n    }>\n  >,\n): Type<BoundedLengthTuple<Min, Max, A>>;\n\n// Only the lower bound is in `StructuralPrefixLength` (`0..10`), so the upper bound is dropped from the\n// result type and only the \"at least `min`\" guarantee is kept.\nexport function boundedLengthTuple<A, Min extends StructuralPrefixLength>(\n  min: Min,\n  max: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: MinLengthTuple<Min, A>;\n    }>\n  >,\n): Type<MinLengthTuple<Min, A>>;\n\n// Only the upper bound is in `StructuralPrefixLength` (`0..10`), so the lower bound is dropped from the\n// result type and only the \"at most `max`\" guarantee is kept.\nexport function boundedLengthTuple<A, Max extends StructuralPrefixLength>(\n  min: number,\n  max: Max,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: MaxLengthTuple<Max, A>;\n    }>\n  >,\n): Type<MaxLengthTuple<Max, A>>;\n\n// Neither bound is in `StructuralPrefixLength` (`0..10`), so the result length is left unconstrained.\nexport function boundedLengthTuple<A>(\n  min: number,\n  max: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]>;\n\nexport function boundedLengthTuple<A>(\n  min: number,\n  max: number,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: readonly A[];\n    }>\n  >,\n): Type<readonly A[]> {\n  type T = readonly A[];\n\n  const typeName =\n    options?.typeName ??\n    `BoundedLengthTuple<${min}, ${max}, ${elementType.typeName}>`;\n\n  const getDefaultValue = memoizeFunction(\n    (): T =>\n      options?.defaultValue ??\n      // An array of the minimum length is the shortest value within the range.\n      Arr.create(asUint32(min), elementType.defaultValue),\n  );\n\n  const validate: Type<T>['validate'] = (a) => {\n    if (!Arr.isArray(a)) {\n      return Result.err([\n        createPrimitiveValidationError({\n          actualValue: a,\n          expectedType: 'array',\n          typeName,\n          details: undefined,\n        }),\n      ]);\n    }\n\n    if (a.length < min || max < a.length) {\n      return Result.err([\n        {\n          path: [],\n          actualValue: a,\n          expectedType: typeName,\n          typeName,\n          details: {\n            kind: 'array-range-length',\n            minLength: min,\n            maxLength: max,\n            actualLength: a.length,\n          },\n        } satisfies ValidationError,\n      ]);\n    }\n\n    const errors: readonly ValidationError[] = Arr.generate(function* () {\n      for (const [index, el] of a.entries()) {\n        const res = elementType.validate(el);\n\n        if (Result.isErr(res)) {\n          yield* prependIndexToValidationErrors(res.value, index);\n        }\n      }\n    });\n\n    if (Arr.isNonEmpty(errors)) {\n      return Result.err(errors);\n    }\n\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return Result.ok(a as unknown as T);\n  };\n\n  const fill: Type<T>['fill'] = (a) => {\n    if (!Arr.isArray(a)) {\n      return getDefaultValue();\n    }\n\n    // Trim down to at most `max`, then pad up to at least `min`.\n    const capped = Arr.take(a, asUint32(max));\n\n    return capped.length >= min\n      ? Arr.map(capped, (el) => elementType.fill(el) satisfies A)\n      : Arr.map(\n          Arr.seq(asUint32(min)),\n          (i) => elementType.fill(capped[i]) satisfies A,\n        );\n  };\n\n  const prune = (a: T): T => a.map((el) => elementType.prune(el));\n\n  return {\n    typeName,\n    get defaultValue() {\n      return getDefaultValue();\n    },\n    fill,\n    prune,\n    validate,\n    is: createIsFn(validate),\n    cast: createCastFn(validate),\n    assertIs: createAssertFn(validate),\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/array/fixed-length-tuple.d.mts

@@ -0,0 +1,8 @@
+import { type FixedLengthTuple, type StructuralPrefixLength } from 'ts-type-forge';
+import { type Type } from '../type.mjs';
+export type { FixedLengthTuple } from 'ts-type-forge';
+export declare const fixedLengthTuple: <A, N extends StructuralPrefixLength>(size: N, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: FixedLengthTuple<N, A>;
+}>>) => Type<FixedLengthTuple<N, A>>;
+//# sourceMappingURL=fixed-length-tuple.d.mts.map

package/dist/array/fixed-length-tuple.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed-length-tuple.d.mts","sourceRoot":"","sources":["../../src/array/fixed-length-tuple.mts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAC5B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAUxC,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAAE,CAAC,SAAS,sBAAsB,QAC5D,CAAC,eACM,IAAI,CAAC,CAAC,CAAC,YACV,OAAO,CACf,QAAQ,CAAC;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACtC,CAAC,CACH,KACA,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAoF7B,CAAC"}

package/dist/array/fixed-length-tuple.mjs

@@ -0,0 +1,79 @@
+import { memoizeFunction, Arr, Result } from 'ts-data-forge';
+import { createAssertFn } from '../utils/create-assert-fn.mjs';
+import { createCastFn } from '../utils/create-cast-fn.mjs';
+import { createIsFn } from '../utils/create-is-fn.mjs';
+import { createPrimitiveValidationError, prependIndexToValidationErrors } from '../utils/validation-error.mjs';
+
+const fixedLengthTuple = (size, elementType, options) => {
+  const typeName = options?.typeName ?? `FixedLengthTuple<${size}, ${elementType.typeName}>`;
+  const getDefaultValue = memoizeFunction(
+    () => options?.defaultValue ?? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    Arr.create(size, elementType.defaultValue)
+  );
+  const validate = (a) => {
+    if (!Arr.isArray(a)) {
+      return Result.err([
+        createPrimitiveValidationError({
+          actualValue: a,
+          expectedType: "array",
+          typeName,
+          details: void 0
+        })
+      ]);
+    }
+    if (!Arr.isFixedLengthTuple(a, size)) {
+      return Result.err([
+        {
+          path: [],
+          actualValue: a,
+          expectedType: typeName,
+          typeName,
+          details: {
+            kind: "array-length",
+            expectedLength: size,
+            actualLength: a.length
+          }
+        }
+      ]);
+    }
+    const errors = Arr.generate(function* () {
+      for (const [index, el] of a.entries()) {
+        const res = elementType.validate(el);
+        if (Result.isErr(res)) {
+          yield* prependIndexToValidationErrors(res.value, index);
+        }
+      }
+    });
+    if (Arr.isNonEmpty(errors)) {
+      return Result.err(errors);
+    }
+    return Result.ok(a);
+  };
+  const fill = (a) => !Arr.isArray(a) ? getDefaultValue() : (
+    // TODO: remove as
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    Arr.map(
+      Arr.seq(size),
+      (i) => elementType.fill(a[i])
+    )
+  );
+  const prune = (a) => (
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    Arr.map(a, (el) => elementType.prune(el))
+  );
+  return {
+    typeName,
+    get defaultValue() {
+      return getDefaultValue();
+    },
+    fill,
+    prune,
+    validate,
+    is: createIsFn(validate),
+    cast: createCastFn(validate),
+    assertIs: createAssertFn(validate)
+  };
+};
+
+export { fixedLengthTuple };
+//# sourceMappingURL=fixed-length-tuple.mjs.map

package/dist/array/fixed-length-tuple.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed-length-tuple.mjs","sources":["../../src/array/fixed-length-tuple.mts"],"sourcesContent":["import { Arr, memoizeFunction, Result } from 'ts-data-forge';\nimport {\n  type FixedLengthTuple,\n  type StructuralPrefixLength,\n} from 'ts-type-forge';\nimport { type Type } from '../type.mjs';\nimport {\n  createAssertFn,\n  createCastFn,\n  createIsFn,\n  createPrimitiveValidationError,\n  prependIndexToValidationErrors,\n  type ValidationError,\n} from '../utils/index.mjs';\n\nexport type { FixedLengthTuple } from 'ts-type-forge';\n\nexport const fixedLengthTuple = <A, N extends StructuralPrefixLength>(\n  size: N,\n  elementType: Type<A>,\n  options?: Partial<\n    Readonly<{\n      typeName: string;\n      defaultValue: FixedLengthTuple<N, A>;\n    }>\n  >,\n): Type<FixedLengthTuple<N, A>> => {\n  type T = FixedLengthTuple<N, A>;\n\n  const typeName =\n    options?.typeName ?? `FixedLengthTuple<${size}, ${elementType.typeName}>`;\n\n  const getDefaultValue = memoizeFunction(\n    (): T =>\n      options?.defaultValue ??\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      (Arr.create(size, elementType.defaultValue) as T),\n  );\n\n  const validate: Type<T>['validate'] = (a) => {\n    if (!Arr.isArray(a)) {\n      return Result.err([\n        createPrimitiveValidationError({\n          actualValue: a,\n          expectedType: 'array',\n          typeName,\n          details: undefined,\n        }),\n      ]);\n    }\n\n    if (!Arr.isFixedLengthTuple(a, size)) {\n      return Result.err([\n        {\n          path: [],\n          actualValue: a,\n          expectedType: typeName,\n          typeName,\n          details: {\n            kind: 'array-length',\n            expectedLength: size,\n            actualLength: a.length,\n          },\n        } satisfies ValidationError,\n      ]);\n    }\n\n    const errors: readonly ValidationError[] = Arr.generate(function* () {\n      for (const [index, el] of a.entries()) {\n        const res = elementType.validate(el);\n\n        if (Result.isErr(res)) {\n          yield* prependIndexToValidationErrors(res.value, index);\n        }\n      }\n    });\n\n    if (Arr.isNonEmpty(errors)) {\n      return Result.err(errors);\n    }\n\n    return Result.ok(a);\n  };\n\n  const fill: Type<T>['fill'] = (a) =>\n    !Arr.isArray(a)\n      ? getDefaultValue()\n      : // TODO: remove as\n        // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n        (Arr.map(\n          Arr.seq(size),\n          (i) => elementType.fill(a[i]) satisfies A,\n        ) as T);\n\n  const prune = (a: T): T =>\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    Arr.map(a, (el) => elementType.prune(el)) as T;\n\n  return {\n    typeName,\n    get defaultValue() {\n      return getDefaultValue();\n    },\n    fill,\n    prune,\n    validate,\n    is: createIsFn(validate),\n    cast: createCastFn(validate),\n    assertIs: createAssertFn(validate),\n  };\n};\n"],"names":[],"mappings":";;;;;;AAiBO,MAAM,gBAAA,GAAmB,CAC9B,IAAA,EACA,WAAA,EACA,OAAA,KAMiC;AAGjC,EAAA,MAAM,WACJ,OAAA,EAAS,QAAA,IAAY,oBAAoB,IAAI,CAAA,EAAA,EAAK,YAAY,QAAQ,CAAA,CAAA,CAAA;AAExE,EAAA,MAAM,eAAA,GAAkB,eAAA;AAAA,IACtB,MACE,OAAA,EAAS,YAAA;AAAA,IAER,GAAA,CAAI,MAAA,CAAO,IAAA,EAAM,WAAA,CAAY,YAAY;AAAA,GAC9C;AAEA,EAAA,MAAM,QAAA,GAAgC,CAAC,CAAA,KAAM;AAC3C,IAAA,IAAI,CAAC,GAAA,CAAI,OAAA,CAAQ,CAAC,CAAA,EAAG;AACnB,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB,8BAAA,CAA+B;AAAA,UAC7B,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,OAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,SACV;AAAA,OACF,CAAA;AAAA,IACH;AAEA,IAAA,IAAI,CAAC,GAAA,CAAI,kBAAA,CAAmB,CAAA,EAAG,IAAI,CAAA,EAAG;AACpC,MAAA,OAAO,OAAO,GAAA,CAAI;AAAA,QAChB;AAAA,UACE,MAAM,EAAC;AAAA,UACP,WAAA,EAAa,CAAA;AAAA,UACb,YAAA,EAAc,QAAA;AAAA,UACd,QAAA;AAAA,UACA,OAAA,EAAS;AAAA,YACP,IAAA,EAAM,cAAA;AAAA,YACN,cAAA,EAAgB,IAAA;AAAA,YAChB,cAAc,CAAA,CAAE;AAAA;AAClB;AACF,OACD,CAAA;AAAA,IACH;AAEA,IAAA,MAAM,MAAA,GAAqC,GAAA,CAAI,QAAA,CAAS,aAAa;AACnE,MAAA,KAAA,MAAW,CAAC,KAAA,EAAO,EAAE,CAAA,IAAK,CAAA,CAAE,SAAQ,EAAG;AACrC,QAAA,MAAM,GAAA,GAAM,WAAA,CAAY,QAAA,CAAS,EAAE,CAAA;AAEnC,QAAA,IAAI,MAAA,CAAO,KAAA,CAAM,GAAG,CAAA,EAAG;AACrB,UAAA,OAAO,8BAAA,CAA+B,GAAA,CAAI,KAAA,EAAO,KAAK,CAAA;AAAA,QACxD;AAAA,MACF;AAAA,IACF,CAAC,CAAA;AAED,IAAA,IAAI,GAAA,CAAI,UAAA,CAAW,MAAM,CAAA,EAAG;AAC1B,MAAA,OAAO,MAAA,CAAO,IAAI,MAAM,CAAA;AAAA,IAC1B;AAEA,IAAA,OAAO,MAAA,CAAO,GAAG,CAAC,CAAA;AAAA,EACpB,CAAA;AAEA,EAAA,MAAM,IAAA,GAAwB,CAAC,CAAA,KAC7B,CAAC,IAAI,OAAA,CAAQ,CAAC,IACV,eAAA,EAAgB;AAAA;AAAA;AAAA,IAGf,GAAA,CAAI,GAAA;AAAA,MACH,GAAA,CAAI,IAAI,IAAI,CAAA;AAAA,MACZ,CAAC,CAAA,KAAM,WAAA,CAAY,IAAA,CAAK,CAAA,CAAE,CAAC,CAAC;AAAA;AAC9B,GAAA;AAEN,EAAA,MAAM,QAAQ,CAAC,CAAA;AAAA;AAAA,IAEb,GAAA,CAAI,IAAI,CAAA,EAAG,CAAC,OAAO,WAAA,CAAY,KAAA,CAAM,EAAE,CAAC;AAAA,GAAA;AAE1C,EAAA,OAAO;AAAA,IACL,QAAA;AAAA,IACA,IAAI,YAAA,GAAe;AACjB,MAAA,OAAO,eAAA,EAAgB;AAAA,IACzB,CAAA;AAAA,IACA,IAAA;AAAA,IACA,KAAA;AAAA,IACA,QAAA;AAAA,IACA,EAAA,EAAI,WAAW,QAAQ,CAAA;AAAA,IACvB,IAAA,EAAM,aAAa,QAAQ,CAAA;AAAA,IAC3B,QAAA,EAAU,eAAe,QAAQ;AAAA,GACnC;AACF;;;;"}

package/dist/array/index.d.mts

@@ -1,8 +1,9 @@
-export * from './array-at-least-length.mjs';
-export * from './array-at-most-length.mjs';
-export * from './array-bounded-length.mjs';
-export * from './array-of-length.mjs';
 export * from './array.mjs';
+export * from './bounded-length-tuple.mjs';
+export * from './fixed-length-tuple.mjs';
+export * from './length-constrained-array.mjs';
+export * from './max-length-tuple.mjs';
+export * from './min-length-tuple.mjs';
 export * from './non-empty-array.mjs';
 export * from './tuple.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/array/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/array/index.mts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/array/index.mts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}

package/dist/array/index.mjs

@@ -1,8 +1,9 @@
-export { arrayAtLeastLength } from './array-at-least-length.mjs';
-export { arrayAtMostLength } from './array-at-most-length.mjs';
-export { arrayBoundedLength } from './array-bounded-length.mjs';
-export { arrayOfLength } from './array-of-length.mjs';
 export { array } from './array.mjs';
+export { boundedLengthTuple } from './bounded-length-tuple.mjs';
+export { fixedLengthTuple } from './fixed-length-tuple.mjs';
+export { boundedLengthArray, fixedLengthArray, maxLengthArray, minLengthArray } from './length-constrained-array.mjs';
+export { maxLengthTuple } from './max-length-tuple.mjs';
+export { minLengthTuple } from './min-length-tuple.mjs';
 export { nonEmptyArray } from './non-empty-array.mjs';
 export { tuple } from './tuple.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/array/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

package/dist/array/length-constrained-array.d.mts

@@ -0,0 +1,82 @@
+import { type BoundedLengthArray, type FixedLengthArray, type MaxLengthArray, type MinLengthArray, type SupportedLength } from 'ts-type-forge';
+import { type Type } from '../type.mjs';
+export type { BoundedLengthArray, FixedLengthArray, MaxLengthArray, MinLengthArray, } from 'ts-type-forge';
+/**
+ * Creates a `Type` for a readonly array with exactly `size` elements, typed as
+ * the branded {@link FixedLengthArray} instead of the structural tuple type
+ * produced by `fixedLengthTuple`.
+ *
+ * Because the length constraint lives only in the brand, the element type is
+ * never expanded into tuple positions, which keeps type-checking cheap even
+ * when `A` is a large type. Prefer this over `fixedLengthTuple` when `A` is
+ * large; prefer `fixedLengthTuple` when positional element types or a literal
+ * `length` are needed.
+ */
+export declare function fixedLengthArray<A, N extends SupportedLength>(size: N, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: FixedLengthArray<N, A>;
+}>>): Type<FixedLengthArray<N, A>>;
+export declare function fixedLengthArray<A>(size: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: readonly A[];
+}>>): Type<readonly A[]>;
+/**
+ * Creates a `Type` for a readonly array with at least `minLength` elements,
+ * typed as the branded {@link MinLengthArray} instead of the structural
+ * `readonly [A, ..., A, ...A[]]` type produced by `minLengthTuple`.
+ *
+ * Because the length constraint lives only in the brand, the element type is
+ * never expanded into tuple positions, which keeps type-checking cheap even
+ * when `A` is a large type.
+ */
+export declare function minLengthArray<A, N extends SupportedLength>(minLength: N, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: MinLengthArray<N, A>;
+}>>): Type<MinLengthArray<N, A>>;
+export declare function minLengthArray<A>(minLength: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: readonly A[];
+}>>): Type<readonly A[]>;
+/**
+ * Creates a `Type` for a readonly array with at most `maxLength` elements,
+ * typed as the branded {@link MaxLengthArray} instead of the union of tuple
+ * types produced by `maxLengthTuple`.
+ *
+ * Because the length constraint lives only in the brand, no union of tuples
+ * of the element type is ever constructed, which keeps type-checking cheap
+ * even when `A` is a large type.
+ */
+export declare function maxLengthArray<A, N extends SupportedLength>(maxLength: N, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: MaxLengthArray<N, A>;
+}>>): Type<MaxLengthArray<N, A>>;
+export declare function maxLengthArray<A>(maxLength: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: readonly A[];
+}>>): Type<readonly A[]>;
+/**
+ * Creates a `Type` for a readonly array whose length is within the inclusive
+ * range `[min, max]`, typed as the branded {@link BoundedLengthArray} instead
+ * of the union of tuple types produced by `boundedLengthTuple`.
+ *
+ * Because the length constraint lives only in the brand, no union of tuples
+ * of the element type is ever constructed, which keeps type-checking cheap
+ * even when `A` is a large type.
+ */
+export declare function boundedLengthArray<A, Min extends SupportedLength, Max extends SupportedLength>(min: Min, max: Max, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: BoundedLengthArray<Min, Max, A>;
+}>>): Type<BoundedLengthArray<Min, Max, A>>;
+export declare function boundedLengthArray<A, Min extends SupportedLength>(min: Min, max: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: MinLengthArray<Min, A>;
+}>>): Type<MinLengthArray<Min, A>>;
+export declare function boundedLengthArray<A, Max extends SupportedLength>(min: number, max: Max, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: MaxLengthArray<Max, A>;
+}>>): Type<MaxLengthArray<Max, A>>;
+export declare function boundedLengthArray<A>(min: number, max: number, elementType: Type<A>, options?: Partial<Readonly<{
+    typeName: string;
+    defaultValue: readonly A[];
+}>>): Type<readonly A[]>;
+//# sourceMappingURL=length-constrained-array.d.mts.map

package/dist/array/length-constrained-array.d.mts.map

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