@hyperjump/json-schema 1.12.1 → 1.14.0

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
@@ -800,7 +794,7 @@ following functions are available in addition to the functions available in the
 * **annotation**: (instance: JsonNode, keyword: string, dialect?: string): any[];
 
     Get the annotations for a keyword for the value represented by the JsonNode.
-* **annotatedWith**: (instance: JsonNode, keyword: string, dialect?: string): JsonNode[];
+* **annotatedWith**: (instance: JsonNode, keyword: string, dialect?: string): Generator<JsonNode>;
 
     Get all JsonNodes that are annotated with the given keyword.
 * **setAnnotation**: (instance: JsonNode, keywordId: string, value: any) => JsonNode

package/annotations/annotated-instance.d.ts

@@ -1,4 +1,4 @@
 export const annotation: <A>(instance: JsonNode, keyword: string, dialectUri?: string) => A[];
-export const annotatedWith: <A extends JsonNode>(instance: A, keyword: string, dialectUri?: string) => A[];
+export const annotatedWith: <A extends JsonNode>(instance: A, keyword: string, dialectUri?: string) => Generator<A>;
 
 export * from "../lib/instance.js";

package/annotations/annotated-instance.js

@@ -1,4 +1,3 @@
-import * as JsonPointer from "@hyperjump/json-pointer";
 import * as Instance from "../lib/instance.js";
 import { getKeywordId } from "../lib/keywords.js";
 
@@ -7,43 +6,15 @@ const defaultDialectId = "https://json-schema.org/validation";
 
 export const annotation = (node, keyword, dialect = defaultDialectId) => {
   const keywordUri = getKeywordId(keyword, dialect);
-
-  let currentNode = node.root;
-  const errors = [...invalidSchemas(currentNode)];
-  for (let segment of JsonPointer.pointerSegments(node.pointer)) {
-    segment = segment === "-" && Instance.typeOf(currentNode) === "array" ? Instance.length(currentNode) : segment;
-    currentNode = Instance.step(segment, currentNode);
-    errors.push(...invalidSchemas(currentNode));
-  }
-
-  const annotations = [];
-  for (const schemaLocation in node.annotations[keywordUri]) {
-    if (!errors.some((error) => schemaLocation.startsWith(error))) {
-      annotations.unshift(node.annotations[keywordUri][schemaLocation]);
-    }
-  }
-
-  return annotations;
+  return node.annotations[keywordUri] ?? [];
 };
 
-const invalidSchemas = function* (node) {
-  for (const error in node.errors) {
-    if (node.errors[error] === "https://json-schema.org/evaluation/validate") {
-      yield error;
-    }
-  }
-};
-
-export const annotatedWith = (instance, keyword, dialectId = defaultDialectId) => {
-  const nodes = [];
-
+export const annotatedWith = function* (instance, keyword, dialectId = defaultDialectId) {
   for (const node of Instance.allNodes(instance)) {
     if (annotation(node, keyword, dialectId).length > 0) {
-      nodes.push(node);
+      yield node;
     }
   }
-
-  return nodes;
 };
 
 export * from "../lib/instance.js";

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/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/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 };