ts-fortress 1.0.0 → 2.0.0

package/README.md

@@ -2,17 +2,23 @@
 
 TypeScript-first schema validation library with static type inference.
 
-ts-fortress is a runtime validation library similar to [io-ts](https://github.com/gcanti/io-ts) and [zod](https://github.com/colinhacks/zod), designed to provide type-safe schema validation with excellent TypeScript integration and static type inference.
+[![npm version](https://img.shields.io/npm/v/ts-fortress.svg)](https://www.npmjs.com/package/ts-fortress)
+[![npm downloads](https://img.shields.io/npm/dm/ts-fortress.svg)](https://www.npmjs.com/package/ts-fortress)
+[![License](https://img.shields.io/npm/l/ts-fortress.svg)](./LICENSE)
+[![codecov](https://codecov.io/gh/noshiro-pf/ts-fortress/graph/badge.svg?token=Y522SWQTPB)](https://codecov.io/gh/noshiro-pf/ts-fortress)
+
+**ts-fortress** is a runtime validation library similar to [io-ts](https://github.com/gcanti/io-ts) and [zod](https://github.com/colinhacks/zod), designed to provide type-safe schema validation with excellent TypeScript integration and static type inference.
 
 ## Features
 
 - 🔒 **Type-safe validation** - Full TypeScript support with static type inference
 - 🏗️ **Composable schemas** - Build complex validation schemas from simple building blocks
 - 🎯 **Zero-runtime overhead** - Type information is inferred at compile time
-- 🔄 **Result-based error handling** - Structured error reporting with `Result<T, Error[]>`
+- 🔄 **Result-based error handling** - Structured error reporting with `Result<T, readonly ValidationError[]>`
 - 🏷️ **Branded types** - Rich collection of branded number types (Int, SafeInt, PositiveInt, etc.)
 - ⚡ **Performance focused** - Minimal runtime overhead and optimized validation
 - 🧩 **Functional composition** - Union, intersection, and merge operations for schema composition
+- 🛠️ **Required default values** - All schemas require explicit default values, enabling automatic data filling via `fill()` function
 
 ## Installation
 
@@ -69,6 +75,387 @@ if (result.isOk()) {
 }
 ```
 
+## Default Values and Data Filling
+
+One of ts-fortress's key design decisions is **requiring explicit default values** for all schema types. This enables powerful data filling capabilities:
+
+```typescript
+import * as t from 'ts-fortress';
+
+// Every type requires a default value
+const UserProfile = t.record({
+    name: t.string('Anonymous'), // Default: 'Anonymous'
+    age: t.number(0), // Default: 0
+    email: t.optional(t.string('')), // Optional field with default ''
+    preferences: t.record({
+        theme: t.string('light'), // Default: 'light'
+        notifications: t.boolean(true), // Default: true
+    }),
+    tags: t.array(t.string('')), // Default: empty array []
+});
+
+// The fill() function automatically provides missing values
+const partialData = {
+    name: 'John Doe',
+    preferences: {
+        theme: 'dark',
+        // notifications missing - will be filled with default
+    },
+    // age, email, tags missing - will be filled with defaults
+};
+
+const filledData = UserProfile.fill(partialData);
+console.log(filledData);
+// Output: {
+//   name: 'John Doe',
+//   age: 0,                    // ← Filled with default
+//   email: '',                 // ← Filled with default
+//   preferences: {
+//     theme: 'dark',
+//     notifications: true,     // ← Filled with default
+//   },
+//   tags: [],                  // ← Filled with default
+// }
+
+// fill() is type-safe and always returns a complete object
+type UserProfile = t.TypeOf<typeof UserProfile>;
+const completeUser: UserProfile = UserProfile.fill(anyPartialData);
+```
+
+### Benefits of Required Default Values
+
+- **Consolidated definitions**: Type definitions and default values are defined in one place, eliminating the need to maintain separate default objects
+- **Data integrity**: Never worry about missing required fields
+- **API resilience**: Handle incomplete data gracefully from external APIs
+- **Form handling**: Easily initialize forms with default values
+- **Configuration**: Provide sensible defaults for optional configuration
+- **Testing**: Generate complete test data from partial fixtures
+
+```typescript
+// Real-world example: API response handling
+const ApiResponse = t.record({
+    data: t.array(t.string('')),
+    pagination: t.record({
+        page: t.number(1),
+        limit: t.number(10),
+        total: t.number(0),
+    }),
+    meta: t.record({
+        timestamp: t.number(Date.now()),
+        version: t.string('1.0.0'),
+    }),
+});
+
+// Handle incomplete API responses gracefully
+const incompleteResponse = { data: ['item1', 'item2'] };
+const completeResponse = ApiResponse.fill(incompleteResponse);
+// All missing fields are automatically filled with their defaults
+```
+
+## Why ts-fortress over Zod and io-ts?
+
+While ts-fortress, [Zod](https://github.com/colinhacks/zod), and [io-ts](https://github.com/gcanti/io-ts) are all excellent TypeScript validation libraries, ts-fortress provides enhanced type safety during validator construction and addresses critical runtime consistency issues found in io-ts.
+
+### Type Safety in Schema Definition
+
+**Problem with Zod**: The following code compiles without errors but creates an invalid schema:
+
+```typescript
+import * as z from 'zod';
+
+// ❌ This compiles but is incorrect!
+export const SomeObject = z.object({
+    key1: 1, // Should be z.literal(1)
+    key2: 'string', // Should be z.string()
+});
+
+export type SomeObject = z.infer<typeof SomeObject>;
+```
+
+The above Zod schema will fail at runtime because raw values (`1`, `'string'`) are not valid Zod validators.
+
+**Correct Zod usage** requires remembering to wrap all values:
+
+```typescript
+// ✅ Correct Zod usage
+export const SomeObject = z.object({
+    key1: z.literal(1),
+    key2: z.string(),
+});
+```
+
+**ts-fortress prevents this error at compile time**:
+
+```typescript
+import * as t from 'ts-fortress';
+
+// ❌ TypeScript error - this won't compile!
+export const SomeObject = t.record({
+    key1: 1, // Error: number is not assignable to Type<unknown>
+    key2: 'string', // Error: string is not assignable to Type<unknown>
+});
+
+// ✅ Correct ts-fortress usage - enforced by TypeScript
+export const SomeObject = t.record({
+    key1: t.numberLiteral(1), // or t.number(1) with default
+    key2: t.string(''),
+});
+```
+
+### Benefits
+
+- **Compile-time safety**: TypeScript catches invalid schema definitions immediately
+- **IDE support**: Better autocomplete and error highlighting during development
+- **Reduced runtime errors**: Impossible to create invalid schemas that fail at runtime
+- **Self-documenting**: The type system guides you toward correct usage
+
+### Deep Readonly Types by Default
+
+**ts-fortress generates deeply readonly types**, promoting immutability and preventing accidental mutations:
+
+```typescript
+import * as t from 'ts-fortress';
+
+const UserType = t.record({
+    name: t.string(''),
+    address: t.record({
+        street: t.string(''),
+        city: t.string(''),
+    }),
+    tags: t.array(t.string('')),
+});
+
+type User = t.TypeOf<typeof UserType>;
+// ↑ Readonly<{
+//     name: string;
+//     address: Readonly<{
+//       street: string;
+//       city: string;
+//     }>;
+//     tags: readonly string[];
+//   }>
+
+const user: User = UserType.cast(someData);
+
+// ❌ All of these produce TypeScript errors:
+user.name = 'new name'; // Cannot assign to 'name' because it is read-only
+user.address.street = 'new street'; // Cannot assign to 'street' because it is read-only
+user.tags.push('new tag'); // Property 'push' does not exist on readonly array
+user.tags[0] = 'modified'; // Index signature in type 'readonly string[]' only permits reading
+```
+
+**In contrast, Zod types are mutable by default**:
+
+```typescript
+import * as z from 'zod';
+
+const UserSchema = z.object({
+    name: z.string(),
+    address: z.object({
+        street: z.string(),
+        city: z.string(),
+    }),
+    tags: z.array(z.string()),
+});
+
+type User = z.infer<typeof UserSchema>;
+// ↑ {
+//     name: string;
+//     address: {
+//       street: string;
+//       city: string;
+//     };
+//     tags: string[];
+//   }
+
+const user: User = UserSchema.parse(someData);
+
+// ✅ These all work in Zod (but may not be desirable):
+user.name = 'new name'; // No error
+user.address.street = 'new street'; // No error
+user.tags.push('new tag'); // No error
+user.tags[0] = 'modified'; // No error
+```
+
+### Benefits of Deep Readonly
+
+- **Immutability by default**: Prevents accidental mutations that can lead to bugs
+- **Functional programming support**: Encourages functional programming patterns
+- **Predictable data flow**: Ensures data integrity throughout your application
+- **Better optimization**: Enables better compiler optimizations and reasoning about code
+- **Thread safety**: Immutable data is inherently safe to share between contexts
+
+### Runtime-Type Consistency Issues in io-ts
+
+**io-ts has several long-standing bugs** where runtime behavior doesn't match TypeScript types, which have remained unfixed for years:
+
+#### 1. Keyof Type Mismatch ([Issue #697](https://github.com/gcanti/io-ts/issues/697))
+
+```typescript
+import * as t from 'io-ts';
+
+const T = t.keyof({
+    0: undefined,
+    1: undefined,
+    2: undefined,
+    3: undefined,
+    4: undefined,
+});
+
+// ❌ Runtime behavior is inconsistent with TypeScript types!
+console.log(T.decode(0)); // Left (fails) - number 0 is rejected
+console.log(T.decode('0')); // Right (succeeds) - string "0" is accepted
+
+type T = t.TypeOf<typeof T>;
+// ↑ TypeScript infers: 0 | 1 | 2 | 3 | 4 (number literals)
+// But should be: "0" | "1" | "2" | "3" | "4" (string literals)
+
+// The runtime validator only accepts strings, but TypeScript thinks it accepts numbers!
+```
+
+#### 2. Union + Undefined Decode Issues ([Issue #677](https://github.com/gcanti/io-ts/issues/677))
+
+```typescript
+import * as t from 'io-ts';
+import { isRight } from 'fp-ts/Either';
+
+const A = t.type({
+    A: t.union([t.number, t.undefined, t.null]),
+});
+
+const B = t.type({
+    B: t.union([t.number, t.undefined, t.null]),
+});
+
+const C = t.partial({
+    C: t.union([t.number, t.null]),
+});
+
+// ❌ Case 1: Union decode adds unexpected fields
+{
+    const UnionBA = t.union([B, A]);
+    const res = UnionBA.decode({ A: 1 });
+
+    if (isRight(res)) {
+        console.log(res.right); // { A: 1, B: undefined } <- NG (expected: { A: 1 })
+        console.log(A.is(res.right)); // true  <- ok
+        console.log(B.is(res.right)); // true  <- NG (expected: false)
+    }
+}
+
+// ❌ Case 2: Union decode produces inconsistent results
+{
+    const UnionCA = t.union([C, A]);
+    const res = UnionCA.decode({ A: 1 });
+
+    if (isRight(res)) {
+        console.log(res.right); // { A: 1 } <- NG (expected: {})
+        console.log(A.is(res.right)); // true  <- ok
+        console.log(C.is(res.right)); // true  <- ok
+    }
+}
+```
+
+**ts-fortress eliminates these problems** by ensuring strict runtime-type consistency:
+
+```typescript
+import * as t from 'ts-fortress';
+
+// ✅ ts-fortress: Runtime and types always match
+const T = t.keyof(
+    t.record({
+        0: t.undefinedType,
+        1: t.undefinedType,
+        2: t.undefinedType,
+        3: t.undefinedType,
+        4: t.undefinedType,
+    }),
+);
+
+type T = t.TypeOf<typeof T>;
+// ↑ TypeScript correctly infers: "0" | "1" | "2" | "3" | "4" (string literals)
+
+// ✅ Runtime behavior matches TypeScript types exactly
+console.log(T.validate(0)); // ❌ Fails correctly - number 0 is rejected
+console.log(T.validate('0')); // ✅ Success - string "0" is accepted
+
+// ✅ Complex union types work reliably without unexpected behavior
+const A = t.record({
+    A: t.union([t.number(0), t.undefinedType, t.nullType]),
+});
+
+const B = t.record({
+    B: t.union([t.number(0), t.undefinedType, t.nullType]),
+});
+
+const C = t.partial(
+    t.record({
+        C: t.union([t.number(0), t.nullType]),
+    }),
+);
+
+// ✅ Case 1: Union validation is predictable and correct
+{
+    const UnionBA = t.union([B, A]);
+    const result = UnionBA.validate({ A: 1 });
+
+    if (result.isOk()) {
+        console.log(result.value); // { A: 1 } <- ✅ Correct! No unexpected fields
+        console.log(A.is(result.value)); // true  <- ✅ Correct
+        console.log(B.is(result.value)); // false <- ✅ Correct! B requires field B
+    }
+}
+
+// ✅ Case 2: Consistent validation behavior
+{
+    const UnionCA = t.union([C, A]);
+    const result = UnionCA.validate({ A: 1 });
+
+    if (result.isOk()) {
+        console.log(result.value); // { A: 1 } <- ✅ Correct and consistent
+        console.log(A.is(result.value)); // true  <- ✅ Correct
+        console.log(C.is(result.value)); // true  <- ✅ Consistent! ts-fortress partial types allow extra fields
+    }
+}
+```
+
+This makes ts-fortress especially valuable in large codebases where schema correctness is critical and runtime failures need to be minimized.
+
+## Migration from io-ts
+
+If you're coming from io-ts, here's how common patterns translate:
+
+```typescript
+// io-ts style
+import * as t from 'io-ts';
+
+const UserCodec = t.type({
+    id: t.string,
+    name: t.string,
+    age: t.number,
+});
+
+type User = t.TypeOf<typeof UserCodec>;
+
+// ts-fortress style
+import * as t from 'ts-fortress';
+
+const UserType = t.record({
+    id: t.string(''),
+    name: t.string(''),
+    age: t.number(0),
+});
+
+type User = t.TypeOf<typeof UserType>;
+```
+
+Key differences:
+
+- **Default values**: ts-fortress requires explicit default values for better type safety
+- **Naming**: `record` instead of `type`, more explicit function names
+- **Error handling**: Built-in `Result` type instead of `Either`
+- **Branded types**: Rich collection of pre-built branded number types
+
 ## Core Concepts
 
 ### Type Interface
@@ -76,15 +463,15 @@ if (result.isOk()) {
 Every validator in ts-fortress implements the `Type<A>` interface:
 
 ```typescript
-interface Type<A> {
+type Type<A> = Readonly<{
     typeName: string; // Human-readable type name
     defaultValue: A; // Default value for this type
     is: (a: unknown) => a is A; // Type guard function
     assertIs: (a: unknown) => asserts a is A; // Type assertion
     cast: (a: unknown) => A; // Cast with fallback to default
     fill: (a: unknown) => A; // Fill missing values with defaults
-    validate: (a: unknown) => Result<A, string[]>; // Detailed validation
-}
+    validate: (a: unknown) => Result<A, readonly ValidationError[]>; // Detailed validation
+}>;
 ```
 
 ### Primitive Types
@@ -212,7 +599,7 @@ type DiceRoll = t.TypeOf<typeof DiceRoll>; // 1 | 2 | 3 | 4 | 5 | 6
 
 ## Error Handling
 
-ts-fortress uses `Result<T, string[]>` for structured error handling:
+ts-fortress uses `Result<T, readonly ValidationError[]>` for structured error handling with detailed error information:
 
 ```typescript
 const UserType = t.record({
@@ -223,9 +610,18 @@ const UserType = t.record({
 const invalidData = { name: 123, age: 'not a number' };
 
 const result = UserType.validate(invalidData);
-if (result.isErr()) {
-    console.log(result.value);
-    // Array of error messages:
+if (Result.isErr(result)) {
+    // result.value is an array of ValidationError objects
+    result.value.forEach((error) => {
+        console.log('Path:', error.path); // ['name'] or ['age']
+        console.log('Expected:', error.expectedType); // 'string' or 'number'
+        console.log('Actual:', error.actualValue); // 123 or 'not a number'
+        console.log('Type:', error.typeName); // type being validated
+    });
+
+    // Convert to legacy string messages for backward compatibility
+    const messages = t.validationErrorsToMessages(result.value);
+    console.log(messages);
     // ['Expected string at name, got number', 'Expected number at age, got string']
 }
 
@@ -237,40 +633,40 @@ try {
 }
 ```
 
-## Migration from io-ts
+### ValidationError Structure
 
-If you're coming from io-ts, here's how common patterns translate:
+Each validation error provides detailed information:
 
 ```typescript
-// io-ts style
-import * as t from 'io-ts';
-
-const UserCodec = t.type({
-    id: t.string,
-    name: t.string,
-    age: t.number,
-});
+interface ValidationError {
+    path: readonly string[]; // Path to the field that failed
+    actualValue: unknown; // The actual value that failed validation
+    expectedType: string; // The expected type or constraint
+    message?: string; // Optional custom error message
+    typeName: string; // Name of the type being validated
+}
+```
 
-type User = t.TypeOf<typeof UserCodec>;
+### Error Utilities
 
-// ts-fortress style
+```typescript
 import * as t from 'ts-fortress';
 
-const UserType = t.record({
-    id: t.string(''),
-    name: t.string(''),
-    age: t.number(0),
-});
-
-type User = t.TypeOf<typeof UserType>;
-```
+// Convert ValidationError objects to string messages
+const messages = t.validationErrorsToMessages(errors);
 
-Key differences:
+// Convert single ValidationError to message
+const message = t.validationErrorToMessage(error);
 
-- **Default values**: ts-fortress requires explicit default values for better type safety
-- **Naming**: `record` instead of `type`, more explicit function names
-- **Error handling**: Built-in `Result` type instead of `Either`
-- **Branded types**: Rich collection of pre-built branded number types
+// Create custom validation errors
+const customError = t.createValidationError({
+    path: ['user', 'email'],
+    actualValue: 'invalid-email',
+    expectedType: 'valid email address',
+    typeName: 'EmailAddress',
+    message: 'Please provide a valid email address',
+});
+```
 
 ## API Reference
 

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

@@ -1 +1 @@
-{"version":3,"file":"array-of-length.d.mts","sourceRoot":"","sources":["../../src/array/array-of-length.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAQxC,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,SAAS,SAAS,EAClD,MAAM,CAAC,EACP,aAAa,IAAI,CAAC,CAAC,CAAC,EACpB,UAAU,QAAQ,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACpC,CAAC,KACD,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CA2D1B,CAAC"}
+{"version":3,"file":"array-of-length.d.mts","sourceRoot":"","sources":["../../src/array/array-of-length.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAQxC,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,SAAS,SAAS,EAClD,MAAM,CAAC,EACP,aAAa,IAAI,CAAC,CAAC,CAAC,EACpB,UAAU,QAAQ,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACpC,CAAC,KACD,IAAI,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAkE1B,CAAC"}

package/dist/array/array-of-length.mjs

@@ -2,7 +2,7 @@ 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 { validationErrorMessage } from '../utils/validation-error-message.mjs';
+import { createPrimitiveValidationError, prependIndexToValidationErrors } from '../validation-error.mjs';
 
 const arrayOfLength = (size, elementType, options) => {
     const { typeName, 
@@ -12,20 +12,32 @@ const arrayOfLength = (size, elementType, options) => {
     const validate = (a) => {
         if (!Arr.isArray(a)) {
             return Result.err([
-                validationErrorMessage(a, 'The value is expected to be an array'),
+                createPrimitiveValidationError({
+                    actualValue: a,
+                    expectedType: 'array',
+                    typeName: typeNameFilled,
+                }),
             ]);
         }
         if (a.length !== size) {
             return Result.err([
-                `The value is expected to be an array of length ${size}, but it is ${a.length}.`,
+                {
+                    path: [],
+                    actualValue: a,
+                    expectedType: typeNameFilled,
+                    message: `Expected array of length ${size}, got length ${a.length}`,
+                    typeName: typeNameFilled,
+                },
             ]);
         }
-        for (const [index, el] of a.entries()) {
+        const errors = a.flatMap((el, index) => {
             const res = elementType.validate(el);
-            if (Result.isErr(res)) {
-                const message = validationErrorMessage(el, `The array element is expected to be <${elementType.typeName}>`, (str) => `but the actual value at index ${index} is '${str}'`);
-                return Result.err([message, ...res.value]);
-            }
+            return Result.isErr(res)
+                ? prependIndexToValidationErrors(res.value, index)
+                : [];
+        });
+        if (errors.length > 0) {
+            return Result.err(errors);
         }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
         return Result.ok(a);

package/dist/array/array-of-length.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-of-length.mjs","sources":["../../src/array/array-of-length.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AASO,MAAM,aAAa,GAAG,CAC3B,IAAO,EACP,WAAoB,EACpB,OAGE,KAC2B;AAG7B,IAAA,MAAM,EACJ,QAAQ;;AAER,IAAA,YAAY,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,YAAY,CAAM,GAC/D,GAAG,OAAO,IAAI,EAAE;IAEjB,MAAM,cAAc,GAClB,QAAQ,IAAI,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA,CAAA,CAAG;AAEtE,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,sBAAsB,CAAC,CAAC,EAAE,sCAAsC,CAAC;AAClE,aAAA,CAAC;QACJ;AAEA,QAAA,IAAI,CAAC,CAAC,MAAM,KAAK,IAAI,EAAE;YACrB,OAAO,MAAM,CAAC,GAAG,CAAC;AAChB,gBAAA,CAAA,+CAAA,EAAkD,IAAI,CAAA,YAAA,EAAe,CAAC,CAAC,MAAM,CAAA,CAAA,CAAG;AACjF,aAAA,CAAC;QACJ;AAEA,QAAA,KAAK,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE;YACrC,MAAM,GAAG,GAAG,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;AAEpC,YAAA,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;gBACrB,MAAM,OAAO,GAAG,sBAAsB,CACpC,EAAE,EACF,CAAA,qCAAA,EAAwC,WAAW,CAAC,QAAQ,CAAA,CAAA,CAAG,EAC/D,CAAC,GAAG,KAAK,CAAA,8BAAA,EAAiC,KAAK,CAAA,KAAA,EAAQ,GAAG,CAAA,CAAA,CAAG,CAC9D;AAED,gBAAA,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC;YAC5C;QACF;;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;AACL,QAAA,QAAQ,EAAE,cAAc;QACxB,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;;;;"}
+{"version":3,"file":"array-of-length.mjs","sources":["../../src/array/array-of-length.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AASO,MAAM,aAAa,GAAG,CAC3B,IAAO,EACP,WAAoB,EACpB,OAGE,KAC2B;AAG7B,IAAA,MAAM,EACJ,QAAQ;;AAER,IAAA,YAAY,GAAG,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,YAAY,CAAM,GAC/D,GAAG,OAAO,IAAI,EAAE;IAEjB,MAAM,cAAc,GAClB,QAAQ,IAAI,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA,CAAA,CAAG;AAEtE,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;AACrB,oBAAA,QAAQ,EAAE,cAAc;iBACzB,CAAC;AACH,aAAA,CAAC;QACJ;AAEA,QAAA,IAAI,CAAC,CAAC,MAAM,KAAK,IAAI,EAAE;YACrB,OAAO,MAAM,CAAC,GAAG,CAAC;AAChB,gBAAA;AACE,oBAAA,IAAI,EAAE,EAAE;AACR,oBAAA,WAAW,EAAE,CAAC;AACd,oBAAA,YAAY,EAAE,cAAc;AAC5B,oBAAA,OAAO,EAAE,CAAA,yBAAA,EAA4B,IAAI,gBAAgB,CAAC,CAAC,MAAM,CAAA,CAAE;AACnE,oBAAA,QAAQ,EAAE,cAAc;AACY,iBAAA;AACvC,aAAA,CAAC;QACJ;QAEA,MAAM,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,KAAK,KAAI;YACrC,MAAM,GAAG,GAAG,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;AACpC,YAAA,OAAO,MAAM,CAAC,KAAK,CAAC,GAAG;kBACnB,8BAA8B,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK;kBAC/C,EAAE;AACR,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;AACL,QAAA,QAAQ,EAAE,cAAc;QACxB,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/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;AAQxC,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,CA4CnB,CAAC"}
+{"version":3,"file":"array.d.mts","sourceRoot":"","sources":["../../src/array/array.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAOxC,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,CA6CnB,CAAC"}

package/dist/array/array.mjs

@@ -2,7 +2,7 @@ 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 { validationErrorMessage } from '../utils/validation-error-message.mjs';
+import { createPrimitiveValidationError, prependIndexToValidationErrors } from '../validation-error.mjs';
 
 const array = (elementType, options) => {
     const { typeName, defaultValue = [] } = options ?? {};
@@ -10,15 +10,21 @@ const array = (elementType, options) => {
     const validate = (a) => {
         if (!Arr.isArray(a)) {
             return Result.err([
-                validationErrorMessage(a, 'The value is expected to be an array'),
+                createPrimitiveValidationError({
+                    actualValue: a,
+                    expectedType: 'array',
+                    typeName: typeNameFilled,
+                }),
             ]);
         }
-        for (const [index, el] of a.entries()) {
+        const errors = a.flatMap((el, index) => {
             const res = elementType.validate(el);
-            if (Result.isErr(res)) {
-                const message = validationErrorMessage(el, `The array element is expected to be <${elementType.typeName}>`, (str) => `but the actual value at index ${index} is '${str}'`);
-                return Result.err([message, ...res.value]);
-            }
+            return Result.isErr(res)
+                ? prependIndexToValidationErrors(res.value, index)
+                : [];
+        });
+        if (errors.length > 0) {
+            return Result.err(errors);
         }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
         return Result.ok(a);

package/dist/array/array.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array.mjs","sources":["../../src/array/array.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;MASa,KAAK,GAAG,CACnB,WAAoB,EACpB,OAKC,KACqB;IAGtB,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,EAAE,EAAE,GAAG,OAAO,IAAI,EAAE;IAErD,MAAM,cAAc,GAAW,QAAQ,IAAI,IAAI,WAAW,CAAC,QAAQ,CAAA,GAAA,CAAK;AAExE,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,sBAAsB,CAAC,CAAC,EAAE,sCAAsC,CAAC;AAClE,aAAA,CAAC;QACJ;AAEA,QAAA,KAAK,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE;YACrC,MAAM,GAAG,GAAG,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;AAEpC,YAAA,IAAI,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;gBACrB,MAAM,OAAO,GAAG,sBAAsB,CACpC,EAAE,EACF,CAAA,qCAAA,EAAwC,WAAW,CAAC,QAAQ,CAAA,CAAA,CAAG,EAC/D,CAAC,GAAG,KAAK,CAAA,8BAAA,EAAiC,KAAK,CAAA,KAAA,EAAQ,GAAG,CAAA,CAAA,CAAG,CAC9D;AAED,gBAAA,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC;YAC5C;QACF;;AAGA,QAAA,OAAO,MAAM,CAAC,EAAE,CAAC,CAAM,CAAC;AAC1B,IAAA,CAAC;AAED,IAAA,MAAM,IAAI,GAAoB,CAAC,CAAC,KAC9B,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,YAAY;IAEnE,OAAO;AACL,QAAA,QAAQ,EAAE,cAAc;QACxB,YAAY;QACZ,IAAI;QACJ,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":[null],"names":[],"mappings":";;;;;;MAQa,KAAK,GAAG,CACnB,WAAoB,EACpB,OAKC,KACqB;IAGtB,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,EAAE,EAAE,GAAG,OAAO,IAAI,EAAE;IAErD,MAAM,cAAc,GAAW,QAAQ,IAAI,IAAI,WAAW,CAAC,QAAQ,CAAA,GAAA,CAAK;AAExE,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;AACrB,oBAAA,QAAQ,EAAE,cAAc;iBACzB,CAAC;AACH,aAAA,CAAC;QACJ;QAEA,MAAM,MAAM,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,KAAK,KAAI;YACrC,MAAM,GAAG,GAAG,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;AACpC,YAAA,OAAO,MAAM,CAAC,KAAK,CAAC,GAAG;kBACnB,8BAA8B,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK;kBAC/C,EAAE;AACR,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,CAAM,CAAC;AAC1B,IAAA,CAAC;AAED,IAAA,MAAM,IAAI,GAAoB,CAAC,CAAC,KAC9B,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,YAAY;IAEnE,OAAO;AACL,QAAA,QAAQ,EAAE,cAAc;QACxB,YAAY;QACZ,IAAI;QACJ,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;;;;"}

package/dist/array/non-empty-array.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"non-empty-array.d.mts","sourceRoot":"","sources":["../../src/array/non-empty-array.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AAQxC,eAAO,MAAM,aAAa,GAAI,CAAC,EAC7B,aAAa,IAAI,CAAC,CAAC,CAAC,EACpB,UAAU,QAAQ,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;CACjC,CAAC,KACD,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAsDvB,CAAC"}
+{"version":3,"file":"non-empty-array.d.mts","sourceRoot":"","sources":["../../src/array/non-empty-array.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,CAAC;AASxC,eAAO,MAAM,aAAa,GAAI,CAAC,EAC7B,aAAa,IAAI,CAAC,CAAC,CAAC,EACpB,UAAU,QAAQ,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;CACjC,CAAC,KACD,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CA6DvB,CAAC"}