ts-fortress 5.0.1 → 5.1.0

package/README.md

@@ -910,6 +910,7 @@ type ValidationError = Readonly<{
 - `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
 
 ### Objects
 

package/dist/array/array-at-least-length.d.mts

@@ -0,0 +1,6 @@
+import { type Type } from '../type.mjs';
+export declare const arrayAtLeastLength: <A, N extends SmallUint>(size: N, elementType: Type<A>, options?: PartialReadonly<{
+    typeName: string;
+    defaultValue: ArrayAtLeastLen<N, A>;
+}>) => Type<ArrayAtLeastLen<N, A>>;
+//# sourceMappingURL=array-at-least-length.d.mts.map

package/dist/array/array-at-least-length.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-at-least-length.d.mts","sourceRoot":"","sources":["../../src/array/array-at-least-length.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAWxC,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,CAAC,SAAS,SAAS,EACvD,MAAM,CAAC,EACP,aAAa,IAAI,CAAC,CAAC,CAAC,EACpB,UAAU,eAAe,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACrC,CAAC,KACD,IAAI,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,CAiE5B,CAAC"}

package/dist/array/array-at-least-length.mjs

@@ -0,0 +1,63 @@
+import { 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 arrayAtLeastLength = (size, elementType, options) => {
+    const { typeName = `ArrayAtLeastLen<${size}, ${elementType.typeName}>`, 
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    defaultValue = Arr.create(size, elementType.defaultValue), } = options ?? {};
+    const validate = (a) => {
+        if (!Arr.isArray(a)) {
+            return Result.err([
+                createPrimitiveValidationError({
+                    actualValue: a,
+                    expectedType: 'array',
+                    typeName,
+                }),
+            ]);
+        }
+        if (a.length < size) {
+            return Result.err([
+                {
+                    path: [],
+                    actualValue: a,
+                    expectedType: typeName,
+                    message: `Expected array of length ${size} or more, got length ${a.length}`,
+                    typeName,
+                },
+            ]);
+        }
+        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 (errors.length > 0) {
+            return Result.err(errors);
+        }
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        return Result.ok(a);
+    };
+    const fill = (a) => Arr.isArray(a)
+        ? // TODO: remove as
+            // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+            Arr.map(Arr.seq(size), (i) => elementType.fill(a[i]))
+        : defaultValue;
+    return {
+        typeName,
+        defaultValue,
+        fill,
+        validate,
+        is: createIsFn(validate),
+        cast: createCastFn(validate),
+        assertIs: createAssertFn(validate),
+    };
+};
+
+export { arrayAtLeastLength };
+//# sourceMappingURL=array-at-least-length.mjs.map

package/dist/array/array-at-least-length.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-at-least-length.mjs","sources":["../../src/array/array-at-least-length.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAYO,MAAM,kBAAkB,GAAG,CAChC,IAAO,EACP,WAAoB,EACpB,OAGE,KAC6B;IAG/B,MAAM,EACJ,QAAQ,GAAG,CAAA,gBAAA,EAAmB,IAAI,CAAA,EAAA,EAAK,WAAW,CAAC,QAAQ,CAAA,CAAA,CAAG;;AAE9D,IAAA,YAAY,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,YAAY,CAAM,GAC/D,GAAG,OAAO,IAAI,EAAE;AAEjB,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;iBACT,CAAC;AACH,aAAA,CAAC;QACJ;AAEA,QAAA,IAAI,CAAC,CAAC,MAAM,GAAG,IAAI,EAAE;YACnB,OAAO,MAAM,CAAC,GAAG,CAAC;AAChB,gBAAA;AACE,oBAAA,IAAI,EAAE,EAAE;AACR,oBAAA,WAAW,EAAE,CAAC;AACd,oBAAA,YAAY,EAAE,QAAQ;AACtB,oBAAA,OAAO,EAAE,CAAA,yBAAA,EAA4B,IAAI,wBAAwB,CAAC,CAAC,MAAM,CAAA,CAAE;oBAC3E,QAAQ;AAC4B,iBAAA;AACvC,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;AACpC,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,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;AACrB,YAAA,OAAO,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC;QAC3B;;AAGA,QAAA,OAAO,MAAM,CAAC,EAAE,CAAC,CAAiB,CAAC;AACrC,IAAA,CAAC;AAED,IAAA,MAAM,IAAI,GAAoB,CAAC,CAAC,KAC9B,GAAG,CAAC,OAAO,CAAC,CAAC;AACX;;YAEG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,KAAK,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAa;UACjE,YAAY;IAElB,OAAO;QACL,QAAQ;QACR,YAAY;QACZ,IAAI;QACJ,QAAQ;AACR,QAAA,EAAE,EAAE,UAAU,CAAC,QAAQ,CAAC;AACxB,QAAA,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC;AAC5B,QAAA,QAAQ,EAAE,cAAc,CAAC,QAAQ,CAAC;KACnC;AACH;;;;"}

package/dist/array/index.d.mts

@@ -1,3 +1,4 @@
+export * from './array-at-least-length.mjs';
 export * from './array-of-length.mjs';
 export * from './array.mjs';
 export * from './non-empty-array.mjs';

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,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,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC"}

package/dist/array/index.mjs

@@ -1,3 +1,4 @@
+export { arrayAtLeastLength } from './array-at-least-length.mjs';
 export { arrayOfLength } from './array-of-length.mjs';
 export { array } from './array.mjs';
 export { nonEmptyArray } from './non-empty-array.mjs';

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/entry-point.mjs

@@ -1,4 +1,5 @@
 export { FiniteNumber, Int, Int16, Int32, Int8, NonNegativeFiniteNumber, NonNegativeInt16, NonNegativeInt32, NonZeroFiniteNumber, NonZeroInt, NonZeroInt16, NonZeroInt32, NonZeroSafeInt, NonZeroUint16, NonZeroUint32, PositiveFiniteNumber, PositiveInt, PositiveInt16, PositiveInt32, PositiveSafeInt, PositiveUint16, PositiveUint32, Result, SafeInt, SafeUint, Uint, Uint16, Uint32, Uint8, asFiniteNumber, asInt, asInt16, asInt32, asInt8, asNonNegativeFiniteNumber, asNonNegativeInt16, asNonNegativeInt32, asNonZeroFiniteNumber, asNonZeroInt, asNonZeroInt16, asNonZeroInt32, asNonZeroSafeInt, asNonZeroUint16, asNonZeroUint32, asPositiveFiniteNumber, asPositiveInt, asPositiveInt16, asPositiveInt32, asPositiveSafeInt, asPositiveUint16, asPositiveUint32, asSafeInt, asSafeUint, asUint, asUint16, asUint32, asUint8, isBigint, isFiniteNumber, isInt, isInt16, isInt32, isInt8, isNonNegativeFiniteNumber, isNonNegativeInt16, isNonNegativeInt32, isNonZeroFiniteNumber, isNonZeroInt, isNonZeroInt16, isNonZeroInt32, isNonZeroSafeInt, isNonZeroUint16, isNonZeroUint32, isPositiveFiniteNumber, isPositiveInt, isPositiveInt16, isPositiveInt32, isPositiveSafeInt, isPositiveUint16, isPositiveUint32, isSafeInt, isSafeUint, isUint, isUint16, isUint32, isUint8 } from 'ts-data-forge';
+export { arrayAtLeastLength } from './array/array-at-least-length.mjs';
 export { arrayOfLength } from './array/array-of-length.mjs';
 export { array } from './array/array.mjs';
 export { nonEmptyArray } from './array/non-empty-array.mjs';

package/dist/entry-point.mjs.map

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

package/dist/index.mjs

@@ -1,3 +1,4 @@
+export { arrayAtLeastLength } from './array/array-at-least-length.mjs';
 export { arrayOfLength } from './array/array-of-length.mjs';
 export { array } from './array/array.mjs';
 export { nonEmptyArray } from './array/non-empty-array.mjs';

package/dist/index.mjs.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-fortress",
-  "version": "5.0.1",
+  "version": "5.1.0",
   "private": false,
   "keywords": [
     "typescript"
@@ -79,7 +79,7 @@
     "@semantic-release/github": "^11.0.6",
     "@semantic-release/npm": "^12.0.2",
     "@semantic-release/release-notes-generator": "^14.1.0",
-    "@types/node": "^24.3.3",
+    "@types/node": "^24.5.2",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "conventional-changelog-conventionalcommits": "^9.1.0",
@@ -94,9 +94,9 @@
     "prettier": "^3.6.2",
     "prettier-plugin-organize-imports": "^4.2.0",
     "prettier-plugin-packagejson": "^2.5.19",
-    "rollup": "^4.50.1",
-    "semantic-release": "^24.2.8",
-    "ts-repo-utils": "^7.5.0",
+    "rollup": "^4.52.0",
+    "semantic-release": "^24.2.9",
+    "ts-repo-utils": "^7.7.0",
     "tslib": "^2.8.1",
     "tsx": "^4.20.5",
     "typedoc": "^0.28.13",

package/src/array/array-at-least-length.mts

@@ -0,0 +1,85 @@
+import { Arr, Result } from 'ts-data-forge';
+import { type Type } from '../type.mjs';
+import {
+  createAssertFn,
+  createCastFn,
+  createIsFn,
+  createPrimitiveValidationError,
+  prependIndexToValidationErrors,
+  type ValidationError,
+  type ValidationErrorWithMessage,
+} from '../utils/index.mjs';
+
+export const arrayAtLeastLength = <A, N extends SmallUint>(
+  size: N,
+  elementType: Type<A>,
+  options?: PartialReadonly<{
+    typeName: string;
+    defaultValue: ArrayAtLeastLen<N, A>;
+  }>,
+): Type<ArrayAtLeastLen<N, A>> => {
+  type T = ArrayAtLeastLen<N, A>;
+
+  const {
+    typeName = `ArrayAtLeastLen<${size}, ${elementType.typeName}>`,
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    defaultValue = Arr.create(size, elementType.defaultValue) as T,
+  } = options ?? {};
+
+  const validate: Type<T>['validate'] = (a) => {
+    if (!Arr.isArray(a)) {
+      return Result.err([
+        createPrimitiveValidationError({
+          actualValue: a,
+          expectedType: 'array',
+          typeName,
+        }),
+      ]);
+    }
+
+    if (a.length < size) {
+      return Result.err([
+        {
+          path: [],
+          actualValue: a,
+          expectedType: typeName,
+          message: `Expected array of length ${size} or more, got length ${a.length}`,
+          typeName,
+        } satisfies ValidationErrorWithMessage,
+      ]);
+    }
+
+    const errors: readonly ValidationError[] = 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 (errors.length > 0) {
+      return Result.err(errors);
+    }
+
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    return Result.ok(a as unknown as T);
+  };
+
+  const fill: Type<T>['fill'] = (a) =>
+    Arr.isArray(a)
+      ? // TODO: remove as
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        (Arr.map(Arr.seq(size), (i) => elementType.fill(a[i]) satisfies A) as T)
+      : defaultValue;
+
+  return {
+    typeName,
+    defaultValue,
+    fill,
+    validate,
+    is: createIsFn(validate),
+    cast: createCastFn(validate),
+    assertIs: createAssertFn(validate),
+  };
+};

package/src/array/array-at-least-length.test.mts

@@ -0,0 +1,197 @@
+import { expectType, Result } from 'ts-data-forge';
+import { number } from '../primitives/index.mjs';
+import { type TypeOf } from '../type.mjs';
+import {
+  type ValidationError,
+  validationErrorsToMessages,
+} from '../utils/index.mjs';
+import { arrayAtLeastLength } from './array-at-least-length.mjs';
+
+describe('arrayAtLeastLength', () => {
+  describe('arg patterns', () => {
+    test('without explicit default value', () => {
+      expect(arrayAtLeastLength(3, number()).defaultValue).toStrictEqual([0, 0, 0]);
+    });
+
+    test('with explicit element default value', () => {
+      expect(arrayAtLeastLength(2, number(5)).defaultValue).toStrictEqual([5, 5]);
+    });
+
+    test('with explicit default value override', () => {
+      expect(
+        arrayAtLeastLength(3, number(), {
+          typeName: 'ys',
+          defaultValue: [1, 2, 3, 4],
+        }).defaultValue,
+      ).toStrictEqual([1, 2, 3, 4]);
+    });
+  });
+
+  const xs = arrayAtLeastLength(3, number(), {
+    typeName: 'xs',
+    defaultValue: [1, 2, 3],
+  });
+
+  type Xs = TypeOf<typeof xs>;
+
+  expectType<Xs, ArrayAtLeastLen<3, number>>('=');
+
+  expectType<typeof xs.defaultValue, Xs>('=');
+
+  describe('is', () => {
+    test('truthy case', () => {
+      const ys: unknown = [4, 5, 6, 7];
+
+      if (xs.is(ys)) {
+        expectType<typeof ys, Xs>('=');
+      } else {
+        expectType<typeof ys, unknown>('=');
+      }
+
+      expect(xs.is(ys)).toBe(true);
+    });
+
+    test('falsy case 1', () => {
+      const ys: unknown = [1, 2];
+
+      if (xs.is(ys)) {
+        expectType<typeof ys, Xs>('=');
+      } else {
+        expectType<typeof ys, unknown>('=');
+      }
+
+      expect(xs.is(ys)).toBe(false);
+    });
+
+    test('falsy case 2', () => {
+      const ys: unknown = [1, '2', 3];
+
+      if (xs.is(ys)) {
+        expectType<typeof ys, Xs>('=');
+      } else {
+        expectType<typeof ys, unknown>('=');
+      }
+
+      expect(xs.is(ys)).toBe(false);
+    });
+
+    test('falsy case 3', () => {
+      const ys: unknown = 'foo';
+
+      if (xs.is(ys)) {
+        expectType<typeof ys, Xs>('=');
+      } else {
+        expectType<typeof ys, unknown>('=');
+      }
+
+      expect(xs.is(ys)).toBe(false);
+    });
+  });
+
+  describe('validate', () => {
+    test('truthy case', () => {
+      const ys: unknown = [4, 5, 6, 7];
+
+      const result = xs.validate(ys);
+      expectType<typeof result, Result<Xs, readonly ValidationError[]>>('=');
+      expect(Result.isOk(result)).toBe(true);
+
+      const resultValue = Result.unwrapThrow(result);
+      expect(resultValue).toStrictEqual([4, 5, 6, 7]);
+    });
+
+    test('validate returns input as-is for OK cases', () => {
+      const input = [4, 5, 6];
+      const result = xs.validate(input);
+      expect(Result.isOk(result)).toBe(true);
+      const resultValue1 = Result.unwrapThrow(result);
+      expect(resultValue1).toBe(input); // ✅ same reference
+    });
+
+    test('falsy case 1', () => {
+      const ys: unknown = 'foo';
+
+      const result = xs.validate(ys);
+      expect(Result.isErr(result)).toBe(true);
+
+      const resultError = Result.unwrapErrThrow(result);
+      expect(resultError).toStrictEqual([
+        {
+          path: [],
+          actualValue: ys,
+          expectedType: 'array',
+          typeName: 'xs',
+          message: undefined,
+        },
+      ]);
+
+      expect(validationErrorsToMessages(resultError)).toStrictEqual([
+        'Expected <array>, got <string> type value "foo".',
+      ]);
+    });
+
+    test('falsy case 2', () => {
+      const ys: unknown = [1, 2];
+
+      const result = xs.validate(ys);
+      expect(Result.isErr(result)).toBe(true);
+
+      const resultError = Result.unwrapErrThrow(result);
+      expect(resultError).toStrictEqual([
+        {
+          path: [],
+          actualValue: ys,
+          expectedType: 'xs',
+          typeName: 'xs',
+          message: 'Expected array of length 3 or more, got length 2',
+        },
+      ]);
+
+      expect(validationErrorsToMessages(resultError)).toStrictEqual([
+        'Expected array of length 3 or more, got length 2',
+      ]);
+    });
+
+    test('falsy case 3', () => {
+      const ys: unknown = [1, '2', 3];
+
+      const result = xs.validate(ys);
+      expect(Result.isErr(result)).toBe(true);
+
+      const resultError = Result.unwrapErrThrow(result);
+      expect(resultError).toStrictEqual([
+        {
+          path: ['1'],
+          actualValue: '2',
+          expectedType: 'number',
+          typeName: 'number',
+          message: undefined,
+        },
+      ]);
+
+      expect(validationErrorsToMessages(resultError)).toStrictEqual([
+        'Expected <number> at 1, got <string> type value "2".',
+      ]);
+    });
+  });
+
+  describe('fill', () => {
+    test('keeps numeric entries and trims extras', () => {
+      const ys: unknown = [4, 5, 6, 7];
+
+      expect(xs.fill(ys)).toStrictEqual([4, 5, 6]);
+    });
+
+    test('fills missing or invalid entries', () => {
+      const ys: unknown = [4, '5'];
+
+      expect(xs.fill(ys)).toStrictEqual([4, 0, 0]);
+    });
+
+    test('fill with the default value for non-array input', () => {
+      const ys: unknown = null;
+
+      expect(xs.fill(ys)).toStrictEqual([1, 2, 3]);
+    });
+  });
+});

package/src/array/index.mts

@@ -1,3 +1,4 @@
+export * from './array-at-least-length.mjs';
 export * from './array-of-length.mjs';
 export * from './array.mjs';
 export * from './non-empty-array.mjs';