@hyperjump/json-schema 1.14.0 → 1.15.0

package/README.md

@@ -212,11 +212,11 @@ Schema, such as `@hyperjump/json-schema/draft-2020-12`.
     Load a schema manually rather than fetching it from the filesystem or over
     the network. Any schema already registered with the same identifier will be
     replaced with no warning.
-* **validate**: (schemaURI: string, instance: any, outputFormat: OutputFormat = FLAG) => Promise\<OutputUnit>
+* **validate**: (schemaURI: string, instance: any, outputFormat: ValidationOptions | OutputFormat = FLAG) => Promise\<OutputUnit>
 
     Validate an instance against a schema. This function is curried to allow
     compiling the schema once and applying it to multiple instances.
-* **validate**: (schemaURI: string) => Promise\<(instance: any, outputFormat: OutputFormat = FLAG) => OutputUnit>
+* **validate**: (schemaURI: string) => Promise\<(instance: any, outputFormat: ValidationOptions | OutputFormat = FLAG) => OutputUnit>
 
     Compiling a schema to a validation function.
 * **FLAG**: "FLAG"
@@ -255,6 +255,10 @@ The following types are used in the above definitions
     Output is an experimental feature of the JSON Schema specification. There
     may be additional fields present in the OutputUnit, but only the `valid`
     property should be considered part of the Stable API.
+* **ValidationOptions**:
+
+    * outputFormat?: OutputFormat
+    * plugins?: EvaluationPlugin[]
 
 ## Bundling
 
@@ -504,6 +508,57 @@ registerSchema({
 const output = await validate("https://example.com/schema1", 42); // Expect InvalidSchemaError
 ```
 
+### EvaluationPlugins
+
+EvaluationPlugins allow you to hook into the validation process for various
+purposes. There are hooks for before an after schema evaluation and before and
+after keyword evaluation. (See the API section for the full interface) The
+following is a simple example to record all the schema locations that were
+evaluated. This could be used as part of a solution for determining test
+coverage for a schema.
+
+```JavaScript
+import { registerSchema, validate } from "@hyperjump/json-schema/draft-2020-12";
+import { BASIC } from "@hyperjump/json-schema/experimental.js";
+
+class EvaluatedKeywordsPlugin {
+  constructor() {
+    this.schemaLocations = new Set();
+  }
+
+  beforeKeyword([, schemaUri]) {
+    this.schemaLocations.add(schemaUri);
+  }
+}
+
+registerSchema({
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  type: "object",
+  properties: {
+    foo: { type: "number" },
+    bar: { type: "boolean" }
+  },
+  required: ["foo"]
+}, "https://schemas.hyperjump.io/main");
+
+const evaluatedKeywordPlugin = new EvaluatedKeywordsPlugin();
+
+await validate("https://schemas.hyperjump.io/main", { foo: 42 }, {
+  outputFormat: BASIC,
+  plugins: [evaluatedKeywordPlugin]
+});
+
+console.log(evaluatedKeywordPlugin.schemaLocations);
+// Set(4) {
+//   'https://schemas.hyperjump.io/main#/type',
+//   'https://schemas.hyperjump.io/main#/properties',
+//   'https://schemas.hyperjump.io/main#/properties/foo/type',
+//   'https://schemas.hyperjump.io/main#/required'
+// }
+
+// NOTE: #/properties/bar is not in the list because the instance doesn't include that property.
+```
+
 ### API
 
 These are available from the `@hyperjump/json-schema/experimental` export.
@@ -543,15 +598,13 @@ These are available from the `@hyperjump/json-schema/experimental` export.
           function to return the annotation.
       * plugin?: EvaluationPlugin
 
+          If the keyword needs to track state during the evaluation process, you
+          can include an EvaluationPlugin that will get added only when this
+          keyword is present in the schema.
+
     * **ValidationContext**: object
       * ast: AST
       * plugins: EvaluationPlugins[]
-
-    * **EvaluationPlugin**: object
-      * beforeSchema(url: string, instance: JsonNode, context: Context): void
-      * beforeKeyword(keywordNode: Node<any>, instance: JsonNode, context: Context, schemaContext: Context, keyword: Keyword): void
-      * afterKeyword(keywordNode: Node<any>, instance: JsonNode, context: Context, valid: boolean, schemaContext: Context, keyword: Keyword): void
-      * afterSchema(url: string, instance: JsonNode, context: Context, valid: boolean): void
 * **defineVocabulary**: (id: string, keywords: { [keyword: string]: string }) => void
 
     Define a vocabulary that maps keyword name to keyword URIs defined using
@@ -630,6 +683,12 @@ These are available from the `@hyperjump/json-schema/experimental` export.
     include annotations or human readable error messages. The output can be
     processed to create human readable error messages as needed.
 
+* **EvaluationPlugin**: object
+    * beforeSchema?(url: string, instance: JsonNode, context: Context): void
+    * beforeKeyword?(keywordNode: CompiledSchemaNode, instance: JsonNode, context: Context, schemaContext: Context, keyword: Keyword): void
+    * afterKeyword?(keywordNode: CompiledSchemaNode, instance: JsonNode, context: Context, valid: boolean, schemaContext: Context, keyword: Keyword): void
+    * afterSchema?(url: string, instance: JsonNode, context: Context, valid: boolean): void
+
 ## Instance API (experimental)
 
 These functions are available from the

package/annotations/index.d.ts

@@ -1,18 +1,18 @@
-import type { OutputFormat, OutputUnit } from "../lib/index.js";
+import type { OutputFormat, OutputUnit, ValidationOptions } from "../lib/index.js";
 import type { CompiledSchema } from "../lib/experimental.js";
 import type { JsonNode } from "../lib/json-node.js";
 import type { Json } from "@hyperjump/json-pointer";
 
 
 export const annotate: (
-  (schemaUrl: string, value: Json, outputFormat?: OutputFormat) => Promise<JsonNode>
+  (schemaUrl: string, value: Json, options?: OutputFormat | ValidationOptions) => Promise<JsonNode>
 ) & (
   (schemaUrl: string) => Promise<Annotator>
 );
 
-export type Annotator = (value: Json, outputFormat?: OutputFormat) => JsonNode;
+export type Annotator = (value: Json, options?: OutputFormat | ValidationOptions) => JsonNode;
 
-export const interpret: (compiledSchema: CompiledSchema, value: JsonNode, outputFormat?: OutputFormat) => JsonNode;
+export const interpret: (compiledSchema: CompiledSchema, value: JsonNode, options?: OutputFormat | ValidationOptions) => JsonNode;
 
 export class ValidationError extends Error {
   public output: OutputUnit;

package/annotations/index.js

@@ -1,50 +1,36 @@
-import { FLAG } from "../lib/index.js";
 import { ValidationError } from "./validation-error.js";
 import {
   getSchema,
   compile,
+  interpret as validate,
   BASIC,
-  DETAILED,
-  annotationsPlugin,
-  basicOutputPlugin,
-  detailedOutputPlugin
+  AnnotationsPlugin
 } from "../lib/experimental.js";
-import Validation from "../lib/keywords/validation.js";
 import * as Instance from "../lib/instance.js";
 
 
-export const annotate = async (schemaUri, json = undefined, outputFormat = undefined) => {
+export const annotate = async (schemaUri, json = undefined, options = undefined) => {
   const schema = await getSchema(schemaUri);
   const compiled = await compile(schema);
-  const interpretAst = (json, outputFormat) => interpret(compiled, Instance.fromJs(json), outputFormat);
+  const interpretAst = (json, options) => interpret(compiled, Instance.fromJs(json), options);
 
-  return json === undefined ? interpretAst : interpretAst(json, outputFormat);
+  return json === undefined ? interpretAst : interpretAst(json, options);
 };
 
-export const interpret = ({ ast, schemaUri }, instance, outputFormat = BASIC) => {
-  const context = { ast, plugins: [annotationsPlugin, ...ast.plugins] };
-
-  switch (outputFormat) {
-    case FLAG:
-      break;
-    case BASIC:
-      context.plugins.push(basicOutputPlugin);
-      break;
-    case DETAILED:
-      context.plugins.push(detailedOutputPlugin);
-      break;
-    default:
-      throw Error(`Unsupported output format '${outputFormat}'`);
-  }
+export const interpret = (compiledSchema, instance, options = BASIC) => {
+  const annotationsPlugin = new AnnotationsPlugin();
+  const plugins = options.plugins ?? [];
 
-  const valid = Validation.interpret(schemaUri, instance, context);
+  const output = validate(compiledSchema, instance, {
+    outputFormat: typeof options === "string" ? options : options.outputFormat ?? BASIC,
+    plugins: [annotationsPlugin, ...plugins]
+  });
 
-  if (!valid) {
-    const result = !valid && "errors" in context ? { valid, errors: context.errors } : { valid };
-    throw new ValidationError(result);
+  if (!output.valid) {
+    throw new ValidationError(output);
   }
 
-  for (const annotation of context.annotations) {
+  for (const annotation of annotationsPlugin.annotations) {
     const node = Instance.get(annotation.instanceLocation, instance);
     const keyword = annotation.keyword;
     if (!node.annotations[keyword]) {

package/annotations/test-utils.d.ts

@@ -0,0 +1 @@
+export const isCompatible: (compatibility: string | undefined, versionUnderTest: number) => boolean;

package/annotations/test-utils.js

@@ -0,0 +1,38 @@
+export const isCompatible = (compatibility, versionUnderTest) => {
+  if (compatibility === undefined) {
+    return true;
+  }
+
+  const constraints = compatibility.split(",");
+  for (const constraint of constraints) {
+    const matches = /(?<operator><=|>=|=)?(?<version>\d+)/.exec(constraint);
+    if (!matches) {
+      throw Error(`Invalid compatibility string: ${compatibility}`);
+    }
+
+    const operator = matches[1] ?? ">=";
+    const version = parseInt(matches[2], 10);
+
+    switch (operator) {
+      case ">=":
+        if (versionUnderTest < version) {
+          return false;
+        }
+        break;
+      case "<=":
+        if (versionUnderTest > version) {
+          return false;
+        }
+        break;
+      case "=":
+        if (versionUnderTest !== version) {
+          return false;
+        }
+        break;
+      default:
+        throw Error(`Unsupported contraint operator: ${operator}`);
+    }
+  }
+
+  return true;
+};

package/draft-04/dependencies.js

@@ -16,21 +16,21 @@ const compile = (schema, ast) => pipe(
 );
 
 const interpret = (dependencies, instance, context) => {
-  const value = Instance.value(instance);
+  if (Instance.typeOf(instance) !== "object") {
+    return true;
+  }
 
-  return Instance.typeOf(instance) !== "object" || dependencies.every(([propertyName, dependency]) => {
-    if (!(propertyName in value)) {
+  return dependencies.every(([propertyName, dependency]) => {
+    if (!Instance.has(propertyName, instance)) {
       return true;
     }
 
     if (Array.isArray(dependency)) {
-      return dependency.every((key) => key in value);
+      return dependency.every((key) => Instance.has(key, instance));
     } else {
       return Validation.interpret(dependency, instance, context);
     }
   });
 };
 
-const simpleApplicator = true;
-
-export default { id, compile, interpret, simpleApplicator };
+export default { id, compile, interpret };

package/draft-2020-12/dynamicRef.js

@@ -32,10 +32,6 @@ const plugin = {
   },
   beforeKeyword(_url, _instance, context, schemaContext) {
     context.dynamicAnchors = schemaContext.dynamicAnchors;
-  },
-  afterKeyword() {
-  },
-  afterSchema() {
   }
 };
 

package/lib/core.js

@@ -11,19 +11,19 @@ import { InvalidSchemaError } from "./invalid-schema-error.js";
 import { getSchema, registerSchema, unregisterSchema as schemaUnregister } from "./schema.js";
 import { getKeywordName } from "./keywords.js";
 import Validation from "./keywords/validation.js";
-import { basicOutputPlugin } from "./evaluation-plugins/basic-output.js";
-import { detailedOutputPlugin } from "./evaluation-plugins/detailed-output.js";
+import { BasicOutputPlugin } from "./evaluation-plugins/basic-output.js";
+import { DetailedOutputPlugin } from "./evaluation-plugins/detailed-output.js";
 
 
 export const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED";
 setMetaSchemaOutputFormat(FLAG);
 
-export const validate = async (url, value = undefined, outputFormat = undefined) => {
+export const validate = async (url, value = undefined, options = undefined) => {
   const schema = await getSchema(url);
   const compiled = await compile(schema);
-  const interpretAst = (value, outputFormat) => interpret(compiled, Instance.fromJs(value), outputFormat);
+  const interpretAst = (value, options) => interpret(compiled, Instance.fromJs(value), options);
 
-  return value === undefined ? interpretAst : interpretAst(value, outputFormat);
+  return value === undefined ? interpretAst : interpretAst(value, options);
 };
 
 export const compile = async (schema) => {
@@ -32,24 +32,30 @@ export const compile = async (schema) => {
   return { ast, schemaUri };
 };
 
-export const interpret = curry(({ ast, schemaUri }, instance, outputFormat = FLAG) => {
-  const context = { ast, plugins: [...ast.plugins] };
+export const interpret = curry(({ ast, schemaUri }, instance, options = FLAG) => {
+  const outputFormat = typeof options === "string" ? options : options.outputFormat ?? FLAG;
+  const plugins = options.plugins ?? [];
 
+  const context = { ast, plugins: [...ast.plugins, ...plugins] };
+
+  let outputPlugin;
   switch (outputFormat) {
     case FLAG:
       break;
     case BASIC:
-      context.plugins.push(basicOutputPlugin);
+      outputPlugin = new BasicOutputPlugin();
+      context.plugins.push(outputPlugin);
       break;
     case DETAILED:
-      context.plugins.push(detailedOutputPlugin);
+      outputPlugin = new DetailedOutputPlugin();
+      context.plugins.push(outputPlugin);
       break;
     default:
       throw Error(`Unsupported output format '${outputFormat}'`);
   }
 
   const valid = Validation.interpret(schemaUri, instance, context);
-  return !valid && "errors" in context ? { valid, errors: context.errors } : { valid };
+  return !valid && outputPlugin ? { valid, errors: outputPlugin.errors } : { valid };
 });
 
 const metaValidators = {};

package/lib/evaluation-plugins/annotations.js

@@ -1,14 +1,16 @@
 import * as Instance from "../instance.js";
 
 
-export const annotationsPlugin = {
+export class AnnotationsPlugin {
   beforeSchema(_url, _instance, context) {
     context.annotations ??= [];
     context.schemaAnnotations = [];
-  },
+  }
+
   beforeKeyword(_node, _instance, context) {
     context.annotations = [];
-  },
+  }
+
   afterKeyword(node, instance, context, valid, schemaContext, keyword) {
     if (valid) {
       const [keywordId, schemaUri, keywordValue] = node;
@@ -23,10 +25,13 @@ export const annotationsPlugin = {
       }
       schemaContext.schemaAnnotations.push(...context.annotations);
     }
-  },
+  }
+
   afterSchema(_schemaNode, _instanceNode, context, valid) {
     if (valid) {
       context.annotations.push(...context.schemaAnnotations);
     }
+
+    this.annotations = context.annotations;
   }
-};
+}

package/lib/evaluation-plugins/basic-output.js

@@ -2,13 +2,15 @@ import { Validation } from "../experimental.js";
 import * as Instance from "../instance.js";
 
 
-export const basicOutputPlugin = {
+export class BasicOutputPlugin {
   beforeSchema(_url, _intance, context) {
     context.errors ??= [];
-  },
+  }
+
   beforeKeyword(_node, _instance, context) {
     context.errors = [];
-  },
+  }
+
   afterKeyword(node, instance, context, valid, schemaContext, keyword) {
     if (!valid) {
       if (!keyword.simpleApplicator) {
@@ -21,7 +23,8 @@ export const basicOutputPlugin = {
       }
       schemaContext.errors.push(...context.errors);
     }
-  },
+  }
+
   afterSchema(url, instance, context, valid) {
     if (typeof context.ast[url] === "boolean" && !valid) {
       context.errors.push({
@@ -30,5 +33,7 @@ export const basicOutputPlugin = {
         instanceLocation: Instance.uri(instance)
       });
     }
+
+    this.errors = context.errors;
   }
-};
+}

package/lib/evaluation-plugins/detailed-output.js

@@ -2,13 +2,15 @@ import { Validation } from "../experimental.js";
 import * as Instance from "../instance.js";
 
 
-export const detailedOutputPlugin = {
+export class DetailedOutputPlugin {
   beforeSchema(_url, _instance, context) {
     context.errors ??= [];
-  },
+  }
+
   beforeKeyword(_node, _instance, context) {
     context.errors = [];
-  },
+  }
+
   afterKeyword(node, instance, context, valid, schemaContext) {
     if (!valid) {
       const [keywordId, schemaUri] = node;
@@ -23,7 +25,8 @@ export const detailedOutputPlugin = {
         outputUnit.errors = context.errors;
       }
     }
-  },
+  }
+
   afterSchema(url, instance, context, valid) {
     if (typeof context.ast[url] === "boolean" && !valid) {
       context.errors.push({
@@ -32,5 +35,7 @@ export const detailedOutputPlugin = {
         instanceLocation: Instance.uri(instance)
       });
     }
+
+    this.errors = context.errors;
   }
-};
+}

package/lib/experimental.d.ts

@@ -1,5 +1,5 @@
 import type { Browser, Document } from "@hyperjump/browser";
-import type { Validator, OutputUnit, OutputFormat, SchemaObject } from "./index.js";
+import type { Validator, OutputUnit, OutputFormat, SchemaObject, EvaluationPlugin } from "./index.js";
 import type { JsonNode } from "./instance.js";
 
 
@@ -31,6 +31,14 @@ type MetaData = {
 
 type Anchors = Record<string, string>;
 
+// Evaluation Plugins
+export type EvaluationPlugin<Context extends ValidationOptions = ValidationOptions> = {
+  beforeSchema?(url: string, instance: JsonNode, context: Context): void;
+  beforeKeyword?(keywordNode: Node<unknown>, instance: JsonNode, context: Context, schemaContext: Context, keyword: Keyword): void;
+  afterKeyword?(keywordNode: Node<unknown>, instance: JsonNode, context: Context, valid: boolean, schemaContext: Context, keyword: Keyword): void;
+  afterSchema?(url: string, instance: JsonNode, context: Context, valid: boolean): void;
+};
+
 // Output Formats
 export const BASIC: "BASIC";
 export const DETAILED: "DETAILED";
@@ -66,12 +74,13 @@ export const loadDialect: (dialectId: string, dialect: Record<string, boolean>,
 export const unloadDialect: (dialectId: string) => void;
 export const hasDialect: (dialectId: string) => boolean;
 
-export type Keyword<A> = {
+export type Keyword<A, Context extends ValidationContext = ValidationContext> = {
   id: string;
   compile: (schema: Browser<SchemaDocument>, ast: AST, parentSchema: Browser<SchemaDocument>) => Promise<A>;
-  interpret: (compiledKeywordValue: A, instance: JsonNode, context: ValidationContext) => boolean;
-  simpleApplicator: boolean;
+  interpret: (compiledKeywordValue: A, instance: JsonNode, context: Context) => boolean;
+  simpleApplicator?: boolean;
   annotation?: <B>(compiledKeywordValue: A, instance: JsonNode) => B | undefined;
+  plugin?: EvaluationPlugin<Context>;
 };
 
 export type ValidationContext = {
@@ -79,20 +88,22 @@ export type ValidationContext = {
   plugins: EvaluationPlugin<unknown>[];
 };
 
-export type EvaluationPlugin<Context> = {
-  beforeSchema(url: string, instance: JsonNode, context: Context): void;
-  beforeKeyword(keywordNode: Node<unknown>, instance: JsonNode, context: Context, schemaContext: Context, keyword: Keyword): void;
-  afterKeyword(keywordNode: Node<unknown>, instance: JsonNode, context: Context, valid: boolean, schemaContext: Context, keyword: Keyword): void;
-  afterSchema(url: string, instance: JsonNode, context: Context, valid: boolean): void;
-};
+export class BasicOutputPlugin implements EvaluationPlugin<ErrorsContext> {
+  errors: OutputUnit[];
+}
+
+export class DetailedOutputPlugin implements EvaluationPlugin<ErrorsContext> {
+  errors: OutputUnit[];
+}
 
-export const basicOutputPlugin: EvaluationPlugin<ErrorsContext>;
-export const detailedOutputPlugin: EvaluationPlugin<ErrorsContext>;
 export type ErrorsContext = {
   errors: OutputUnit[];
 };
 
-export const annotationsPlugin: EvaluationPlugin<AnnotationsContext>;
+export class AnnotationsPlugin implements EvaluationPlugin<AnnotationsContext> {
+  annotations: OutputUnit[];
+}
+
 export type AnnotationsContext = {
   annotations: OutputUnit[];
 };

package/lib/experimental.js

@@ -6,6 +6,6 @@ export {
 } from "./keywords.js";
 export { getSchema, toSchema, canonicalUri, buildSchemaDocument } from "./schema.js";
 export { default as Validation } from "./keywords/validation.js";
-export { basicOutputPlugin } from "./evaluation-plugins/basic-output.js";
-export { detailedOutputPlugin } from "./evaluation-plugins/detailed-output.js";
-export { annotationsPlugin } from "./evaluation-plugins/annotations.js";
+export * from "./evaluation-plugins/basic-output.js";
+export * from "./evaluation-plugins/detailed-output.js";
+export * from "./evaluation-plugins/annotations.js";

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 import type { Json } from "@hyperjump/json-pointer";
+import type { EvaluationPlugin } from "./experimental.js";
 
 
 export type SchemaFragment = string | number | boolean | null | SchemaObject | SchemaFragment[];
@@ -16,13 +17,18 @@ export const getAllRegisteredSchemaUris: () => string[];
  */
 export const addSchema: typeof registerSchema;
 
+export type ValidationOptions = {
+  outputFormat?: OutputFormat;
+  plugins?: EvaluationPlugin[];
+};
+
 export const validate: (
-  (url: string, value: Json, outputFormat?: OutputFormat) => Promise<OutputUnit>
+  (url: string, value: Json, options?: OutputFormat | ValidationOptions) => Promise<OutputUnit>
 ) & (
   (url: string) => Promise<Validator>
 );
 
-export type Validator = (value: Json, outputFormat?: OutputFormat) => OutputUnit;
+export type Validator = (value: Json, options?: OutputFormat | ValidationOptions) => OutputUnit;
 
 export type OutputUnit = {
   keyword: string;

package/lib/keywords/contentSchema.js

@@ -1,4 +1,3 @@
-import { canonicalUri } from "../schema.js";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 import { getKeywordName } from "../keywords.js";
@@ -9,13 +8,17 @@ const id = "https://json-schema.org/keyword/contentSchema";
 const compile = async (contentSchema, _ast, parentSchema) => {
   const contentMediaTypeKeyword = getKeywordName(contentSchema.document.dialectId, "https://json-schema.org/keyword/contentMediaType");
   const contentMediaType = await Browser.step(contentMediaTypeKeyword, parentSchema);
-  return Browser.value(contentMediaType) && canonicalUri(contentSchema);
+  if (Browser.value(contentMediaType) === undefined) {
+    return;
+  }
+
+  return Browser.value(contentSchema);
 };
 
 const interpret = () => true;
 
 const annotation = (contentSchema, instance) => {
-  if (Instance.typeOf(instance) !== "string") {
+  if (!contentSchema || Instance.typeOf(instance) !== "string") {
     return;
   }
 

package/lib/keywords/dynamicRef.js

@@ -31,10 +31,6 @@ const plugin = {
   },
   beforeKeyword(_url, _instance, context, schemaContext) {
     context.dynamicAnchors = schemaContext.dynamicAnchors;
-  },
-  afterKeyword() {
-  },
-  afterSchema() {
   }
 };
 

package/lib/keywords/unevaluatedItems.js

@@ -13,25 +13,22 @@ const interpret = ([schemaUrl, unevaluatedItems], instance, context) => {
     return true;
   }
 
-  if (context.rootSchema === schemaUrl) {
-    return true;
-  }
-
   // Because order matters, we re-evaluate this schema skipping this keyword
   // just to collect all the evalauted items.
-  const keywordContext = {
-    ...context,
-    plugins: [...context.ast.plugins, unevaluatedPlugin],
-    rootSchema: schemaUrl
-  };
-  if (!Validation.interpret(schemaUrl, instance, keywordContext)) {
+  if (context.rootSchema === schemaUrl) {
     return true;
   }
+  const evaluatedItemsPlugin = new EvaluatedItemsPlugin(schemaUrl);
+  Validation.interpret(schemaUrl, instance, {
+    ...context,
+    plugins: [...context.ast.plugins, evaluatedItemsPlugin]
+  });
+  const evaluatedItems = evaluatedItemsPlugin.evaluatedItems;
 
   let isValid = true;
   let index = 0;
   for (const item of Instance.iter(instance)) {
-    if (!keywordContext.evaluatedItems.has(index)) {
+    if (!evaluatedItems.has(index)) {
       if (!Validation.interpret(unevaluatedItems, item, context)) {
         isValid = false;
       }
@@ -47,29 +44,38 @@ const interpret = ([schemaUrl, unevaluatedItems], instance, context) => {
 
 const simpleApplicator = true;
 
-const unevaluatedPlugin = {
+class EvaluatedItemsPlugin {
+  constructor(rootSchema) {
+    this.rootSchema = rootSchema;
+  }
+
   beforeSchema(_url, _instance, context) {
     context.evaluatedItems ??= new Set();
     context.schemaEvaluatedItems ??= new Set();
-  },
-  beforeKeyword(_node, _instance, context, schemaContext) {
-    context.rootSchema = schemaContext.rootSchema;
+  }
+
+  beforeKeyword(_node, _instance, context) {
+    context.rootSchema = this.rootSchema;
     context.evaluatedItems = new Set();
-  },
+  }
+
   afterKeyword(_node, _instance, context, valid, schemaContext) {
     if (valid) {
       for (const index of context.evaluatedItems) {
         schemaContext.schemaEvaluatedItems.add(index);
       }
     }
-  },
+  }
+
   afterSchema(_url, _instance, context, valid) {
     if (valid) {
       for (const index of context.schemaEvaluatedItems) {
         context.evaluatedItems.add(index);
       }
     }
+
+    this.evaluatedItems = context.evaluatedItems;
   }
-};
+}
 
 export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/unevaluatedProperties.js

@@ -13,25 +13,22 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, context) => {
     return true;
   }
 
-  if (context.rootSchema === schemaUrl) {
-    return true;
-  }
-
   // Because order matters, we re-evaluate this schema skipping this keyword
   // just to collect all the evalauted properties.
-  const keywordContext = {
-    ...context,
-    plugins: [...context.ast.plugins, unevaluatedPlugin],
-    rootSchema: schemaUrl
-  };
-  if (!Validation.interpret(schemaUrl, instance, keywordContext)) {
+  if (context.rootSchema === schemaUrl) {
     return true;
   }
+  const evaluatedPropertiesPlugin = new EvaluatedPropertiesPlugin(schemaUrl);
+  Validation.interpret(schemaUrl, instance, {
+    ...context,
+    plugins: [...context.ast.plugins, evaluatedPropertiesPlugin]
+  });
+  const evaluatedProperties = evaluatedPropertiesPlugin.evaluatedProperties;
 
   let isValid = true;
   for (const [propertyNameNode, property] of Instance.entries(instance)) {
     const propertyName = Instance.value(propertyNameNode);
-    if (keywordContext.evaluatedProperties.has(propertyName)) {
+    if (evaluatedProperties.has(propertyName)) {
       continue;
     }
 
@@ -47,29 +44,38 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, context) => {
 
 const simpleApplicator = true;
 
-const unevaluatedPlugin = {
+class EvaluatedPropertiesPlugin {
+  constructor(rootSchema) {
+    this.rootSchema = rootSchema;
+  }
+
   beforeSchema(_url, _instance, context) {
     context.evaluatedProperties ??= new Set();
     context.schemaEvaluatedProperties ??= new Set();
-  },
-  beforeKeyword(_node, _instance, context, schemaContext) {
-    context.rootSchema = schemaContext.rootSchema;
+  }
+
+  beforeKeyword(_node, _instance, context) {
+    context.rootSchema = this.rootSchema;
     context.evaluatedProperties = new Set();
-  },
+  }
+
   afterKeyword(_node, _instance, context, valid, schemaContext) {
     if (valid) {
       for (const property of context.evaluatedProperties) {
         schemaContext.schemaEvaluatedProperties.add(property);
       }
     }
-  },
+  }
+
   afterSchema(_url, _instance, context, valid) {
     if (valid) {
       for (const property of context.schemaEvaluatedProperties) {
         context.evaluatedProperties.add(property);
       }
     }
+
+    this.evaluatedProperties = context.evaluatedProperties;
   }
-};
+}
 
 export default { id, compile, interpret, simpleApplicator };

package/lib/keywords/validation.js

@@ -49,7 +49,7 @@ const interpret = (url, instance, context) => {
   let valid = true;
 
   for (const plugin of context.plugins) {
-    plugin.beforeSchema(url, instance, context);
+    plugin.beforeSchema?.(url, instance, context);
   }
 
   if (typeof context.ast[url] === "boolean") {
@@ -64,7 +64,7 @@ const interpret = (url, instance, context) => {
         plugins: context.plugins
       };
       for (const plugin of context.plugins) {
-        plugin.beforeKeyword(node, instance, keywordContext, context, keyword);
+        plugin.beforeKeyword?.(node, instance, keywordContext, context, keyword);
       }
       const isKeywordValid = keyword.interpret(keywordValue, instance, keywordContext);
       if (!isKeywordValid) {
@@ -72,13 +72,13 @@ const interpret = (url, instance, context) => {
       }
 
       for (const plugin of context.plugins) {
-        plugin.afterKeyword(node, instance, keywordContext, isKeywordValid, context, keyword);
+        plugin.afterKeyword?.(node, instance, keywordContext, isKeywordValid, context, keyword);
       }
     }
   }
 
   for (const plugin of context.plugins) {
-    plugin.afterSchema(url, instance, context, valid);
+    plugin.afterSchema?.(url, instance, context, valid);
   }
   return valid;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "description": "A JSON Schema validator with support for custom keywords, vocabularies, and dialects",
   "type": "module",
   "main": "./stable/index.js",