@hyperjump/json-schema 1.13.0 → 1.14.1

package/README.md

@@ -248,8 +248,8 @@ The following types are used in the above definitions
 
 * **OutputFormat**: **FLAG**
 
-    Only the `FLAG` output format is part of the Stable API. Additional output
-    formats are included as part of the Experimental API.
+    Only the `FLAG` output format is part of the Stable API. Additional [output
+    formats](#output-formats) are included as part of the Experimental API.
 * **OutputUnit**: { valid: boolean }
 
     Output is an experimental feature of the JSON Schema specification. There
@@ -336,7 +336,8 @@ These are available from the `@hyperjump/json-schema/bundle` export.
 The `FLAG` output format isn't very informative. You can change the output
 format used for validation to get more information about failures. The official
 output format is still evolving, so these may change or be replaced in the
-future.
+future. This implementation currently supports the BASIC and DETAILED output
+formats.
 
 ```javascript
 import { BASIC } from "@hyperjump/json-schema/experimental";
@@ -536,28 +537,21 @@ These are available from the `@hyperjump/json-schema/experimental` export.
           validation of its own. In these cases, it isn't helpful to include
           them in BASIC output. This flag is used to trim those nodes from the
           output.
-      * collectEvaluatedProperties?: (compiledKeywordValue: any, instance: JsonNode, context: ValidationContext, isTop?: boolean) => Set\<string> | false
-
-          If the keyword is an applicator, it will need to implement this
-          function for `unevaluatedProperties` to work as expected.
-      * collectEvaluatedItems?: (compiledKeywordValue: A, instance: JsonNode, context: ValidationContext, isTop?: boolean) => Set\<number> | false
-
-          If the keyword is an applicator, it will need to implement this
-          function for `unevaluatedItems` to work as expected.
-      * collectExternalIds?: (visited: Set\<string>, parentSchema: Browser, schema: Browser) => Set\<string>
-          If the keyword is an applicator, it will need to implement this
-          function to work properly with the [bundle](#bundling) feature.
-      * annotation?: (compiledKeywordValue: any) => any
+      * annotation?: (compiledKeywordValue: any) => any | undefined
 
           If the keyword is an annotation, it will need to implement this
           function to return the annotation.
+      * plugin?: EvaluationPlugin
 
     * **ValidationContext**: object
       * ast: AST
-      * dynamicAnchors: object
-      * schemaUrl: string
-      * errors: OutputUnit[]
-      * annotations: OutputUnit[]
+      * 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
@@ -596,7 +590,7 @@ These are available from the `@hyperjump/json-schema/experimental` export.
 * **getSchema**: (uri: string, browser?: Browser) => Promise\<Browser>
 
     Get a schema by it's URI taking the local schema registry into account.
-* buildSchemaDocument: (schema: SchemaObject | boolean, retrievalUri?: string, contextDialectId?: string) => SchemaDocument
+* **buildSchemaDocument**: (schema: SchemaObject | boolean, retrievalUri?: string, contextDialectId?: string) => SchemaDocument
 
     Build a SchemaDocument from a JSON-compatible value. You might use this if
     you're creating a custom media type plugin, such as supporting JSON Schemas

package/annotations/index.js

@@ -1,6 +1,14 @@
 import { FLAG } from "../lib/index.js";
 import { ValidationError } from "./validation-error.js";
-import { getSchema, compile, BASIC } from "../lib/experimental.js";
+import {
+  getSchema,
+  compile,
+  BASIC,
+  DETAILED,
+  annotationsPlugin,
+  basicOutputPlugin,
+  detailedOutputPlugin
+} from "../lib/experimental.js";
 import Validation from "../lib/keywords/validation.js";
 import * as Instance from "../lib/instance.js";
 
@@ -14,23 +22,35 @@ export const annotate = async (schemaUri, json = undefined, outputFormat = undef
 };
 
 export const interpret = ({ ast, schemaUri }, instance, outputFormat = BASIC) => {
-  const errors = [];
-  const annotations = [];
-  const context = { ast, dynamicAnchors: {}, errors, annotations, outputFormat };
+  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}'`);
+  }
+
   const valid = Validation.interpret(schemaUri, instance, context);
 
   if (!valid) {
-    const result = outputFormat === FLAG || valid ? { valid } : { valid, errors };
+    const result = !valid && "errors" in context ? { valid, errors: context.errors } : { valid };
     throw new ValidationError(result);
   }
 
-  for (const annotation of annotations) {
+  for (const annotation of context.annotations) {
     const node = Instance.get(annotation.instanceLocation, instance);
     const keyword = annotation.keyword;
     if (!node.annotations[keyword]) {
       node.annotations[keyword] = [];
     }
-    node.annotations[keyword].push(annotation.annotation);
+    node.annotations[keyword].unshift(annotation.annotation);
   }
 
   return instance;

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/bundle/index.js

@@ -1,13 +1,8 @@
-import curry from "just-curry-it";
 import { v4 as uuid } from "uuid";
-import * as Browser from "@hyperjump/browser";
+import { jrefTypeOf } from "@hyperjump/browser/jref";
 import * as JsonPointer from "@hyperjump/json-pointer";
-import { asyncCollectSet, asyncFilter, asyncFlatten, asyncMap, pipe } from "@hyperjump/pact";
-import {
-  Validation,
-  canonicalUri, getSchema, toSchema,
-  getKeywordName, getKeyword, getKeywordByName
-} from "../lib/experimental.js";
+import { resolveIri, toAbsoluteIri } from "@hyperjump/uri";
+import { getSchema, toSchema, getKeywordName } from "../lib/experimental.js";
 
 
 export const URI = "uri", UUID = "uuid";
@@ -19,32 +14,36 @@ const defaultOptions = {
 };
 
 export const bundle = async (url, options = {}) => {
-  loadKeywordSupport();
   const fullOptions = { ...defaultOptions, ...options };
 
   const mainSchema = await getSchema(url);
-  const contextUri = mainSchema.document.baseUri;
-  const contextDialectId = mainSchema.document.dialectId;
+  fullOptions.contextUri = mainSchema.document.baseUri;
+  fullOptions.contextDialectId = mainSchema.document.dialectId;
+
   const bundled = toSchema(mainSchema);
+  fullOptions.bundlingLocation = "/" + getKeywordName(fullOptions.contextDialectId, "https://json-schema.org/keyword/definitions");
+  if (JsonPointer.get(fullOptions.bundlingLocation, bundled) === undefined) {
+    JsonPointer.assign(fullOptions.bundlingLocation, bundled, {});
+  }
 
-  const externalIds = await Validation.collectExternalIds(new Set(), mainSchema, mainSchema);
+  return await doBundling(mainSchema.uri, bundled, fullOptions);
+};
 
-  // Bundle
-  const bundlingLocation = "/" + getKeywordName(contextDialectId, "https://json-schema.org/keyword/definitions");
-  if (JsonPointer.get(bundlingLocation, bundled) === undefined && externalIds.size > 0) {
-    JsonPointer.assign(bundlingLocation, bundled, {});
-  }
+const doBundling = async (schemaUri, bundled, fullOptions, contextSchema, visited = new Set()) => {
+  visited.add(schemaUri);
 
-  for (const uri of externalIds) {
-    if (fullOptions.externalSchemas.includes(uri)) {
+  const schema = await getSchema(schemaUri, contextSchema);
+  for (const reference of allReferences(schema.document.root)) {
+    const uri = toAbsoluteIri(resolveIri(reference.href, schema.document.baseUri));
+    if (visited.has(uri) || fullOptions.externalSchemas.includes(uri) || (uri in schema.document.embedded && !(uri in schema._cache))) {
       continue;
     }
 
-    const externalSchema = await getSchema(uri);
+    const externalSchema = await getSchema(uri, contextSchema);
     const embeddedSchema = toSchema(externalSchema, {
-      contextUri: externalSchema.document.baseUri.startsWith("file:") ? contextUri : undefined,
+      contextUri: externalSchema.document.baseUri.startsWith("file:") ? fullOptions.contextUri : undefined,
       includeDialect: fullOptions.alwaysIncludeDialect ? "always" : "auto",
-      contextDialectId: contextDialectId
+      contextDialectId: fullOptions.contextDialectId
     });
     let id;
     if (fullOptions.definitionNamingStrategy === URI) {
@@ -56,216 +55,29 @@ export const bundle = async (url, options = {}) => {
     } else {
       throw Error(`Unknown definition naming stragety: ${fullOptions.definitionNamingStrategy}`);
     }
-    const pointer = JsonPointer.append(id, bundlingLocation);
+    const pointer = JsonPointer.append(id, fullOptions.bundlingLocation);
     JsonPointer.assign(pointer, bundled, embeddedSchema);
+
+    bundled = await doBundling(uri, bundled, fullOptions, schema, visited);
   }
 
   return bundled;
 };
 
-Validation.collectExternalIds = curry(async (visited, parentSchema, schema) => {
-  const uri = canonicalUri(schema);
-  if (visited.has(uri) || Browser.typeOf(schema) === "boolean") {
-    return new Set();
-  }
-
-  visited.add(uri);
-
-  const externalIds = await pipe(
-    Browser.entries(schema),
-    asyncMap(async ([keyword, keywordSchema]) => {
-      const keywordHandler = getKeywordByName(keyword, schema.document.dialectId);
-
-      return "collectExternalIds" in keywordHandler
-        ? await keywordHandler.collectExternalIds(visited, schema, keywordSchema)
-        : new Set();
-    }),
-    asyncFlatten,
-    asyncCollectSet
-  );
-
-  if (parentSchema.document.baseUri !== schema.document.baseUri
-    && (!(schema.document.baseUri in parentSchema.document.embedded) || schema.document.baseUri in parentSchema._cache)
-  ) {
-    externalIds.add(schema.document.baseUri);
-  }
-
-  return externalIds;
-});
-
-const collectExternalIdsFromArrayOfSchemas = (visited, parentSchema, schema) => pipe(
-  Browser.iter(schema),
-  asyncMap(Validation.collectExternalIds(visited, parentSchema)),
-  asyncFlatten,
-  asyncCollectSet
-);
-
-const collectExternalIdsFromObjectOfSchemas = async (visited, parentSchema, schema) => pipe(
-  Browser.values(schema),
-  asyncMap(Validation.collectExternalIds(visited, parentSchema)),
-  asyncFlatten,
-  asyncCollectSet
-);
-
-const loadKeywordSupport = () => {
-  // Stable
-
-  const additionalProperties = getKeyword("https://json-schema.org/keyword/additionalProperties");
-  if (additionalProperties) {
-    additionalProperties.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  const allOf = getKeyword("https://json-schema.org/keyword/allOf");
-  if (allOf) {
-    allOf.collectExternalIds = collectExternalIdsFromArrayOfSchemas;
-  }
-
-  const anyOf = getKeyword("https://json-schema.org/keyword/anyOf");
-  if (anyOf) {
-    anyOf.collectExternalIds = collectExternalIdsFromArrayOfSchemas;
-  }
-
-  const contains = getKeyword("https://json-schema.org/keyword/contains");
-  if (contains) {
-    contains.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  const dependentSchemas = getKeyword("https://json-schema.org/keyword/dependentSchemas");
-  if (dependentSchemas) {
-    dependentSchemas.collectExternalIds = collectExternalIdsFromObjectOfSchemas;
-  }
-
-  const if_ = getKeyword("https://json-schema.org/keyword/if");
-  if (if_) {
-    if_.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  const then = getKeyword("https://json-schema.org/keyword/then");
-  if (then) {
-    then.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  const else_ = getKeyword("https://json-schema.org/keyword/else");
-  if (else_) {
-    else_.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  const items = getKeyword("https://json-schema.org/keyword/items");
-  if (items) {
-    items.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  const not = getKeyword("https://json-schema.org/keyword/not");
-  if (not) {
-    not.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  const oneOf = getKeyword("https://json-schema.org/keyword/oneOf");
-  if (oneOf) {
-    oneOf.collectExternalIds = collectExternalIdsFromArrayOfSchemas;
-  }
-
-  const patternProperties = getKeyword("https://json-schema.org/keyword/patternProperties");
-  if (patternProperties) {
-    patternProperties.collectExternalIds = collectExternalIdsFromObjectOfSchemas;
-  }
-
-  const prefixItems = getKeyword("https://json-schema.org/keyword/prefixItems");
-  if (prefixItems) {
-    prefixItems.collectExternalIds = collectExternalIdsFromArrayOfSchemas;
-  }
-
-  const properties = getKeyword("https://json-schema.org/keyword/properties");
-  if (properties) {
-    properties.collectExternalIds = collectExternalIdsFromObjectOfSchemas;
-  }
-
-  const propertyNames = getKeyword("https://json-schema.org/keyword/propertyNames");
-  if (propertyNames) {
-    propertyNames.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  const ref = getKeyword("https://json-schema.org/keyword/ref");
-  if (ref) {
-    ref.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  const unevaluatedItems = getKeyword("https://json-schema.org/keyword/unevaluatedItems");
-  if (unevaluatedItems) {
-    unevaluatedItems.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  const unevaluatedProperties = getKeyword("https://json-schema.org/keyword/unevaluatedProperties");
-  if (unevaluatedProperties) {
-    unevaluatedProperties.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  // Draft-04
-
-  const additionalItems4 = getKeyword("https://json-schema.org/keyword/draft-04/additionalItems");
-  if (additionalItems4) {
-    additionalItems4.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  const dependencies = getKeyword("https://json-schema.org/keyword/draft-04/dependencies");
-  if (dependencies) {
-    dependencies.collectExternalIds = (visited, parentSchema, schema) => pipe(
-      Browser.values(schema),
-      asyncFilter((subSchema) => Browser.typeOf(subSchema) === "object"),
-      asyncMap(Validation.collectExternalIds(visited, parentSchema)),
-      asyncFlatten,
-      asyncCollectSet
-    );
-  }
-
-  const items4 = getKeyword("https://json-schema.org/keyword/draft-04/items");
-  if (items4) {
-    items4.collectExternalIds = (visited, parentSchema, schema) => Browser.typeOf(schema) === "array"
-      ? collectExternalIdsFromArrayOfSchemas(visited, parentSchema, schema)
-      : Validation.collectExternalIds(visited, parentSchema, schema);
-  }
-
-  // Draft-06
-
-  const contains6 = getKeyword("https://json-schema.org/keyword/draft-06/contains");
-  if (contains6) {
-    contains6.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  // Draft-2019-09
-
-  const contains19 = getKeyword("https://json-schema.org/keyword/draft-2019-09/contains");
-  if (contains19) {
-    contains19.collectExternalIds = Validation.collectExternalIds;
-  }
-
-  // Extensions
-
-  const propertyDependencies = getKeyword("https://json-schema.org/keyword/propertyDependencies");
-  if (propertyDependencies) {
-    propertyDependencies.collectExternalIds = (visited, parentSchema, schema) => pipe(
-      Browser.values(schema),
-      asyncMap((mapping) => Browser.values(mapping)),
-      asyncFlatten,
-      asyncMap(Validation.collectExternalIds(visited, parentSchema)),
-      asyncFlatten,
-      asyncCollectSet
-    );
-  }
-
-  const conditional = getKeyword("https://json-schema.org/keyword/conditional");
-  if (conditional) {
-    conditional.collectExternalIds = collectExternalIdsFromArrayOfSchemas;
-  }
-
-  const itemPattern = getKeyword("https://json-schema.org/keyword/itemPattern");
-  if (itemPattern) {
-    itemPattern.collectExternalIds = (visited, parentSchema, schema) => pipe(
-      Browser.iter(schema),
-      asyncFilter((item) => Browser.typeOf(item) === "object"),
-      asyncMap(Validation.collectExternalIds(visited, parentSchema)),
-      asyncFlatten,
-      asyncCollectSet
-    );
+const allReferences = function* (node) {
+  switch (jrefTypeOf(node)) {
+    case "object":
+      for (const property in node) {
+        yield* allReferences(node[property]);
+      }
+      break;
+    case "array":
+      for (const item of node) {
+        yield* allReferences(item);
+      }
+      break;
+    case "reference":
+      yield node;
+      break;
   }
 };

package/draft-04/additionalItems.js

@@ -1,4 +1,4 @@
-import { pipe, drop, every } from "@hyperjump/pact";
+import { drop } from "@hyperjump/pact";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../lib/instance.js";
 import { getKeywordName, Validation } from "../lib/experimental.js";
@@ -19,26 +19,20 @@ const interpret = ([numberOfItems, additionalItems], instance, context) => {
     return true;
   }
 
-  return pipe(
-    Instance.iter(instance),
-    drop(numberOfItems),
-    every((item) => Validation.interpret(additionalItems, item, context))
-  );
-};
-
-const simpleApplicator = true;
+  let isValid = true;
+  let index = numberOfItems;
+  for (const item of drop(numberOfItems, Instance.iter(instance))) {
+    if (!Validation.interpret(additionalItems, item, context)) {
+      isValid = false;
+    }
 
-const collectEvaluatedItems = (keywordValue, instance, context) => {
-  if (!interpret(keywordValue, instance, context)) {
-    return false;
+    context.evaluatedItems?.add(index);
+    index++;
   }
 
-  const evaluatedIndexes = new Set();
-  for (let ndx = keywordValue[0]; ndx < Instance.length(instance); ndx++) {
-    evaluatedIndexes.add(ndx);
-  }
-
-  return evaluatedIndexes;
+  return isValid;
 };
 
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedItems };
+const simpleApplicator = true;
+
+export default { id, compile, interpret, simpleApplicator };

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-04/items.js

@@ -1,4 +1,4 @@
-import { pipe, asyncMap, asyncCollectArray, every, zip, take, range, collectSet } from "@hyperjump/pact";
+import { pipe, asyncMap, asyncCollectArray, zip } from "@hyperjump/pact";
 import * as Browser from "@hyperjump/browser";
 import * as Instance from "../lib/instance.js";
 import { Validation } from "../lib/experimental.js";
@@ -23,23 +23,35 @@ const interpret = (items, instance, context) => {
     return true;
   }
 
+  let isValid = true;
+  let index = 0;
+
   if (typeof items === "string") {
-    return every((itemValue) => Validation.interpret(items, itemValue, context), Instance.iter(instance));
+    for (const item of Instance.iter(instance)) {
+      if (!Validation.interpret(items, item, context)) {
+        isValid = false;
+      }
+
+      context.evaluatedItems?.add(index++);
+    }
   } else {
-    return pipe(
-      zip(items, Instance.iter(instance)),
-      take(Instance.length(instance)),
-      every(([prefixItem, item]) => Validation.interpret(prefixItem, item, context))
-    );
+    for (const [tupleItem, tupleInstance] of zip(items, Instance.iter(instance))) {
+      if (!tupleInstance) {
+        break;
+      }
+
+      if (!Validation.interpret(tupleItem, tupleInstance, context)) {
+        isValid = false;
+      }
+
+      context.evaluatedItems?.add(index);
+      index++;
+    }
   }
+
+  return isValid;
 };
 
 const simpleApplicator = true;
 
-const collectEvaluatedItems = (items, instance, context) => {
-  return interpret(items, instance, context) && (typeof items === "string"
-    ? collectSet(range(0, Instance.length(instance)))
-    : collectSet(range(0, items.length)));
-};
-
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator };

package/draft-2020-12/dynamicRef.js

@@ -1,6 +1,6 @@
 import * as Browser from "@hyperjump/browser";
 import { Validation, canonicalUri } from "../lib/experimental.js";
-import { uriFragment } from "../lib/common.js";
+import { toAbsoluteUri, uriFragment } from "../lib/common.js";
 
 
 const id = "https://json-schema.org/keyword/draft-2020-12/dynamicRef";
@@ -12,19 +12,31 @@ const compile = async (dynamicRef, ast) => {
   return [referencedSchema.document.baseUri, fragment, canonicalUri(referencedSchema)];
 };
 
-const evaluate = (strategy, [id, fragment, ref], instance, context) => {
+const interpret = ([id, fragment, ref], instance, context) => {
   if (fragment in context.ast.metaData[id].dynamicAnchors) {
     context.dynamicAnchors = { ...context.ast.metaData[id].dynamicAnchors, ...context.dynamicAnchors };
-    return strategy(context.dynamicAnchors[fragment], instance, context);
+    return Validation.interpret(context.dynamicAnchors[fragment], instance, context);
   } else {
-    return strategy(ref, instance, context);
+    return Validation.interpret(ref, instance, context);
   }
 };
 
 const simpleApplicator = true;
 
-const interpret = (...args) => evaluate(Validation.interpret, ...args);
-const collectEvaluatedProperties = (...args) => evaluate(Validation.collectEvaluatedProperties, ...args);
-const collectEvaluatedItems = (...args) => evaluate(Validation.collectEvaluatedItems, ...args);
+const plugin = {
+  beforeSchema(url, _instance, context) {
+    context.dynamicAnchors = {
+      ...context.ast.metaData[toAbsoluteUri(url)].dynamicAnchors,
+      ...context.dynamicAnchors
+    };
+  },
+  beforeKeyword(_url, _instance, context, schemaContext) {
+    context.dynamicAnchors = schemaContext.dynamicAnchors;
+  },
+  afterKeyword() {
+  },
+  afterSchema() {
+  }
+};
 
-export default { id, compile, interpret, simpleApplicator, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, simpleApplicator, plugin };