@hyperjump/json-schema 0.23.4 → 1.0.0

package/lib/keywords/oneOf.js

@@ -1,15 +1,18 @@
-const { Core, Schema } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import Validation from "./validation.js";
 
 
+const id = "https://json-schema.org/keyword/oneOf";
+
 const compile = async (schema, ast) => {
-  const oneOf = await Schema.map((itemSchema) => Core.compileSchema(itemSchema, ast), schema);
+  const oneOf = await Schema.map((itemSchema) => Validation.compile(itemSchema, ast), schema);
   return Promise.all(oneOf);
 };
 
 const interpret = (oneOf, instance, ast, dynamicAnchors) => {
   let validCount = 0;
   for (const schemaUrl of oneOf) {
-    if (Core.interpretSchema(schemaUrl, instance, ast, dynamicAnchors)) {
+    if (Validation.interpret(schemaUrl, instance, ast, dynamicAnchors)) {
       validCount++;
     }
 
@@ -28,7 +31,7 @@ const collectEvaluatedProperties = (oneOf, instance, ast, dynamicAnchors) => {
       return false;
     }
 
-    const propertyNames = Core.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
+    const propertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
     return propertyNames ? validCount++ === 0 && propertyNames : acc;
   }, false);
 };
@@ -40,9 +43,9 @@ const collectEvaluatedItems = (oneOf, instance, ast, dynamicAnchors) => {
       return false;
     }
 
-    const itemIndexes = Core.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
+    const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
     return itemIndexes ? validCount++ === 0 && itemIndexes : acc;
   }, false);
 };
 
-module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/pattern.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/pattern";
+
 const compile = (schema) => new RegExp(Schema.value(schema), "u");
 const interpret = (pattern, instance) => !Instance.typeOf(instance, "string") || pattern.test(Instance.value(instance));
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/patternProperties.js

@@ -1,10 +1,14 @@
-const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
-const Pact = require("@hyperjump/pact");
+import * as Pact from "@hyperjump/pact";
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
+import Validation from "./validation.js";
 
 
+const id = "https://json-schema.org/keyword/patternProperties";
+
 const compile = (schema, ast) => Pact.pipeline([
   Schema.entries,
-  Pact.map(async ([pattern, propertySchema]) => [new RegExp(pattern, "u"), await Core.compileSchema(propertySchema, ast)]),
+  Pact.map(async ([pattern, propertySchema]) => [new RegExp(pattern, "u"), await Validation.compile(propertySchema, ast)]),
   Pact.all
 ], schema);
 
@@ -12,7 +16,7 @@ const interpret = (patternProperties, instance, ast, dynamicAnchors) => {
   return !Instance.typeOf(instance, "object") || patternProperties.every(([pattern, schemaUrl]) => {
     return Instance.entries(instance)
       .filter(([propertyName]) => pattern.test(propertyName))
-      .every(([, propertyValue]) => Core.interpretSchema(schemaUrl, propertyValue, ast, dynamicAnchors));
+      .every(([, propertyValue]) => Validation.interpret(schemaUrl, propertyValue, ast, dynamicAnchors));
   });
 };
 
@@ -20,4 +24,4 @@ const collectEvaluatedProperties = (patternProperties, instance, ast, dynamicAnc
   return interpret(patternProperties, instance, ast, dynamicAnchors) && patternProperties.map(([pattern]) => pattern);
 };
 
-module.exports = { compile, interpret, collectEvaluatedProperties };
+export default { id, compile, interpret, collectEvaluatedProperties };

package/lib/keywords/prefixItems.js

@@ -0,0 +1,28 @@
+import * as Pact from "@hyperjump/pact";
+import * as Instance from "../instance.js";
+import * as Schema from "../schema.js";
+import Validation from "./validation.js";
+
+
+const id = "https://json-schema.org/keyword/prefixItems";
+
+const compile = (schema, ast) => {
+  return Pact.pipeline([
+    Schema.map((itemSchema) => Validation.compile(itemSchema, ast)),
+    Pact.all
+  ], schema);
+};
+
+const interpret = (items, instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "array")) {
+    return true;
+  }
+
+  return Instance.every((item, ndx) => !(ndx in items) || Validation.interpret(items[ndx], item, ast, dynamicAnchors), instance);
+};
+
+const collectEvaluatedItems = (items, instance, ast, dynamicAnchors) => {
+  return interpret(items, instance, ast, dynamicAnchors) && new Set(items.map((item, ndx) => ndx));
+};
+
+export default { id, compile, interpret, collectEvaluatedItems };

package/lib/keywords/properties.js

@@ -1,12 +1,15 @@
-const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
-const Pact = require("@hyperjump/pact");
-const { escapeRegExp } = require("../common");
+import * as Pact from "@hyperjump/pact";
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
+import Validation from "./validation.js";
 
 
+const id = "https://json-schema.org/keyword/properties";
+
 const compile = (schema, ast) => Pact.pipeline([
   Schema.entries,
   Pact.reduce(async (acc, [propertyName, propertySchema]) => {
-    acc[propertyName] = await Core.compileSchema(propertySchema, ast);
+    acc[propertyName] = await Validation.compile(propertySchema, ast);
     return acc;
   }, Object.create(null))
 ], schema);
@@ -14,7 +17,7 @@ const compile = (schema, ast) => Pact.pipeline([
 const interpret = (properties, instance, ast, dynamicAnchors) => {
   return !Instance.typeOf(instance, "object") || Instance.entries(instance)
     .filter(([propertyName]) => propertyName in properties)
-    .every(([propertyName, schemaUrl]) => Core.interpretSchema(properties[propertyName], schemaUrl, ast, dynamicAnchors));
+    .every(([propertyName, schemaUrl]) => Validation.interpret(properties[propertyName], schemaUrl, ast, dynamicAnchors));
 };
 
 const collectEvaluatedProperties = (properties, instance, ast, dynamicAnchors) => {
@@ -22,4 +25,6 @@ const collectEvaluatedProperties = (properties, instance, ast, dynamicAnchors) =
     .map((propertyName) => new RegExp(`^${escapeRegExp(propertyName)}$`));
 };
 
-module.exports = { compile, interpret, collectEvaluatedProperties };
+const escapeRegExp = (string) => string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+
+export default { id, compile, interpret, collectEvaluatedProperties };

package/lib/keywords/propertyDependencies.js

@@ -0,0 +1,49 @@
+import * as Pact from "@hyperjump/pact";
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
+import Validation from "./validation.js";
+
+
+const id = "https://json-schema.org/keyword/propertyDependencies";
+const experimental = true;
+
+const compile = async (schema, ast) => {
+  return Pact.pipeline([
+    Schema.entries,
+    Pact.reduce(async (propertyDependencies, [propertyName, valueMappings]) => {
+      propertyDependencies[propertyName] = await Pact.pipeline([
+        Schema.entries,
+        Pact.reduce(async (valueMappings, [propertyValue, conditionalSchema]) => {
+          valueMappings[propertyValue] = await Validation.compile(conditionalSchema, ast);
+          return valueMappings;
+        }, {})
+      ], valueMappings);
+      return propertyDependencies;
+    }, {})
+  ], schema);
+};
+
+const interpret = (propertyDependencies, instance, ast, dynamicAnchors) => {
+  return !Instance.typeOf(instance, "object") || Object.entries(propertyDependencies).every(([propertyName, valueMappings]) => {
+    const propertyValue = Instance.value(instance)[propertyName];
+    return !Instance.has(propertyName, instance)
+      || !(propertyValue in valueMappings)
+      || Validation.interpret(valueMappings[propertyValue], instance, ast, dynamicAnchors);
+  });
+};
+
+const collectEvaluatedProperties = (propertyDependencies, instance, ast, dynamicAnchors) => {
+  return Object.entries(propertyDependencies)
+    .reduce((acc, [propertyName, valueMappings]) => {
+      const propertyValue = Instance.value(instance)[propertyName];
+
+      if (Instance.has(propertyName, instance) && propertyValue in valueMappings) {
+        const propertyNames = Validation.collectEvaluatedProperties(valueMappings[propertyValue], instance, ast, dynamicAnchors);
+        return propertyNames !== false && acc.concat(propertyNames);
+      } else {
+        return acc;
+      }
+    }, []);
+};
+
+export default { id, experimental, compile, interpret, collectEvaluatedProperties };

package/lib/keywords/propertyNames.js

@@ -1,11 +1,14 @@
-const { Core, Instance } = require("@hyperjump/json-schema-core");
+import * as Instance from "../instance.js";
+import Validation from "./validation.js";
 
 
-const compile = (schema, ast) => Core.compileSchema(schema, ast);
+const id = "https://json-schema.org/keyword/propertyNames";
+
+const compile = (schema, ast) => Validation.compile(schema, ast);
 
 const interpret = (propertyNames, instance, ast, dynamicAnchors) => {
   return !Instance.typeOf(instance, "object") || Instance.keys(instance)
-    .every((key) => Core.interpretSchema(propertyNames, Instance.cons(key), ast, dynamicAnchors));
+    .every((key) => Validation.interpret(propertyNames, Instance.cons(key), ast, dynamicAnchors));
 };
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/readOnly.js

@@ -0,0 +1,4 @@
+import metaData from "./meta-data.js";
+
+
+export default { id: "https://json-schema.org/keyword/readOnly", ...metaData };

package/lib/keywords/ref.js

@@ -1,13 +1,16 @@
-const { Core, Schema } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import Validation from "./validation.js";
 
 
+const id = "https://json-schema.org/keyword/ref";
+
 const compile = async (ref, ast) => {
   const referencedSchema = await Schema.get(Schema.value(ref), ref);
-  return Core.compileSchema(referencedSchema, ast);
+  return Validation.compile(referencedSchema, ast);
 };
 
-const interpret = Core.interpretSchema;
-const collectEvaluatedProperties = Core.collectEvaluatedProperties;
-const collectEvaluatedItems = Core.collectEvaluatedItems;
+const interpret = Validation.interpret;
+const collectEvaluatedProperties = Validation.collectEvaluatedProperties;
+const collectEvaluatedItems = Validation.collectEvaluatedItems;
 
-module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/requireAllExcept.js

@@ -0,0 +1,24 @@
+import * as Instance from "../instance.js";
+import { getKeywordName } from "../keywords.js";
+import * as Schema from "../schema.js";
+
+
+const id = "https://json-schema.org/keyword/requireAllExcept";
+const experimental = true;
+
+const compile = async (schema, ast, parentSchema) => {
+  const requireAllExcept = await Schema.value(schema);
+  const propertiesKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/properties");
+  const propertiesSchema = await Schema.step(propertiesKeyword, parentSchema);
+  const propertyNames = Schema.typeOf(propertiesSchema, "object") ? Schema.keys(propertiesSchema) : [];
+
+  const required = new Set(propertyNames);
+  requireAllExcept.forEach((propertyName) => propertyNames.remove(propertyName));
+  return [...required];
+};
+
+const interpret = (required, instance) => {
+  return !Instance.typeOf(instance, "object") || required.every((propertyName) => Instance.value(instance).hasOwnProperty(propertyName));
+};
+
+export default { id, experimental, compile, interpret };

package/lib/keywords/required.js

@@ -1,10 +1,13 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/required";
+
 const compile = (schema) => Schema.value(schema);
 
 const interpret = (required, instance) => {
   return !Instance.typeOf(instance, "object") || required.every((propertyName) => Object.prototype.hasOwnProperty.call(Instance.value(instance), propertyName));
 };
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/then.js

@@ -1,26 +1,31 @@
-const { Core, Schema } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import { getKeywordName, getKeyword } from "../keywords.js";
+import Validation from "./validation.js";
 
 
+const id = "https://json-schema.org/keyword/then";
+
 const compile = async (schema, ast, parentSchema) => {
-  if (Schema.has("if", parentSchema)) {
-    const ifSchema = await Schema.step("if", parentSchema);
-    return [await Core.compileSchema(ifSchema, ast), await Core.compileSchema(schema, ast)];
+  const ifKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/if");
+  if (Schema.has(ifKeyword, parentSchema)) {
+    const ifSchema = await Schema.step(ifKeyword, parentSchema);
+    return [await Validation.compile(ifSchema, ast), await Validation.compile(schema, ast)];
   } else {
     return [];
   }
 };
 
 const interpret = ([guard, block], instance, ast, dynamicAnchors) => {
-  return guard === undefined || !quietInterpretSchema(guard, instance, ast, dynamicAnchors) || Core.interpretSchema(block, instance, ast, dynamicAnchors);
+  return guard === undefined || !quietInterpretSchema(guard, instance, ast, dynamicAnchors) || Validation.interpret(block, instance, ast, dynamicAnchors);
 };
 
 // Interpret a schema without events being emitted
-const quietInterpretSchema = (uri, instance, ast, dynamicAnchors) => {
-  const nodes = ast[uri][2];
+const quietInterpretSchema = (url, instance, ast, dynamicAnchors) => {
+  const nodes = ast[url][2];
 
   return typeof nodes === "boolean" ? nodes : nodes
     .every(([keywordId, , keywordValue]) => {
-      return Core.getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
+      return getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
     });
 };
 
@@ -29,7 +34,7 @@ const collectEvaluatedProperties = ([guard, block], instance, ast, dynamicAnchor
     return [];
   }
 
-  return Core.collectEvaluatedProperties(block, instance, ast, dynamicAnchors);
+  return Validation.collectEvaluatedProperties(block, instance, ast, dynamicAnchors);
 };
 
 const collectEvaluatedItems = ([guard, block], instance, ast, dynamicAnchors) => {
@@ -37,7 +42,7 @@ const collectEvaluatedItems = ([guard, block], instance, ast, dynamicAnchors) =>
     return new Set();
   }
 
-  return Core.collectEvaluatedItems(block, instance, ast, dynamicAnchors);
+  return Validation.collectEvaluatedItems(block, instance, ast, dynamicAnchors);
 };
 
-module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };
+export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/title.js

@@ -0,0 +1,4 @@
+import metaData from "./meta-data.js";
+
+
+export default { id: "https://json-schema.org/keyword/title", ...metaData };

package/lib/keywords/type.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/type";
+
 const compile = (schema) => Schema.value(schema);
 const interpret = (type, instance) => typeof type === "string" ? Instance.typeOf(instance, type) : type.some(Instance.typeOf(instance));
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/unevaluatedItems.js

@@ -1,8 +1,12 @@
-const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
+import Validation from "./validation.js";
 
 
+const id = "https://json-schema.org/keyword/unevaluatedItems";
+
 const compile = async (schema, ast, parentSchema) => {
-  return [Schema.uri(parentSchema), await Core.compileSchema(schema, ast)];
+  return [Schema.uri(parentSchema), await Validation.compile(schema, ast)];
 };
 
 const interpret = ([schemaUrl, unevaluatedItems], instance, ast, dynamicAnchors) => {
@@ -10,9 +14,9 @@ const interpret = ([schemaUrl, unevaluatedItems], instance, ast, dynamicAnchors)
     return true;
   }
 
-  const itemIndexes = Core.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors, true);
+  const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors, true);
   return itemIndexes === false || Instance.every((item, itemIndex) => {
-    return itemIndexes.has(itemIndex) || Core.interpretSchema(unevaluatedItems, Instance.step(itemIndex, instance), ast, dynamicAnchors);
+    return itemIndexes.has(itemIndex) || Validation.interpret(unevaluatedItems, Instance.step(itemIndex, instance), ast, dynamicAnchors);
   }, instance);
 };
 
@@ -20,4 +24,4 @@ const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
   return interpret(keywordValue, instance, ast, dynamicAnchors) && new Set(Instance.map((item, ndx) => ndx, instance));
 };
 
-module.exports = { compile, interpret, collectEvaluatedItems };
+export default { id, compile, interpret, collectEvaluatedItems };

package/lib/keywords/unevaluatedProperties.js

@@ -1,8 +1,12 @@
-const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
+import Validation from "./validation.js";
 
 
+const id = "https://json-schema.org/keyword/unevaluatedProperties";
+
 const compile = async (schema, ast, parentSchema) => {
-  return [Schema.uri(parentSchema), await Core.compileSchema(schema, ast)];
+  return [Schema.uri(parentSchema), await Validation.compile(schema, ast)];
 };
 
 const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnchors) => {
@@ -10,15 +14,15 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnc
     return true;
   }
 
-  const evaluatedPropertyNames = Core.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors, true);
+  const evaluatedPropertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors, true);
 
   return !evaluatedPropertyNames || Instance.entries(instance)
     .filter(([propertyName]) => !evaluatedPropertyNames.some((pattern) => propertyName.match(pattern)))
-    .every(([, property]) => Core.interpretSchema(unevaluatedProperties, property, ast, dynamicAnchors));
+    .every(([, property]) => Validation.interpret(unevaluatedProperties, property, ast, dynamicAnchors));
 };
 
 const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors) =>{
   return interpret(keywordValue, instance, ast, dynamicAnchors) && [new RegExp("")];
 };
 
-module.exports = { compile, interpret, collectEvaluatedProperties };
+export default { id, compile, interpret, collectEvaluatedProperties };

package/lib/keywords/uniqueItems.js

@@ -1,7 +1,10 @@
-const { Schema, Instance } = require("@hyperjump/json-schema-core");
-const jsonStringify = require("fastest-stable-stringify");
+import jsonStringify from "fastest-stable-stringify";
+import * as Schema from "../schema.js";
+import * as Instance from "../instance.js";
 
 
+const id = "https://json-schema.org/keyword/uniqueItems";
+
 const compile = (schema) => Schema.value(schema);
 
 const interpret = (uniqueItems, instance) => {
@@ -13,4 +16,4 @@ const interpret = (uniqueItems, instance) => {
   return new Set(normalizedItems).size === normalizedItems.length;
 };
 
-module.exports = { compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/validation.js

@@ -0,0 +1,123 @@
+import * as Pact from "@hyperjump/pact";
+import { publishAsync, publish } from "../pubsub.js";
+import { isExperimentalKeywordEnabled } from "../configuration.js";
+import * as Instance from "../instance.js";
+import { getKeywordId, getKeyword } from "../keywords.js";
+import { resolveUrl } from "../common.js";
+import * as Schema from "../schema.js";
+
+
+const id = "https://json-schema.org/evaluation/validate";
+
+const compile = async (schema, ast) => {
+  // Meta validation
+  await publishAsync("validate.metaValidate", schema);
+
+  // Dynamic Scope
+  if (!(schema.id in ast.metaData)) {
+    ast.metaData[schema.id] = {
+      dynamicAnchors: schema.dynamicAnchors
+    };
+  }
+
+  // Compile
+  const url = Schema.uri(schema);
+  if (!(url in ast)) {
+    ast[url] = false; // Place dummy entry in ast to avoid recursive loops
+
+    const schemaValue = Schema.value(schema);
+    if (!["object", "boolean"].includes(typeof schemaValue)) {
+      throw Error(`No schema found at '${Schema.uri(schema)}'`);
+    }
+
+    ast[url] = [
+      id,
+      Schema.uri(schema),
+      typeof schemaValue === "boolean" ? schemaValue : await Pact.pipeline([
+        Schema.entries,
+        Pact.map(async ([keyword, keywordSchema]) => {
+          const keywordId = getKeywordId(schema.dialectId, keyword);
+          if (!keywordId) {
+            throw Error(`Encountered unknown keyword '${keyword}' at ${Schema.uri(schema)}`);
+          }
+
+          const keywordHandler = getKeyword(keywordId);
+          if (keywordHandler.experimental && !isExperimentalKeywordEnabled(keywordId)) {
+            throw Error(`Encountered experimental keyword ${keyword} at '${Schema.uri(schema)}'. You can enable this keyword with: setExperimentalKeywordEnabled('${keywordId}', true)`);
+          }
+
+          const keywordAst = await keywordHandler.compile(keywordSchema, ast, schema);
+          return [keywordId, Schema.uri(keywordSchema), keywordAst];
+        }),
+        Pact.all
+      ], schema)
+    ];
+  }
+
+  return url;
+};
+
+const interpret = (url, instance, ast, dynamicAnchors) => {
+  const [keywordId, schemaUrl, nodes] = ast[url];
+
+  dynamicAnchors = { ...ast.metaData[resolveUrl("", url)].dynamicAnchors, ...dynamicAnchors };
+
+  publish("result.start");
+  const isValid = typeof nodes === "boolean" ? nodes : nodes
+    .every(([keywordId, schemaUrl, keywordValue]) => {
+      publish("result.start");
+      const isValid = getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
+
+      publish("result", {
+        keyword: keywordId,
+        absoluteKeywordLocation: schemaUrl,
+        instanceLocation: Instance.uri(instance),
+        valid: isValid,
+        ast: keywordValue
+      });
+      publish("result.end");
+      return isValid;
+    });
+
+  publish("result", {
+    keyword: keywordId,
+    absoluteKeywordLocation: schemaUrl,
+    instanceLocation: Instance.uri(instance),
+    valid: isValid,
+    ast: url
+  });
+  publish("result.end");
+  return isValid;
+};
+
+const collectEvaluatedProperties = (url, instance, ast, dynamicAnchors, isTop = false) => {
+  const nodes = ast[url][2];
+
+  if (typeof nodes === "boolean") {
+    return nodes ? [] : false;
+  }
+
+  return nodes
+    .filter(([keywordId]) => !isTop || keywordId !== "https://json-schema.org/keyword/unevaluatedProperties")
+    .reduce((acc, [keywordId, , keywordValue]) => {
+      const propertyNames = acc && getKeyword(keywordId).collectEvaluatedProperties(keywordValue, instance, ast, dynamicAnchors);
+      return propertyNames !== false && [...acc, ...propertyNames];
+    }, []);
+};
+
+const collectEvaluatedItems = (url, instance, ast, dynamicAnchors, isTop = false) => {
+  const nodes = ast[url][2];
+
+  if (typeof nodes === "boolean") {
+    return nodes ? new Set() : false;
+  }
+
+  return nodes
+    .filter(([keywordId]) => !isTop || keywordId !== "https://json-schema.org/keyword/unevaluatedItems")
+    .reduce((acc, [keywordId, , keywordValue]) => {
+      const itemIndexes = acc !== false && getKeyword(keywordId).collectEvaluatedItems(keywordValue, instance, ast, dynamicAnchors);
+      return itemIndexes !== false && new Set([...acc, ...itemIndexes]);
+    }, new Set());
+};
+
+export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/vocabulary.js

@@ -0,0 +1 @@
+export default { id: "https://json-schema.org/keyword/vocabulary" };

package/lib/keywords/writeOnly.js

@@ -0,0 +1,4 @@
+import metaData from "./meta-data.js";
+
+
+export default { id: "https://json-schema.org/keyword/writeOnly", ...metaData };

package/lib/keywords.d.ts

@@ -0,0 +1,19 @@
+import type { AST } from "./core.js";
+import type { JsonDocument } from "./instance.js";
+import type { SchemaDocument, Anchors } from "./schema.js";
+
+
+export const addKeyword: <A>(keywordHandler: Keyword<A>) => void;
+export const getKeywordName: (dialectId: string, keywordId: string) => string;
+export const getKeyword: <A>(id: string) => Keyword<A>;
+export const defineVocabulary: (id: string, keywords: { [keyword: string]: string }) => void;
+export const loadDialect: (dialectId: string, dialect: { [vocabularyId: string]: boolean }, allowUnknownKeywords?: boolean) => void;
+
+export type Keyword<A> = {
+  id: string;
+  experimental?: boolean;
+  compile: (schema: SchemaDocument, ast: AST, parentSchema: SchemaDocument) => Promise<A>;
+  interpret: (compiledKeywordValue: A, instance: JsonDocument, ast: AST, dynamicAnchors: Anchors) => boolean;
+  collectEvaluatedProperties?: (compiledKeywordValue: A, instance: JsonDocument, ast: AST, dynamicAnchors: Anchors, isTop?: boolean) => string[] | false;
+  collectEvaluatedItems?: (compiledKeywordValue: A, instance: JsonDocument, ast: AST, dynamicAnchors: Anchors, isTop?: boolean) => Set<number> | false;
+};