json-schema-library 10.5.4 → 11.0.1

package/index.ts

@@ -3,16 +3,19 @@ export type { CompileOptions } from "./src/compileSchema";
 export type { Context, SchemaNode, GetNodeOptions, ValidateReturnType } from "./src/SchemaNode";
 export type { DataNode } from "./src/methods/toDataNodes";
 export type { Draft, DraftVersion } from "./src/Draft";
-export type { JsonError, JsonPointer, JsonSchema, OptionalNodeOrError, NodeOrError } from "./src/types";
+export type { JsonError, JsonAnnotation, JsonPointer, JsonSchema, OptionalNodeOrError, NodeOrError } from "./src/types";
 export type {
     Keyword,
+    Maybe,
     ValidationPath,
     JsonSchemaReducerParams,
     JsonSchemaReducer,
     JsonSchemaResolverParams,
     JsonSchemaResolver,
     JsonSchemaValidatorParams,
-    JsonSchemaValidator
+    JsonSchemaValidator,
+    ValidationAnnotation,
+    ValidationReturnType
 } from "./src/Keyword";
 export { default as settings } from "./src/settings";
 
@@ -29,16 +32,17 @@ export { oneOfFuzzyKeyword, oneOfKeyword } from "./src/keywords/oneOf";
 
 // errors
 export { render } from "./src/errors/render";
-export type { ErrorData, ErrorConfig } from "./src/types";
+export type { Annotation, AnnotationData, ErrorConfig } from "./src/types";
 
 // utilities
 export { getTypeOf } from "./src/utils/getTypeOf";
 export { isReduceable } from "./src/SchemaNode";
-export { isJsonError, isSchemaNode } from "./src/types";
+export { isJsonError, isJsonAnnotation, isAnnotation, isSchemaNode } from "./src/types";
 export { extendDraft, addKeywords } from "./src/Draft";
 export { mergeNode } from "./src/mergeNode";
 export { mergeSchema } from "./src/utils/mergeSchema";
 export { getSchemaType } from "./src/utils/getSchemaType";
+export { default as sanitizeErrors } from "./src/utils/sanitizeErrors";
 
 // remotes
 export { remotes } from "./remotes";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-library",
-  "version": "10.5.4",
+  "version": "11.0.1",
   "description": "Customizable and hackable json-validator and json-schema utilities for traversal, data generation and validation",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -67,17 +67,17 @@
     "@eslint/js": "^10.0.1",
     "@types/glob": "^9.0.0",
     "@types/mocha": "^10.0.6",
-    "@types/node": "^25.2.2",
+    "@types/node": "^25.2.3",
     "@types/valid-url": "^1.0.7",
     "eslint": "^9.39.2",
-    "glob": "^13.0.1",
-    "json-schema-test-suite": "https://github.com/json-schema-org/JSON-Schema-Test-Suite#83e866b46c9f9e7082fd51e83a61c5f2145a1ab7",
+    "glob": "^13.0.3",
+    "json-schema-test-suite": "https://github.com/json-schema-org/JSON-Schema-Test-Suite#Test-JSON-Schema-Acceptance-1.029",
     "mocha": "^11.7.5",
     "nyc": "^17.1.0",
     "tsdown": "^0.20.3",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.54.0",
+    "typescript-eslint": "^8.55.0",
     "watch": "^1.0.1"
   },
   "dependencies": {
@@ -99,7 +99,7 @@
     "lodash": ">=4",
     "merge": ">=2",
     "micromatch": ">=4.0.8",
-    "string-width": "^4.2.3"
+    "string-width": ">=4.2.3"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"

package/src/Keyword.ts

@@ -1,4 +1,4 @@
-import type { SchemaNode, JsonError } from "./types";
+import type { SchemaNode, JsonError, JsonAnnotation } from "./types";
 
 export type ValidationPath = {
     pointer: string;
@@ -30,13 +30,18 @@ export interface JsonSchemaResolver {
     (options: JsonSchemaResolverParams): SchemaNode | JsonError | undefined;
 }
 
-export type ValidationResult = JsonError | Promise<JsonError | undefined>;
+// type MaybeAsync<T> = T | Promise<T>;
+// type MaybeArray<T> = T | T[];
+export type Maybe<T> = T | undefined;
+export type ValidationAnnotation = JsonError | JsonAnnotation | Promise<Maybe<ValidationAnnotation>[]>;
+type ValidationResult = Maybe<ValidationAnnotation>;
+export type ValidationReturnType = ValidationResult | ValidationResult[];
 
 export type JsonSchemaValidatorParams = { pointer: string; data: unknown; node: SchemaNode; path: ValidationPath };
 export interface JsonSchemaValidator {
     toJSON?: () => string;
     order?: number;
-    (options: JsonSchemaValidatorParams): undefined | Promise<undefined> | ValidationResult | ValidationResult[];
+    (options: JsonSchemaValidatorParams): ValidationReturnType;
 }
 
 export type Keyword = {

package/src/SchemaNode.ts

@@ -1,7 +1,15 @@
 import { copy } from "fast-copy";
 import sanitizeErrors from "./utils/sanitizeErrors";
 import settings from "./settings";
-import type { JsonSchemaReducer, JsonSchemaResolver, JsonSchemaValidator, Keyword, ValidationPath } from "./Keyword";
+import type {
+    JsonSchemaReducer,
+    JsonSchemaResolver,
+    JsonSchemaValidator,
+    Keyword,
+    Maybe,
+    ValidationAnnotation,
+    ValidationPath
+} from "./Keyword";
 import { createSchema } from "./methods/createSchema";
 import { Draft } from "./Draft";
 import { toSchemaNodes } from "./methods/toSchemaNodes";
@@ -9,10 +17,12 @@ import {
     isJsonError,
     JsonSchema,
     JsonError,
-    ErrorData,
+    AnnotationData,
     DefaultErrors,
     OptionalNodeOrError,
-    NodeOrError
+    NodeOrError,
+    JsonAnnotation,
+    isJsonAnnotation
 } from "./types";
 import { isObject } from "./utils/isObject";
 import { join } from "@sagold/json-pointer";
@@ -180,7 +190,8 @@ export interface SchemaNode extends SchemaNodeMethodsType {
  */
 interface SchemaNodeMethodsType {
     compileSchema(schema: JsonSchema, evaluationPath?: string, schemaLocation?: string, dynamicId?: string): SchemaNode;
-    createError<T extends string = DefaultErrors>(code: T, data: ErrorData, message?: string): JsonError;
+    createError<T extends string = DefaultErrors>(code: T, data: AnnotationData, message?: string): JsonError;
+    createAnnotation<T extends string = DefaultErrors>(code: T, data: AnnotationData, message?: string): JsonAnnotation;
     createSchema(data?: unknown): JsonSchema;
 
     // getNode overloads
@@ -201,7 +212,7 @@ interface SchemaNodeMethodsType {
     getNodeRef($ref: string): SchemaNode | undefined;
     getNodeRoot(): SchemaNode;
     getDraftVersion(): string;
-    getData(data?: unknown, options?: TemplateOptions): unknown;
+    getData(data?: unknown, options?: TemplateOptions): any; // eslint-disable-line @typescript-eslint/no-explicit-any
     reduceNode(
         data: unknown,
         options?: { key?: string | number; pointer?: string; path?: ValidationPath }
@@ -241,10 +252,14 @@ export type ValidateReturnType = {
      * List of validation errors or empty
      */
     errors: JsonError[];
+    /**
+     * List of annotations from validators
+     */
+    annotations: JsonAnnotation[];
     /**
      * List of Promises resolving to `JsonError|undefined` or empty.
      */
-    errorsAsync: Promise<JsonError | undefined>[];
+    errorsAsync: Promise<Maybe<ValidationAnnotation>[]>[];
 };
 
 export function joinDynamicId(a?: string, b?: string) {
@@ -290,7 +305,7 @@ export const SchemaNodeMethods = {
         return node;
     },
 
-    createError<T extends string = DefaultErrors>(code: T, data: ErrorData, message?: string): JsonError {
+    createError<T extends string = DefaultErrors>(code: T, data: AnnotationData, message?: string): JsonError {
         const node = this as SchemaNode;
         let errorMessage = message;
         if (errorMessage === undefined) {
@@ -303,6 +318,23 @@ export const SchemaNodeMethods = {
         return { type: "error", code, message: errorMessage, data };
     },
 
+    createAnnotation<T extends string = DefaultErrors>(
+        code: T,
+        data: AnnotationData,
+        message?: string
+    ): JsonAnnotation {
+        const node = this as SchemaNode;
+        let annotationMessage = message;
+        if (annotationMessage === undefined) {
+            const error = node.schema?.errorMessages?.[code] ?? node.context.errors[code];
+            if (typeof error === "function") {
+                return error(data);
+            }
+            annotationMessage = render(error ?? name, data);
+        }
+        return { type: "annotation", code, message: annotationMessage, data };
+    },
+
     createSchema,
 
     getChildSelection(property: string | number): JsonError | SchemaNode[] {
@@ -412,20 +444,24 @@ export const SchemaNodeMethods = {
         const node = this as SchemaNode;
         const errors = validateNode(node, data, pointer, path) ?? [];
         const syncErrors: JsonError[] = [];
+        const annotations: JsonAnnotation[] = [];
         const flatErrorList = sanitizeErrors(Array.isArray(errors) ? errors : [errors]).filter(isJsonError);
 
-        const errorsAsync: Promise<JsonError | undefined>[] = [];
+        const errorsAsync: Promise<Maybe<ValidationAnnotation>[]>[] = [];
         sanitizeErrors(Array.isArray(errors) ? errors : [errors]).forEach((error) => {
             if (isJsonError(error)) {
                 syncErrors.push(error);
             } else if (error instanceof Promise) {
-                errorsAsync.push(error);
+                errorsAsync.push(error.then(sanitizeErrors));
+            } else if (isJsonAnnotation(error)) {
+                annotations.push(error);
             }
         });
 
         const result: ValidateReturnType = {
             valid: flatErrorList.length === 0,
             errors: syncErrors,
+            annotations,
             errorsAsync
         };
 
@@ -478,7 +514,7 @@ export const SchemaNodeMethods = {
      * @returns a list of all sub-schema as SchemaNode
      */
     toSchemaNodes() {
-        return toSchemaNodes(this as SchemaNode);
+        return toSchemaNodes(this);
     },
 
     /**

package/src/compileSchema.validate.test.ts

@@ -1,11 +1,12 @@
 import { compileSchema } from "./compileSchema";
 import { strict as assert } from "assert";
-import { Draft, JsonError, SchemaNode } from "./types";
+import { Draft, isJsonError, SchemaNode } from "./types";
 import { draft2020 } from "./draft2020";
+import sanitizeErrors from "./utils/sanitizeErrors";
 
-describe("compileSchema.validate", () => {
+describe("compileSchema : validate", () => {
+    // note: boolean schema is already thoroughly tested by spec
     describe("boolean schema", () => {
-        // note: all this is tested in spec already
         it("should fail if root schema is false", () => {
             // @ts-expect-error boolean typ unsupported
             const { errors } = compileSchema(false).validate("anything");
@@ -995,73 +996,107 @@ describe("compileSchema.validate - errorsAsync", () => {
                     ...draft2020.keywords,
                     {
                         id: "async",
-                        keyword: "async-error",
+                        keyword: "asyncError",
                         addValidate: (node) => node.schema.asyncError != null,
-                        validate: async ({ node }): Promise<JsonError> => {
+                        validate: async ({ node }) => {
                             if (node.schema.asyncError === false) {
-                                return undefined;
+                                return [undefined];
                             }
-                            return node.createError("type-error", {
-                                schema: {},
-                                pointer: "",
-                                value: ""
-                            });
+                            return [
+                                node.createError("type-error", {
+                                    schema: {},
+                                    pointer: "",
+                                    value: ""
+                                })
+                            ];
                         }
                     }
                 ]
             };
+        });
 
-            it("should resolve async validation returning no error", async () => {
-                const { errors, errorsAsync } = compileSchema(
-                    { type: "number", asyncError: false },
-                    { drafts: [draft] }
-                ).validate(4);
-                const asyncErrors = await Promise.all(errorsAsync);
-                assert.deepEqual(errors.length, 0);
-                assert.deepEqual(asyncErrors.length, 0);
-            });
+        it("should resolve async validation returning no error", async () => {
+            const { errors, errorsAsync } = compileSchema(
+                { type: "number", asyncError: false },
+                { drafts: [draft] }
+            ).validate(4);
 
-            it("should resolve async validation errors", async () => {
-                const { errorsAsync } = compileSchema(
-                    { type: "number", asyncError: true },
-                    { drafts: [draft] }
-                ).validate(4);
-                const asyncErrors = await Promise.all(errorsAsync);
-                assert.deepEqual(asyncErrors.length, 1);
-                assert.deepEqual(asyncErrors[0].code, "type-error");
-            });
+            const asyncErrors = sanitizeErrors(await Promise.all(errorsAsync));
+            assert.deepEqual(errors.length, 0);
+            assert.deepEqual(asyncErrors.length, 0);
+        });
+
+        it("should resolve async validation errors", async () => {
+            const { errorsAsync } = compileSchema({ type: "number", asyncError: true }, { drafts: [draft] }).validate(
+                4
+            );
+
+            const asyncErrors = sanitizeErrors(await Promise.all(errorsAsync));
+            assert.deepEqual(asyncErrors.length, 1, "should have resolved promise to return error");
+            assert(isJsonError(asyncErrors[0]));
+            assert.deepEqual(asyncErrors[0].code, "type-error");
         });
     });
 });
 
-describe("compileSchema.validate - custom errors", () => {
-    it("should return custom error message for minItems", () => {
-        const { errors } = compileSchema({
-            type: "array",
-            minItems: 2,
-            errorMessages: {
-                "min-items-error": "Custom error {{minItems}}"
+describe("annotation", () => {
+    let draft: Draft;
+    beforeEach(() => {
+        draft = {
+            ...draft2020,
+            keywords: [
+                ...draft2020.keywords,
+                {
+                    id: "annotation",
+                    keyword: "annotation",
+                    addValidate: (node) => node.schema.annotation === true,
+                    validate: ({ node }) =>
+                        node.createAnnotation("deprecated-warning", {
+                            schema: {},
+                            pointer: "",
+                            value: ""
+                        })
+                }
+            ]
+        };
+    });
+
+    it("should return annotations-property from validate", async () => {
+        const { annotations } = compileSchema(
+            {
+                type: "number",
+                annotation: true
+            },
+            {
+                drafts: [draft]
             }
-        }).validate([1]);
-        assert.deepEqual(errors.length, 1);
-        assert.deepEqual(errors[0].message, "Custom error 2");
+        ).validate(4);
+
+        assert(Array.isArray(annotations));
     });
 
-    it("should return custom error for oneOf-error", () => {
-        const { errors } = compileSchema({
-            type: "array",
-            items: {
-                errorMessages: {
-                    "one-of-error": "{{value}} does not match any of the options"
-                },
-                oneOf: [
-                    { type: "number" },
-                    { type: "object", properties: { a: { type: "string" } }, additionalProperties: false }
-                ]
+    it("should add annotations to annotations-property", async () => {
+        const { annotations } = compileSchema(
+            {
+                type: "number",
+                annotation: true
             },
-            additionalItems: false
-        }).validate([100, { a: "correct", b: "not correct" }]);
-        assert.deepEqual(errors.length, 1);
-        assert.deepEqual(errors[0].message, '{"a":"correct","b":"not correct"} does not match any of the options');
+            {
+                drafts: [draft]
+            }
+        ).validate(4);
+
+        assert.equal(annotations.length, 1);
+        assert.equal(annotations[0].code, "deprecated-warning");
+    });
+
+    it("should return deprecated-warning annotation per default", async () => {
+        const { annotations } = compileSchema({
+            type: "number",
+            deprecated: true
+        }).validate(4);
+
+        assert.equal(annotations.length, 1);
+        assert.equal(annotations[0].code, "deprecated-warning");
     });
 });

package/src/draft04.ts

@@ -1,14 +1,21 @@
+import { $defsKeyword } from "./keywords/$defs";
+import { $refKeyword } from "./draft04/keywords/$ref";
 import { additionalItemsKeyword } from "./draft2019-09/keywords/additionalItems";
 import { additionalPropertiesKeyword } from "./keywords/additionalProperties";
 import { allOfKeyword } from "./keywords/allOf";
 import { anyOfKeyword } from "./keywords/anyOf";
 import { containsKeyword } from "./keywords/contains";
-import { $defsKeyword } from "./keywords/$defs";
+import { createSchema } from "./methods/createSchema";
 import { dependenciesKeyword } from "./keywords/dependencies";
+import { deprecatedKeyword } from "./keywords/deprecated";
 import { enumKeyword } from "./keywords/enum";
+import { errors } from "./errors/errors";
 import { exclusiveMaximumKeyword } from "./draft04/keywords/exclusiveMaximum";
 import { exclusiveMinimumKeyword } from "./draft04/keywords/exclusiveMinimum";
 import { formatKeyword } from "./keywords/format";
+import { formats } from "./formats/formats";
+import { getChildSelection } from "./draft2019-09/methods/getChildSelection";
+import { getData } from "./draft2019-09/methods/getData";
 import { itemsKeyword } from "./draft2019-09/keywords/items";
 import { maximumKeyword } from "./keywords/maximum";
 import { maxItemsKeyword } from "./keywords/maxItems";
@@ -25,17 +32,11 @@ import { patternKeyword } from "./keywords/pattern";
 import { patternPropertiesKeyword } from "./keywords/patternProperties";
 import { propertiesKeyword } from "./keywords/properties";
 import { propertyNamesKeyword } from "./keywords/propertyNames";
-import { $refKeyword } from "./draft04/keywords/$ref";
 import { requiredKeyword } from "./keywords/required";
 import { sanitizeKeywords } from "./Draft";
+import { toDataNodes } from "./methods/toDataNodes";
 import { typeKeyword } from "./keywords/type";
 import { uniqueItemsKeyword } from "./keywords/uniqueItems";
-import { getChildSelection } from "./draft2019-09/methods/getChildSelection";
-import { getData } from "./draft2019-09/methods/getData";
-import { toDataNodes } from "./methods/toDataNodes";
-import { createSchema } from "./methods/createSchema";
-import { errors } from "./errors/errors";
-import { formats } from "./formats/formats";
 
 /**
  * @draft-04
@@ -77,6 +78,7 @@ export const draft04 = sanitizeKeywords({
         containsKeyword,
         $defsKeyword,
         dependenciesKeyword, // optional support for old draft-version
+        deprecatedKeyword,
         enumKeyword,
         exclusiveMaximumKeyword,
         exclusiveMinimumKeyword,

package/src/draft06.ts

@@ -1,15 +1,22 @@
+import { $defsKeyword } from "./keywords/$defs";
+import { $refKeyword } from "./draft06/keywords/$ref";
 import { additionalItemsKeyword } from "./draft2019-09/keywords/additionalItems";
 import { additionalPropertiesKeyword } from "./keywords/additionalProperties";
 import { allOfKeyword } from "./keywords/allOf";
 import { anyOfKeyword } from "./keywords/anyOf";
 import { constKeyword } from "./keywords/const";
 import { containsKeyword } from "./keywords/contains";
-import { $defsKeyword } from "./keywords/$defs";
+import { createSchema } from "./methods/createSchema";
 import { dependenciesKeyword } from "./keywords/dependencies";
+import { deprecatedKeyword } from "./keywords/deprecated";
 import { enumKeyword } from "./keywords/enum";
+import { errors } from "./errors/errors";
 import { exclusiveMaximumKeyword } from "./keywords/exclusiveMaximum";
 import { exclusiveMinimumKeyword } from "./keywords/exclusiveMinimum";
 import { formatKeyword } from "./keywords/format";
+import { formats } from "./formats/formats";
+import { getChildSelection } from "./draft2019-09/methods/getChildSelection";
+import { getData } from "./draft2019-09/methods/getData";
 import { itemsKeyword } from "./draft2019-09/keywords/items";
 import { maximumKeyword } from "./keywords/maximum";
 import { maxItemsKeyword } from "./keywords/maxItems";
@@ -26,17 +33,11 @@ import { patternKeyword } from "./keywords/pattern";
 import { patternPropertiesKeyword } from "./keywords/patternProperties";
 import { propertiesKeyword } from "./keywords/properties";
 import { propertyNamesKeyword } from "./keywords/propertyNames";
-import { $refKeyword } from "./draft06/keywords/$ref";
 import { requiredKeyword } from "./keywords/required";
 import { sanitizeKeywords } from "./Draft";
+import { toDataNodes } from "./methods/toDataNodes";
 import { typeKeyword } from "./keywords/type";
 import { uniqueItemsKeyword } from "./keywords/uniqueItems";
-import { getChildSelection } from "./draft2019-09/methods/getChildSelection";
-import { getData } from "./draft2019-09/methods/getData";
-import { toDataNodes } from "./methods/toDataNodes";
-import { createSchema } from "./methods/createSchema";
-import { errors } from "./errors/errors";
-import { formats } from "./formats/formats";
 
 /**
  * @draft-06 https://json-schema.org/draft-06/json-schema-release-notes
@@ -79,6 +80,7 @@ export const draft06 = sanitizeKeywords({
         containsKeyword,
         $defsKeyword,
         dependenciesKeyword, // optional support for old draft-version
+        deprecatedKeyword,
         enumKeyword,
         exclusiveMaximumKeyword,
         exclusiveMinimumKeyword,

package/src/draft07.ts

@@ -1,15 +1,22 @@
+import { $defsKeyword } from "./keywords/$defs";
+import { $refKeyword } from "./draft06/keywords/$ref";
 import { additionalItemsKeyword } from "./draft2019-09/keywords/additionalItems";
 import { additionalPropertiesKeyword } from "./keywords/additionalProperties";
 import { allOfKeyword } from "./keywords/allOf";
 import { anyOfKeyword } from "./keywords/anyOf";
 import { constKeyword } from "./keywords/const";
 import { containsKeyword } from "./keywords/contains";
-import { $defsKeyword } from "./keywords/$defs";
+import { createSchema } from "./methods/createSchema";
 import { dependenciesKeyword } from "./keywords/dependencies";
+import { deprecatedKeyword } from "./keywords/deprecated";
 import { enumKeyword } from "./keywords/enum";
+import { errors } from "./errors/errors";
 import { exclusiveMaximumKeyword } from "./keywords/exclusiveMaximum";
 import { exclusiveMinimumKeyword } from "./keywords/exclusiveMinimum";
 import { formatKeyword } from "./keywords/format";
+import { formats } from "./formats/formats";
+import { getChildSelection } from "./draft2019-09/methods/getChildSelection";
+import { getData } from "./draft2019-09/methods/getData";
 import { ifKeyword } from "./keywords/ifthenelse";
 import { itemsKeyword } from "./draft2019-09/keywords/items";
 import { maximumKeyword } from "./keywords/maximum";
@@ -27,17 +34,11 @@ import { patternKeyword } from "./keywords/pattern";
 import { patternPropertiesKeyword } from "./keywords/patternProperties";
 import { propertiesKeyword } from "./keywords/properties";
 import { propertyNamesKeyword } from "./keywords/propertyNames";
-import { $refKeyword } from "./draft06/keywords/$ref";
 import { requiredKeyword } from "./keywords/required";
 import { sanitizeKeywords } from "./Draft";
+import { toDataNodes } from "./methods/toDataNodes";
 import { typeKeyword } from "./keywords/type";
 import { uniqueItemsKeyword } from "./keywords/uniqueItems";
-import { getChildSelection } from "./draft2019-09/methods/getChildSelection";
-import { getData } from "./draft2019-09/methods/getData";
-import { toDataNodes } from "./methods/toDataNodes";
-import { createSchema } from "./methods/createSchema";
-import { errors } from "./errors/errors";
-import { formats } from "./formats/formats";
 
 /**
  * @draft-07 https://json-schema.org/draft-07/json-schema-release-notes
@@ -70,6 +71,7 @@ export const draft07 = sanitizeKeywords({
         containsKeyword,
         $defsKeyword,
         dependenciesKeyword, // optional support for old draft-version
+        deprecatedKeyword,
         enumKeyword,
         exclusiveMaximumKeyword,
         exclusiveMinimumKeyword,

package/src/draft2019-09/keywords/additionalItems.ts

@@ -1,5 +1,5 @@
 import { isObject } from "../../utils/isObject";
-import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationResult } from "../../Keyword";
+import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationReturnType } from "../../Keyword";
 import { SchemaNode } from "../../types";
 import { getValue } from "../../utils/getValue";
 import { validateNode } from "../../validateNode";
@@ -49,7 +49,7 @@ function validateAdditionalItems({ node, data, pointer, path }: JsonSchemaValida
         return;
     }
     const startIndex = Array.isArray(schema.items) ? schema.items.length : 0;
-    const errors: ValidationResult[] = [];
+    const errors: ValidationReturnType = [];
     for (let i = startIndex; i < data.length; i += 1) {
         const item = data[i];
         if (node.items) {

package/src/draft2019-09/keywords/items.ts

@@ -1,4 +1,4 @@
-import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationResult } from "../../Keyword";
+import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationReturnType } from "../../Keyword";
 import { SchemaNode } from "../../types";
 import { isObject } from "../../utils/isObject";
 import { validateNode } from "../../validateNode";
@@ -52,7 +52,7 @@ function validateItems({ node, data, pointer = "#", path }: JsonSchemaValidatorP
         return node.createError("invalid-data-error", { pointer, value: data, schema });
     }
 
-    const errors: ValidationResult[] = [];
+    const errors: ValidationReturnType = [];
     if (node.prefixItems) {
         // note: schema is valid when data does not have enough elements as defined by array-list
         for (let i = 0; i < Math.min(node.prefixItems.length, data.length); i += 1) {

package/src/draft2019-09/keywords/unevaluatedItems.ts

@@ -1,7 +1,6 @@
 import { isObject } from "../../utils/isObject";
 import { SchemaNode } from "../../types";
-import { Keyword, JsonSchemaValidatorParams, ValidationResult } from "../../Keyword";
-import sanitizeErrors from "../../utils/sanitizeErrors";
+import { Keyword, JsonSchemaValidatorParams, ValidationReturnType } from "../../Keyword";
 import { validateNode } from "../../validateNode";
 
 /**
@@ -50,7 +49,7 @@ function validateUnevaluatedItems({ node, data, pointer, path }: JsonSchemaValid
     // console.log("EVAL", reducedNode.schema);
 
     const validIf = node.if != null && validateNode(node.if, data, pointer, path).length === 0;
-    const errors: ValidationResult[] = [];
+    const errors: ValidationReturnType = [];
     // "unevaluatedItems with nested items"
     for (let i = 0; i < data.length; i += 1) {
         const value = data[i];
@@ -63,9 +62,16 @@ function validateUnevaluatedItems({ node, data, pointer, path }: JsonSchemaValid
                 // nothing should validate, so we validate unevaluated items only
                 const unevaluatedItems = node.unevaluatedItems;
                 if (unevaluatedItems) {
-                    return sanitizeErrors(
-                        data.map((value) => validateNode(unevaluatedItems, value, `${pointer}/${i}`, path))
-                    );
+                    data.forEach((value) => {
+                        const result = validateNode(unevaluatedItems, value, `${pointer}/${i}`, path);
+                        if (result == null) {
+                            return;
+                        }
+                        if (Array.isArray(result)) {
+                            return errors.push(...result);
+                        }
+                        errors.push(result);
+                    });
                 }
                 if (node.schema.unevaluatedItems === false) {
                     return node.createError("unevaluated-items-error", {