json-schema-library 11.3.1 → 11.4.0

package/src/keywords/allOf.ts

@@ -8,6 +8,7 @@ import {
 } from "../Keyword";
 import { SchemaNode } from "../types";
 import { validateNode } from "../validateNode";
+import { collectValidationErrors } from "src/utils/collectValidationErrors";
 
 const KEYWORD = "allOf";
 
@@ -41,11 +42,7 @@ export function parseAllOf(node: SchemaNode) {
     node[KEYWORD] = schema[KEYWORD].map((s, index) =>
         node.compileSchema(s, `${evaluationPath}/${KEYWORD}/${index}`, `${schemaLocation}/${KEYWORD}/${index}`)
     );
-
-    return node[KEYWORD].reduce((errors, node) => {
-        if (node.schemaValidation) errors.push(...node.schemaValidation);
-        return errors;
-    }, [] as ValidationAnnotation[]);
+    return collectValidationErrors([], ...node[KEYWORD]);
 }
 
 function reduceAllOf({ node, data, key, pointer, path }: JsonSchemaReducerParams) {

package/src/keywords/anyOf.ts

@@ -2,6 +2,7 @@ import { mergeSchema } from "../utils/mergeSchema";
 import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationAnnotation } from "../Keyword";
 import { SchemaNode } from "../types";
 import { validateNode } from "../validateNode";
+import { collectValidationErrors } from "src/utils/collectValidationErrors";
 
 const KEYWORD = "anyOf";
 
@@ -35,10 +36,7 @@ export function parseAnyOf(node: SchemaNode) {
         node.compileSchema(s, `${evaluationPath}/${KEYWORD}/${index}`, `${schemaLocation}/${KEYWORD}/${index}`)
     );
 
-    return node[KEYWORD].reduce((errors, node) => {
-        if (node.schemaValidation) errors.push(...node.schemaValidation);
-        return errors;
-    }, [] as ValidationAnnotation[]);
+    return collectValidationErrors([], ...node[KEYWORD]);
 }
 
 function reduceAnyOf({ node, data, pointer, path }: JsonSchemaReducerParams) {

package/src/keywords/dependencies.ts

@@ -7,6 +7,7 @@ import { validateDependentRequired } from "./dependentRequired";
 import { validateDependentSchemas } from "./dependentSchemas";
 import sanitizeErrors from "../utils/sanitizeErrors";
 import { isListOfStrings } from "../utils/isListOfStrings";
+import { collectValidationErrors } from "src/utils/collectValidationErrors";
 
 const KEYWORD = "dependencies";
 
@@ -42,6 +43,7 @@ export function parseDependencies(node: SchemaNode) {
                 `${node.evaluationPath}/${KEYWORD}/${property}`,
                 `${node.schemaLocation}/${KEYWORD}/${property}`
             );
+            collectValidationErrors(errors, node.dependentSchemas[property]);
         } else if (isListOfStrings(schema)) {
             node.dependentRequired = node.dependentRequired ?? {};
             node.dependentRequired[property] = schema;

package/src/keywords/dependentSchemas.ts

@@ -4,6 +4,7 @@ import { isSchemaNode, SchemaNode, JsonSchema, isBooleanSchema } from "../types"
 import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationAnnotation } from "../Keyword";
 import { validateNode } from "../validateNode";
 import sanitizeErrors from "../utils/sanitizeErrors";
+import { collectValidationErrors } from "src/utils/collectValidationErrors";
 
 const KEYWORD = "dependentSchemas";
 
@@ -46,9 +47,7 @@ export function parseDependentSchemas(node: SchemaNode) {
                 `${node.evaluationPath}/${KEYWORD}/${property}`,
                 `${node.schemaLocation}/${KEYWORD}/${property}`
             );
-            if (parsedSchemas[property].schemaValidation) {
-                errors.push(...parsedSchemas[property].schemaValidation);
-            }
+            collectValidationErrors(errors, parsedSchemas[property]);
         } else if (isBooleanSchema(schema)) {
             parsedSchemas[property] = schema;
         } else {

package/src/keywords/format.ts

@@ -24,6 +24,14 @@ function parseFormat(node: SchemaNode) {
             message: `Keyword '${KEYWORD}' must be a string - received '${typeof format}'`
         });
     }
+    if (node.context.formats[format] == null) {
+        return node.createAnnotation("unknown-format-warning", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: format,
+            message: `Keyword '${KEYWORD}' must be a string - received '${typeof format}'`
+        });
+    }
 }
 
 function validateFormat(options: JsonSchemaValidatorParams) {

package/src/keywords/ifthenelse.ts

@@ -2,6 +2,7 @@ import { mergeSchema } from "../utils/mergeSchema";
 import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams, ValidationAnnotation } from "../Keyword";
 import { isBooleanSchema, isJsonSchema, SchemaNode } from "../types";
 import { validateNode } from "../validateNode";
+import { collectValidationErrors } from "src/utils/collectValidationErrors";
 
 export const ifKeyword: Keyword = {
     id: "if-then-else",
@@ -19,9 +20,7 @@ export function parseIfThenElse(node: SchemaNode) {
     if (schema.if != null) {
         if (isJsonSchema(schema.if) || isBooleanSchema(schema.if)) {
             node.if = node.compileSchema(schema.if, `${evaluationPath}/if`);
-            if (node.if.schemaValidation) {
-                errors.push(...node.if.schemaValidation);
-            }
+            collectValidationErrors(errors, node.if);
         } else {
             errors.push(
                 node.createError("schema-error", {
@@ -36,9 +35,7 @@ export function parseIfThenElse(node: SchemaNode) {
     if (schema.then != null) {
         if (isJsonSchema(schema.then) || isBooleanSchema(schema.then)) {
             node.then = node.compileSchema(schema.then, `${evaluationPath}/then`);
-            if (node.then.schemaValidation) {
-                errors.push(...node.then.schemaValidation);
-            }
+            collectValidationErrors(errors, node.then);
         } else {
             errors.push(
                 node.createError("schema-error", {
@@ -53,9 +50,7 @@ export function parseIfThenElse(node: SchemaNode) {
     if (schema.else != null) {
         if (isJsonSchema(schema.else) || isBooleanSchema(schema.else)) {
             node.else = node.compileSchema(schema.else, `${evaluationPath}/else`);
-            if (node.else.schemaValidation) {
-                errors.push(...node.else.schemaValidation);
-            }
+            collectValidationErrors(errors, node.else);
         } else {
             errors.push(
                 node.createError("schema-error", {

package/src/keywords/oneOf.ts

@@ -13,6 +13,7 @@ import sanitizeErrors from "../utils/sanitizeErrors";
 import { isObject } from "../utils/isObject";
 import { validateNode } from "../validateNode";
 import { joinDynamicId } from "../SchemaNode";
+import { collectValidationErrors } from "src/utils/collectValidationErrors";
 
 const KEYWORD = "oneOf";
 const { DECLARATOR_ONEOF } = settings;
@@ -57,11 +58,7 @@ export function parseOneOf(node: SchemaNode) {
     node[KEYWORD] = schema[KEYWORD].map((s, index) =>
         node.compileSchema(s, `${evaluationPath}/${KEYWORD}/${index}`, `${schemaLocation}/${KEYWORD}/${index}`)
     );
-
-    return node[KEYWORD].reduce((errors, node) => {
-        if (node.schemaValidation) errors.push(...node.schemaValidation);
-        return errors;
-    }, [] as ValidationAnnotation[]);
+    return collectValidationErrors([], ...node[KEYWORD]);
 }
 
 function reduceOneOf({ node, data, pointer, path }: Omit<JsonSchemaReducerParams, "key">) {

package/src/keywords/patternProperties.ts

@@ -6,11 +6,13 @@ import {
     JsonSchemaReducerParams,
     JsonSchemaResolverParams,
     JsonSchemaValidatorParams,
-    ValidationReturnType
+    ValidationReturnType,
+    ValidationAnnotation
 } from "../Keyword";
 import { getValue } from "../utils/getValue";
 import { validateNode } from "../validateNode";
 import settings from "../settings";
+import { collectValidationErrors } from "src/utils/collectValidationErrors";
 
 const { REGEX_FLAGS } = settings;
 
@@ -45,6 +47,8 @@ export function parsePatternProperties(node: SchemaNode) {
             `${node.schemaLocation}/patternProperties/${pattern}`
         )
     }));
+
+    return collectValidationErrors([], ...node.patternProperties.map(({ node }) => node));
 }
 
 function patternPropertyResolver({ node, key }: JsonSchemaResolverParams) {

package/src/keywords/prefixItems.ts

@@ -1,14 +1,17 @@
 import { SchemaNode } from "../types";
 import { Keyword, JsonSchemaResolverParams, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
 import { validateNode } from "../validateNode";
+import { collectValidationErrors } from "src/utils/collectValidationErrors";
+
+const KEYWORD = "prefixItems";
 
 export const prefixItemsKeyword: Keyword = {
-    id: "prefixItems",
-    keyword: "prefixItems",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseItems,
-    addResolve: (node) => node.prefixItems != null,
+    addResolve: (node) => node[KEYWORD] != null,
     resolve: prefixItemsResolver,
-    addValidate: ({ schema }) => schema.prefixItems != null,
+    addValidate: (node) => node[KEYWORD] != null,
     validate: validatePrefixItems
 };
 
@@ -24,10 +27,11 @@ export function parseItems(node: SchemaNode) {
         node.prefixItems = schema.prefixItems.map((itemSchema, index) =>
             node.compileSchema(
                 itemSchema,
-                `${evaluationPath}/prefixItems/${index}`,
-                `${node.schemaLocation}/prefixItems/${index}`
+                `${evaluationPath}/${KEYWORD}/${index}`,
+                `${node.schemaLocation}/${KEYWORD}/${index}`
             )
         );
+        return collectValidationErrors([], ...node.prefixItems);
     }
 }
 
@@ -37,12 +41,13 @@ function validatePrefixItems({ node, data, pointer = "#", path }: JsonSchemaVali
     }
 
     const errors: ValidationReturnType = [];
-    if (node.prefixItems) {
+    const prefixItems = node[KEYWORD];
+    if (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) {
+        for (let i = 0; i < Math.min(prefixItems.length, data.length); i += 1) {
             const itemData = data[i];
             // @todo v1 reevaluate: incomplete schema is created here?
-            const itemNode = node.prefixItems[i];
+            const itemNode = prefixItems[i];
             const result = validateNode(itemNode, itemData, `${pointer}/${i}`, path);
             errors.push(...result);
         }

package/src/keywords/properties.ts

@@ -9,6 +9,7 @@ import {
 } from "../Keyword";
 import { isObject } from "../utils/isObject";
 import { validateNode } from "../validateNode";
+import { collectValidationErrors } from "src/utils/collectValidationErrors";
 
 export const propertiesKeyword: Keyword = {
     id: "property",
@@ -48,9 +49,7 @@ export function parseProperties(node: SchemaNode) {
             `${schemaLocation}/properties/${propertyName}`
         );
         parsedProperties[propertyName] = propertyNode;
-        if (parsedProperties[propertyName].schemaValidation) {
-            errors.push(...parsedProperties[propertyName].schemaValidation);
-        }
+        collectValidationErrors(errors, parsedProperties[propertyName]);
     });
     node.properties = parsedProperties;
 

package/src/keywords/propertyDependencies.ts

@@ -1,3 +1,4 @@
+import { collectValidationErrors } from "src/utils/collectValidationErrors";
 import {
     Keyword,
     JsonSchemaValidatorParams,
@@ -115,9 +116,7 @@ function parsePropertyDependencies(node: SchemaNode) {
                 `${node.evaluationPath}/${KEYWORD}/${propertyName}/${value}`,
                 `${node.schemaLocation}/${KEYWORD}/${propertyName}/${value}`
             );
-            if (parsed[propertyName][value].schemaValidation) {
-                errors.push(...parsed[propertyName][value].schemaValidation);
-            }
+            collectValidationErrors(errors, parsed[propertyName][value]);
         });
     });
     node[KEYWORD] = parsed;

package/src/keywords/propertyNames.ts

@@ -35,7 +35,7 @@ export function parsePropertyNames(node: SchemaNode) {
         `${node.evaluationPath}/propertyNames`,
         `${node.schemaLocation}/propertyNames`
     );
-    return node.schemaValidation;
+    return node.propertyNames.schemaValidation;
 }
 
 function validatePropertyNames({ node, data, pointer, path }: JsonSchemaValidatorParams) {

package/src/utils/collectValidationErrors.ts

@@ -0,0 +1,9 @@
+import { ValidationAnnotation } from "src/Keyword";
+import { SchemaNode } from "src/SchemaNode";
+
+export function collectValidationErrors(errors: ValidationAnnotation[], ...compiled: SchemaNode[]) {
+    return compiled.reduce((errors, node) => {
+        if (node.schemaValidation) errors.push(...node.schemaValidation);
+        return errors;
+    }, errors);
+}

package/src/validateSchema.test.ts

@@ -252,45 +252,36 @@ describe("validateSchema", () => {
 
     describe("annotations", () => {
         it("should return unknown keywords as annotation", () => {
-            const { schemaAnnotations } = compileSchema(
-                {
-                    properties: {
-                        headline: {
-                            options: {},
-                            type: "string"
-                        }
+            const { schemaAnnotations } = compileSchema({
+                properties: {
+                    headline: {
+                        options: {},
+                        type: "string"
                     }
-                },
-                { withSchemaAnnotations: true }
-            );
+                }
+            });
             assert.equal(schemaAnnotations.length, 1);
             assert.equal(schemaAnnotations[0].data.pointer, "#/properties/headline/options");
         });
         it("should return not unknown keywords starting with 'x-'", () => {
-            const { schemaAnnotations } = compileSchema(
-                {
-                    properties: {
-                        headline: {
-                            "x-options": {},
-                            type: "string"
-                        }
+            const { schemaAnnotations } = compileSchema({
+                properties: {
+                    headline: {
+                        "x-options": {},
+                        type: "string"
                     }
-                },
-                { withSchemaAnnotations: true }
-            );
+                }
+            });
             assert.equal(schemaAnnotations.length, 0);
         });
         it("should return removed keywords from old drafts as annotation", () => {
-            const { schemaAnnotations } = compileSchema(
-                {
-                    properties: {
-                        headline: {
-                            additionalItems: true
-                        }
+            const { schemaAnnotations } = compileSchema({
+                properties: {
+                    headline: {
+                        additionalItems: true
                     }
-                },
-                { withSchemaAnnotations: true }
-            );
+                }
+            });
             assert.equal(schemaAnnotations.length, 1);
             assert.equal(schemaAnnotations[0].data.pointer, "#/properties/headline/additionalItems");
         });
@@ -303,10 +294,18 @@ describe("validateSchema", () => {
                         }
                     }
                 },
-                { drafts: [draft07], withSchemaAnnotations: true }
+                { drafts: [draft07] }
             );
             assert.equal(schemaAnnotations.length, 1);
             assert.equal(schemaAnnotations[0].data.pointer, "#/properties/headline/prefixItems");
         });
+        it("should return unsupported formats as annotation", () => {
+            const { schemaAnnotations } = compileSchema({
+                type: "array",
+                prefixItems: [{ format: "email" }, { format: "textarea" }]
+            });
+            assert.equal(schemaAnnotations.length, 1);
+            assert.equal(schemaAnnotations[0].data.pointer, "#/prefixItems/1/format");
+        });
     });
 });

package/tsconfig.json

@@ -13,6 +13,7 @@
         "baseUrl": ".",
         "paths": {
             "json-schema-library": ["./index.ts"],
+            "json-schema-library/formats": ["./src/formats/additionalFormats.ts"],
             "json-schema-library/remotes": ["./remotes/index.ts"],
             "json-schema-library/package.json": ["./package.json"]
         },

package/tsconfig.test.json

@@ -13,6 +13,7 @@
         "baseUrl": ".",
         "paths": {
             "json-schema-library": ["./index.ts"],
+            "json-schema-library/formats": ["./src/formats/additionalformats.ts"],
             "json-schema-library/remotes": ["./remotes/index.ts"],
             "json-schema-library/package.json": ["./package.json"]
         }

package/tsdown.config.ts

@@ -2,7 +2,10 @@ import { defineConfig } from "tsdown";
 
 export default defineConfig({
     dts: true,
-    entry: ["./index.ts", "./remotes/index.ts"],
+    entry: { index: "./index.ts", remotes: "./remotes/index.ts", formats: "./src/formats/additionalFormats.ts" },
     exports: true,
-    globalName: "jlib"
+    globalName: "jlib",
+    sourcemap: true,
+    // Only bundle @hyperjump/json-schema-formats (used only in formats entry)
+    noExternal: ["@hyperjump/json-schema-formats"]
 });

package/tsdown.iife.config.ts

@@ -1,10 +1,31 @@
 import { defineConfig } from "tsdown";
 
-export default defineConfig({
-    entry: ["./index.ts"],
-    format: "iife",
-    globalName: "jlib",
-    platform: "browser",
-    // Bundle anything that's not a relative/absolute path (=> node_modules)
-    noExternal: (id) => !id.startsWith(".") && !id.startsWith("/")
-});
+export default defineConfig([
+    {
+        entry: { jlib: "./index.ts" },
+        format: "iife",
+        globalName: "jlib",
+        platform: "browser",
+        sourcemap: false,
+        // Bundle anything that's not a relative/absolute path (=> node_modules)
+        noExternal: (id) => !id.startsWith(".") && !id.startsWith("/")
+    },
+    {
+        entry: { jlibRemote: "./remotes/index.ts" },
+        format: "iife",
+        globalName: "jlibRemotes",
+        platform: "browser",
+        sourcemap: false,
+        // Bundle anything that's not a relative/absolute path (=> node_modules)
+        noExternal: (id) => !id.startsWith(".") && !id.startsWith("/")
+    },
+    {
+        entry: { jlibFormats: "./src/formats/additionalFormats.ts" },
+        format: "iife",
+        globalName: "jlibFormats",
+        platform: "browser",
+        sourcemap: false,
+        // Bundle anything that's not a relative/absolute path (=> node_modules)
+        noExternal: (id) => !id.startsWith(".") && !id.startsWith("/")
+    }
+]);

package/dist/remotes/index.d.cts

@@ -1,7 +0,0 @@
-import { c as JsonSchema } from "../types-ZgoQMSny.cjs";
-
-//#region remotes/index.d.ts
-/** JSON Schema meta-schemata */
-declare const remotes: JsonSchema[];
-//#endregion
-export { remotes };

package/dist/remotes/index.d.mts

@@ -1,7 +0,0 @@
-import { c as JsonSchema } from "../types-DVyFDxCv.mjs";
-
-//#region remotes/index.d.ts
-/** JSON Schema meta-schemata */
-declare const remotes: JsonSchema[];
-//#endregion
-export { remotes };