Making getErrors synchronous

src/error-handlers/anyOf.js

@@ -7,7 +7,7 @@ import { getErrors } from "../json-schema-errors.js";
  */
 
 /** @type ErrorHandler */
-const anyOfErrorHandler = async (normalizedErrors, instance, localization) => {
+const anyOfErrorHandler = (normalizedErrors, instance, localization, ast) => {
   /** @type ErrorObject[] */
   const errors = [];
 
@@ -51,13 +51,13 @@ const anyOfErrorHandler = async (normalizedErrors, instance, localization) => {
       }
 
       // The alternative passed all the filters
-      alternatives.push(await getErrors(alternative, instance, localization));
+      alternatives.push(getErrors(alternative, instance, localization, ast));
     }
 
     // If all alternatives were filtered out, default to returning all of them
     if (alternatives.length === 0) {
       for (const alternative of anyOf) {
-        alternatives.push(await getErrors(alternative, instance, localization));
+        alternatives.push(getErrors(alternative, instance, localization, ast));
       }
     }
 

src/error-handlers/boolean-schema.js

@@ -5,7 +5,7 @@ import * as Instance from "@hyperjump/json-schema/instance/experimental";
  */
 
 /** @type ErrorHandler */
-const booleanSchemaErrorHandler = async (normalizedErrors, instance, localization) => {
+const booleanSchemaErrorHandler = (normalizedErrors, instance, localization) => {
   /** @type ErrorObject[] */
   const errors = [];
 

src/error-handlers/contains.js

@@ -1,13 +1,13 @@
-import { getSchema } from "@hyperjump/json-schema/experimental";
-import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
+import { getCompiledKeywordValue, getSiblingKeywordLocation } from "../json-schema-errors.js";
 
 /**
+ * @import { ContainsAst } from "../normalization-handlers/contains.js"
  * @import { ContainsRange, ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const containsErrorHandler = async (normalizedErrors, instance, localization) => {
+const containsErrorHandler = (normalizedErrors, instance, localization, ast) => {
   /** @type ErrorObject[] */
   const errors = [];
 
@@ -25,25 +25,21 @@ const containsErrorHandler = async (normalizedErrors, instance, localization) =>
       /** @type string[] */
       const schemaLocations = [schemaLocation];
 
+      const contains = /** @type ContainsAst */ (getCompiledKeywordValue(ast, schemaLocation));
+
       /** @type ContainsRange */
       const range = {};
-      const parentLocation = pointerPop(schemaLocation);
-
-      for (const minContainsLocation in normalizedErrors["https://json-schema.org/keyword/minContains"]) {
-        if (pointerPop(minContainsLocation) === parentLocation) {
-          const minContainsNode = await getSchema(minContainsLocation);
-          range.minContains = /** @type number */ (Schema.value(minContainsNode));
+      if (typeof contains !== "string") {
+        if (contains.minContains !== 1) {
+          range.minContains = contains.minContains;
+          const minContainsLocation = getSiblingKeywordLocation(ast, schemaLocation, "https://json-schema.org/keyword/minContains");
           schemaLocations.push(minContainsLocation);
-          break;
         }
-      }
 
-      for (const maxContainsLocation in normalizedErrors["https://json-schema.org/keyword/maxContains"]) {
-        if (pointerPop(maxContainsLocation) === parentLocation) {
-          const maxContainsNode = await getSchema(maxContainsLocation);
-          range.maxContains = /** @type number */ (Schema.value(maxContainsNode));
+        if (contains.maxContains !== Number.MAX_SAFE_INTEGER) {
+          range.maxContains = contains.maxContains;
+          const maxContainsLocation = getSiblingKeywordLocation(ast, schemaLocation, "https://json-schema.org/keyword/maxContains");
           schemaLocations.push(maxContainsLocation);
-          break;
         }
       }
 
@@ -58,7 +54,4 @@ const containsErrorHandler = async (normalizedErrors, instance, localization) =>
   return errors;
 };
 
-/** @type (pointer: string) => string */
-const pointerPop = (pointer) => pointer.replace(/\/[^/]+$/, "");
-
 export default containsErrorHandler;

src/error-handlers/draft-04/dependencies.js

@@ -5,7 +5,7 @@ import { getErrors } from "../../json-schema-errors.js";
  */
 
 /** @type ErrorHandler */
-const dependenciesErrorHandler = async (normalizedErrors, instance, localization) => {
+const dependenciesErrorHandler = (normalizedErrors, instance, localization, ast) => {
   /** @type ErrorObject[] */
   const errors = [];
 
@@ -16,7 +16,7 @@ const dependenciesErrorHandler = async (normalizedErrors, instance, localization
 
     const dependentSchemaOutputs = normalizedErrors["https://json-schema.org/keyword/draft-04/dependencies"][schemaLocation];
     for (const dependentSchemaOutput of dependentSchemaOutputs) {
-      const dependentSchemaErrors = await getErrors(dependentSchemaOutput, instance, localization);
+      const dependentSchemaErrors = getErrors(dependentSchemaOutput, instance, localization, ast);
       errors.push(...dependentSchemaErrors);
     }
   }

src/error-handlers/format.js

@@ -1,13 +1,12 @@
-import { getSchema } from "@hyperjump/json-schema/experimental";
-import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
+import { getCompiledKeywordValue } from "../json-schema-errors.js";
 
 /**
  * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const formatErrorHandler = async (normalizedErrors, instance, localization) => {
+const formatErrorHandler = (normalizedErrors, instance, localization, ast) => {
   /** @type ErrorObject[] */
   const errors = [];
 
@@ -26,8 +25,7 @@ const formatErrorHandler = async (normalizedErrors, instance, localization) => {
         continue;
       }
 
-      const keyword = await getSchema(schemaLocation);
-      const format = /** @type string */ (Schema.value(keyword));
+      const format = /** @type string */ (getCompiledKeywordValue(ast, schemaLocation));
 
       errors.push({
         message: localization.getFormatErrorMessage(format),

src/error-handlers/maxItems.js

@@ -1,13 +1,12 @@
-import { getSchema } from "@hyperjump/json-schema/experimental";
-import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
+import { getCompiledKeywordValue } from "../json-schema-errors.js";
 
 /**
  * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const maxItemsErrorHandler = async (normalizedErrors, instance, localization) => {
+const maxItemsErrorHandler = (normalizedErrors, instance, localization, ast) => {
   /** @type ErrorObject[] */
   const errors = [];
   let lowestMaxItems = Infinity;
@@ -18,8 +17,7 @@ const maxItemsErrorHandler = async (normalizedErrors, instance, localization) =>
       continue;
     }
 
-    const keyword = await getSchema(schemaLocation);
-    const maxItems = /** @type number */ (Schema.value(keyword));
+    const maxItems = /** @type number */ (getCompiledKeywordValue(ast, schemaLocation));
 
     if (maxItems < lowestMaxItems) {
       lowestMaxItems = maxItems;

src/error-handlers/maxLength.js

@@ -1,13 +1,12 @@
-import { getSchema } from "@hyperjump/json-schema/experimental";
-import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
+import { getCompiledKeywordValue } from "../json-schema-errors.js";
 
 /**
  * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const maxLengthErrorHandler = async (normalizedErrors, instance, localization) => {
+const maxLengthErrorHandler = (normalizedErrors, instance, localization, ast) => {
   /** @type ErrorObject[] */
   const errors = [];
   let lowestMaxLength = Infinity;
@@ -18,8 +17,7 @@ const maxLengthErrorHandler = async (normalizedErrors, instance, localization) =
       continue;
     }
 
-    const keyword = await getSchema(schemaLocation);
-    const maxLength = /** @type number */ (Schema.value(keyword));
+    const maxLength = /** @type number */ (getCompiledKeywordValue(ast, schemaLocation));
 
     if (maxLength < lowestMaxLength) {
       lowestMaxLength = maxLength;

src/error-handlers/maxProperties.js

@@ -1,13 +1,12 @@
-import { getSchema } from "@hyperjump/json-schema/experimental";
-import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
+import { getCompiledKeywordValue } from "../json-schema-errors.js";
 
 /**
  * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const maxPropertiesErrorHandler = async (normalizedErrors, instance, localization) => {
+const maxPropertiesErrorHandler = (normalizedErrors, instance, localization, ast) => {
   /** @type ErrorObject[] */
   const errors = [];
   let lowestMaxProperties = Infinity;
@@ -17,8 +16,7 @@ const maxPropertiesErrorHandler = async (normalizedErrors, instance, localizatio
       continue;
     }
 
-    const keyword = await getSchema(schemaLocation);
-    const maxProperties = /** @type number */ (Schema.value(keyword));
+    const maxProperties = /** @type number */ (getCompiledKeywordValue(ast, schemaLocation));
 
     if (maxProperties < lowestMaxProperties) {
       lowestMaxProperties = maxProperties;

src/error-handlers/maximum.js

@@ -1,13 +1,12 @@
-import { getSchema } from "@hyperjump/json-schema/experimental";
-import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
+import { getCompiledKeywordValue, getSiblingKeywordLocation } from "../json-schema-errors.js";
 
 /**
  * @import { ErrorHandler } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const maximumErrorHandler = async (normalizedErrors, instance, localization) => {
+const maximumErrorHandler = (normalizedErrors, instance, localization, ast) => {
   let lowestMaximum = Infinity;
   let isExclusive = false;
 
@@ -19,8 +18,7 @@ const maximumErrorHandler = async (normalizedErrors, instance, localization) =>
       continue;
     }
 
-    const keyword = await getSchema(schemaLocation);
-    const maximum = /** @type number */ (Schema.value(keyword));
+    const maximum = /** @type number */ (getCompiledKeywordValue(ast, schemaLocation));
     if (maximum < lowestMaximum) {
       lowestMaximum = maximum;
       schemaLocations = [schemaLocation];
@@ -32,8 +30,7 @@ const maximumErrorHandler = async (normalizedErrors, instance, localization) =>
       continue;
     }
 
-    const keyword = await getSchema(schemaLocation);
-    const exclusiveMaximum = /** @type number */ (Schema.value(keyword));
+    const exclusiveMaximum = /** @type number */ (getCompiledKeywordValue(ast, schemaLocation));
     if (exclusiveMaximum < lowestMaximum) {
       lowestMaximum = exclusiveMaximum;
       isExclusive = true;
@@ -46,27 +43,15 @@ const maximumErrorHandler = async (normalizedErrors, instance, localization) =>
       continue;
     }
 
-    const parentLocation = pointerPop(schemaLocation);
-    /** @type string */
-    let exclusiveLocation = "";
-    for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/draft-04/exclusiveMaximum"]) {
-      const exclusiveParentLocation = pointerPop(schemaLocation);
-      if (exclusiveParentLocation === parentLocation) {
-        const exclusiveNode = await getSchema(schemaLocation);
-        if (Schema.value(exclusiveNode)) {
-          exclusiveLocation = schemaLocation;
-        }
-        break;
-      }
-    }
-
-    const keywordNode = await getSchema(schemaLocation);
-    const maximum = /** @type number */ (Schema.value(keywordNode));
-
+    const [maximum, exclusive] = /** @type [number, boolean] */ (getCompiledKeywordValue(ast, schemaLocation));
     if (maximum < lowestMaximum) {
       lowestMaximum = maximum;
-      isExclusive = !!exclusiveLocation;
-      schemaLocations = exclusiveLocation ? [schemaLocation, exclusiveLocation] : [schemaLocation];
+      isExclusive = exclusive;
+      schemaLocations = [schemaLocation];
+      if (exclusive) {
+        const exclusiveLocation = getSiblingKeywordLocation(ast, schemaLocation, "https://json-schema.org/keyword/draft-04/exclusiveMaximum");
+        schemaLocations.push(exclusiveLocation);
+      }
     }
   }
 
@@ -87,7 +72,4 @@ const maximumErrorHandler = async (normalizedErrors, instance, localization) =>
   }
 };
 
-/** @type (pointer: string) => string */
-const pointerPop = (pointer) => pointer.replace(/\/[^/]+$/, "");
-
 export default maximumErrorHandler;

src/error-handlers/minItems.js

@@ -1,13 +1,12 @@
-import { getSchema } from "@hyperjump/json-schema/experimental";
-import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
+import { getCompiledKeywordValue } from "../json-schema-errors.js";
 
 /**
  * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const minItemsErrorHandler = async (normalizedErrors, instance, localization) => {
+const minItemsErrorHandler = (normalizedErrors, instance, localization, ast) => {
   /** @type ErrorObject[] */
   const errors = [];
   let highestMinItem = 0;
@@ -18,8 +17,7 @@ const minItemsErrorHandler = async (normalizedErrors, instance, localization) =>
       continue;
     }
 
-    const keyword = await getSchema(schemaLocation);
-    const minItems = /** @type number */ (Schema.value(keyword));
+    const minItems = /** @type number */ (getCompiledKeywordValue(ast, schemaLocation));
 
     if (minItems > highestMinItem) {
       highestMinItem = minItems;

src/error-handlers/minLength.js

@@ -1,13 +1,12 @@
-import { getSchema } from "@hyperjump/json-schema/experimental";
-import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
+import { getCompiledKeywordValue } from "../json-schema-errors.js";
 
 /**
  * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const minLengthErrorHandler = async (normalizedErrors, instance, localization) => {
+const minLengthErrorHandler = (normalizedErrors, instance, localization, ast) => {
   /** @type ErrorObject[] */
   const errors = [];
   let highestMinLength = -Infinity;
@@ -18,8 +17,7 @@ const minLengthErrorHandler = async (normalizedErrors, instance, localization) =
       continue;
     }
 
-    const keyword = await getSchema(schemaLocation);
-    const minLength = /** @type number */ (Schema.value(keyword));
+    const minLength = /** @type number */ (getCompiledKeywordValue(ast, schemaLocation));
 
     if (minLength > highestMinLength) {
       highestMinLength = minLength;

src/error-handlers/minProperties.js

@@ -1,13 +1,12 @@
-import { getSchema } from "@hyperjump/json-schema/experimental";
-import * as Schema from "@hyperjump/browser";
 import * as Instance from "@hyperjump/json-schema/instance/experimental";
+import { getCompiledKeywordValue } from "../json-schema-errors.js";
 
 /**
  * @import { ErrorHandler, ErrorObject } from "../index.d.ts"
  */
 
 /** @type ErrorHandler */
-const minPropertiesErrorHandler = async (normalizedErrors, instance, localization) => {
+const minPropertiesErrorHandler = (normalizedErrors, instance, localization, ast) => {
   /** @type ErrorObject[] */
   const errors = [];
 
@@ -19,8 +18,7 @@ const minPropertiesErrorHandler = async (normalizedErrors, instance, localizatio
       continue;
     }
 
-    const keyword = await getSchema(schemaLocation);
-    const minProperties = /** @type number */ (Schema.value(keyword));
+    const minProperties = /** @type number */ (getCompiledKeywordValue(ast, schemaLocation));
 
     if (minProperties > highestMinProperties) {
       highestMinProperties = minProperties;