@hyperjump/json-schema 1.3.0 → 1.4.0

package/lib/keywords/patternProperties.js

@@ -12,16 +12,33 @@ const compile = (schema, ast) => Pact.pipeline([
   Pact.all
 ], schema);
 
-const interpret = (patternProperties, instance, ast, dynamicAnchors) => {
+const interpret = (patternProperties, instance, ast, dynamicAnchors, quiet) => {
   return !Instance.typeOf(instance, "object") || patternProperties.every(([pattern, schemaUrl]) => {
     return Instance.entries(instance)
       .filter(([propertyName]) => pattern.test(propertyName))
-      .every(([, propertyValue]) => Validation.interpret(schemaUrl, propertyValue, ast, dynamicAnchors));
+      .every(([, propertyValue]) => Validation.interpret(schemaUrl, propertyValue, ast, dynamicAnchors, quiet));
   });
 };
 
 const collectEvaluatedProperties = (patternProperties, instance, ast, dynamicAnchors) => {
-  return interpret(patternProperties, instance, ast, dynamicAnchors) && patternProperties.map(([pattern]) => pattern);
+  if (!Instance.typeOf(instance, "object")) {
+    return false;
+  }
+
+  const evaluatedPropertyNames = new Set();
+  for (const [pattern, propertySchema] of patternProperties) {
+    for (const [propertyName, property] of Instance.entries(instance)) {
+      if (pattern.test(propertyName)) {
+        if (!Validation.interpret(propertySchema, property, ast, dynamicAnchors, true)) {
+          return false;
+        }
+
+        evaluatedPropertyNames.add(propertyName);
+      }
+    }
+  }
+
+  return evaluatedPropertyNames;
 };
 
 export default { id, compile, interpret, collectEvaluatedProperties };

package/lib/keywords/prefixItems.js

@@ -13,16 +13,16 @@ const compile = (schema, ast) => {
   ], schema);
 };
 
-const interpret = (items, instance, ast, dynamicAnchors) => {
+const interpret = (items, instance, ast, dynamicAnchors, quiet) => {
   if (!Instance.typeOf(instance, "array")) {
     return true;
   }
 
-  return Instance.every((item, ndx) => !(ndx in items) || Validation.interpret(items[ndx], item, ast, dynamicAnchors), instance);
+  return Instance.every((item, ndx) => !(ndx in items) || Validation.interpret(items[ndx], item, ast, dynamicAnchors, quiet), instance);
 };
 
 const collectEvaluatedItems = (items, instance, ast, dynamicAnchors) => {
-  return interpret(items, instance, ast, dynamicAnchors) && new Set(items.map((item, ndx) => ndx));
+  return interpret(items, instance, ast, dynamicAnchors, true) && new Set(items.map((item, ndx) => ndx));
 };
 
 export default { id, compile, interpret, collectEvaluatedItems };

package/lib/keywords/properties.js

@@ -14,17 +14,29 @@ const compile = (schema, ast) => Pact.pipeline([
   }, Object.create(null))
 ], schema);
 
-const interpret = (properties, instance, ast, dynamicAnchors) => {
+const interpret = (properties, instance, ast, dynamicAnchors, quiet) => {
   return !Instance.typeOf(instance, "object") || Instance.entries(instance)
     .filter(([propertyName]) => propertyName in properties)
-    .every(([propertyName, schemaUrl]) => Validation.interpret(properties[propertyName], schemaUrl, ast, dynamicAnchors));
+    .every(([propertyName, schemaUrl]) => Validation.interpret(properties[propertyName], schemaUrl, ast, dynamicAnchors, quiet));
 };
 
 const collectEvaluatedProperties = (properties, instance, ast, dynamicAnchors) => {
-  return interpret(properties, instance, ast, dynamicAnchors) && Object.keys(properties)
-    .map((propertyName) => new RegExp(`^${escapeRegExp(propertyName)}$`));
-};
+  if (!Instance.typeOf(instance, "object")) {
+    return false;
+  }
+
+  const evaluatedPropertyNames = new Set();
+  for (const [propertyName, property] of Instance.entries(instance)) {
+    if (propertyName in properties) {
+      if (!Validation.interpret(properties[propertyName], property, ast, dynamicAnchors, true)) {
+        return false;
+      }
 
-const escapeRegExp = (string) => string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
+      evaluatedPropertyNames.add(propertyName);
+    }
+  }
+
+  return evaluatedPropertyNames;
+};
 
 export default { id, compile, interpret, collectEvaluatedProperties };

package/lib/keywords/propertyDependencies.js

@@ -23,12 +23,12 @@ const compile = (schema, ast) => {
   ], schema);
 };
 
-const interpret = (propertyDependencies, instance, ast, dynamicAnchors) => {
+const interpret = (propertyDependencies, instance, ast, dynamicAnchors, quiet) => {
   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);
+      || Validation.interpret(valueMappings[propertyValue], instance, ast, dynamicAnchors, quiet);
   });
 };
 

package/lib/keywords/propertyNames.js

@@ -8,7 +8,7 @@ const compile = (schema, ast) => Validation.compile(schema, ast);
 
 const interpret = (propertyNames, instance, ast, dynamicAnchors) => {
   return !Instance.typeOf(instance, "object") || Instance.keys(instance)
-    .every((key) => Validation.interpret(propertyNames, Instance.cons(key), ast, dynamicAnchors));
+    .every((key) => Validation.interpret(propertyNames, Instance.cons(key), ast, dynamicAnchors, true));
 };
 
 export default { id, compile, interpret };

package/lib/keywords/then.js

@@ -1,5 +1,5 @@
 import * as Schema from "../schema.js";
-import { getKeywordName, getKeyword } from "../keywords.js";
+import { getKeywordName } from "../keywords.js";
 import Validation from "./validation.js";
 
 
@@ -15,33 +15,26 @@ const compile = async (schema, ast, parentSchema) => {
   }
 };
 
-const interpret = ([guard, block], instance, ast, dynamicAnchors) => {
-  return guard === undefined || !quietInterpretSchema(guard, instance, ast, dynamicAnchors) || Validation.interpret(block, instance, ast, dynamicAnchors);
+const interpret = ([ifSchema, thenSchema], instance, ast, dynamicAnchors, quiet) => {
+  return ifSchema === undefined
+    || !Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true)
+    || Validation.interpret(thenSchema, instance, ast, dynamicAnchors, quiet);
 };
 
-// Interpret a schema without events being emitted
-const quietInterpretSchema = (url, instance, ast, dynamicAnchors) => {
-  const nodes = ast[url][2];
-
-  return typeof nodes === "boolean" ? nodes : nodes.every(([keywordId, , keywordValue]) => {
-    return getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
-  });
-};
-
-const collectEvaluatedProperties = ([guard, block], instance, ast, dynamicAnchors) => {
-  if (guard === undefined || !quietInterpretSchema(guard, instance, ast, dynamicAnchors)) {
-    return [];
+const collectEvaluatedProperties = ([ifSchema, thenSchema], instance, ast, dynamicAnchors) => {
+  if (ifSchema === undefined || !Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true)) {
+    return new Set();
   }
 
-  return Validation.collectEvaluatedProperties(block, instance, ast, dynamicAnchors);
+  return Validation.collectEvaluatedProperties(thenSchema, instance, ast, dynamicAnchors);
 };
 
-const collectEvaluatedItems = ([guard, block], instance, ast, dynamicAnchors) => {
-  if (guard === undefined || !quietInterpretSchema(guard, instance, ast, dynamicAnchors)) {
+const collectEvaluatedItems = ([ifSchema, thenSchema], instance, ast, dynamicAnchors) => {
+  if (ifSchema === undefined || !Validation.interpret(ifSchema, instance, ast, dynamicAnchors, true)) {
     return new Set();
   }
 
-  return Validation.collectEvaluatedItems(block, instance, ast, dynamicAnchors);
+  return Validation.collectEvaluatedItems(thenSchema, instance, ast, dynamicAnchors);
 };
 
 export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/unevaluatedItems.js

@@ -9,14 +9,14 @@ const compile = async (schema, ast, parentSchema) => {
   return [Schema.uri(parentSchema), await Validation.compile(schema, ast)];
 };
 
-const interpret = ([schemaUrl, unevaluatedItems], instance, ast, dynamicAnchors) => {
+const interpret = ([schemaUrl, unevaluatedItems], instance, ast, dynamicAnchors, quiet) => {
   if (!Instance.typeOf(instance, "array")) {
     return true;
   }
 
   const itemIndexes = Validation.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors, true);
   return itemIndexes === false || Instance.every((item, itemIndex) => {
-    return itemIndexes.has(itemIndex) || Validation.interpret(unevaluatedItems, Instance.step(itemIndex, instance), ast, dynamicAnchors);
+    return itemIndexes.has(itemIndex) || Validation.interpret(unevaluatedItems, Instance.step(itemIndex, instance), ast, dynamicAnchors, quiet);
   }, instance);
 };
 

package/lib/keywords/unevaluatedProperties.js

@@ -9,7 +9,7 @@ const compile = async (schema, ast, parentSchema) => {
   return [Schema.uri(parentSchema), await Validation.compile(schema, ast)];
 };
 
-const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnchors) => {
+const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnchors, quiet) => {
   if (!Instance.typeOf(instance, "object")) {
     return true;
   }
@@ -17,12 +17,32 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnc
   const evaluatedPropertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors, true);
 
   return !evaluatedPropertyNames || Instance.entries(instance)
-    .filter(([propertyName]) => !evaluatedPropertyNames.some((pattern) => propertyName.match(pattern)))
-    .every(([, property]) => Validation.interpret(unevaluatedProperties, property, ast, dynamicAnchors));
+    .filter(([propertyName]) => !evaluatedPropertyNames.has(propertyName))
+    .every(([, property]) => Validation.interpret(unevaluatedProperties, property, ast, dynamicAnchors, quiet));
 };
 
-const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors) => {
-  return interpret(keywordValue, instance, ast, dynamicAnchors) && [new RegExp("")];
+const collectEvaluatedProperties = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "object")) {
+    return true;
+  }
+
+  const evaluatedPropertyNames = Validation.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors, true);
+
+  if (!evaluatedPropertyNames) {
+    return false;
+  }
+
+  for (const [propertyName, property] of Instance.entries(instance)) {
+    if (!evaluatedPropertyNames.has(propertyName)) {
+      if (!Validation.interpret(unevaluatedProperties, property, ast, dynamicAnchors, true)) {
+        return false;
+      }
+
+      evaluatedPropertyNames.add(propertyName);
+    }
+  }
+
+  return evaluatedPropertyNames;
 };
 
 export default { id, compile, interpret, collectEvaluatedProperties };

package/lib/keywords/validation.js

@@ -30,78 +30,70 @@ const compile = async (schema, ast) => {
       throw Error(`No schema found at '${url}'`);
     }
 
-    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 ${url}`);
-          }
-
-          const keywordHandler = getKeyword(keywordId);
-          if (!keywordHandler) {
-            throw Error(`Encountered unsupported keyword ${keyword} at '${url}'. You can provide an implementation for the '${keywordId}' keyword using the 'addKeyword' function.`);
-          }
-          if (keywordHandler.experimental && !isExperimentalKeywordEnabled(keywordId)) {
-            throw Error(`Encountered experimental keyword ${keyword} at '${url}'. 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)
-    ];
+    ast[url] = 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 ${url}`);
+        }
+
+        const keywordHandler = getKeyword(keywordId);
+        if (!keywordHandler) {
+          throw Error(`Encountered unsupported keyword ${keyword} at '${url}'. You can provide an implementation for the '${keywordId}' keyword using the 'addKeyword' function.`);
+        }
+        if (keywordHandler.experimental && !isExperimentalKeywordEnabled(keywordId)) {
+          throw Error(`Encountered experimental keyword ${keyword} at '${url}'. 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];
-
+const interpret = (url, instance, ast, dynamicAnchors, quiet = false) => {
   dynamicAnchors = { ...ast.metaData[toAbsoluteUri(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);
+  !quiet && publish("result.start");
+  const isValid = typeof ast[url] === "boolean" ? ast[url] : ast[url].every(([keywordId, schemaUrl, keywordValue]) => {
+    !quiet && publish("result.start");
+    const isValid = getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors, quiet);
 
-    publish("result", {
+    !quiet && publish("result", {
       keyword: keywordId,
       absoluteKeywordLocation: schemaUrl,
       instanceLocation: Instance.uri(instance),
       valid: isValid,
       ast: keywordValue
     });
-    publish("result.end");
+    !quiet && publish("result.end");
     return isValid;
   });
 
-  publish("result", {
-    keyword: keywordId,
-    absoluteKeywordLocation: schemaUrl,
+  !quiet && publish("result", {
+    keyword: id,
+    absoluteKeywordLocation: url,
     instanceLocation: Instance.uri(instance),
     valid: isValid,
     ast: url
   });
-  publish("result.end");
+  !quiet && publish("result.end");
   return isValid;
 };
 
-const emptyPropertyNames = [];
+const emptyPropertyNames = new Set();
 const collectEvaluatedProperties = (url, instance, ast, dynamicAnchors, isTop = false) => {
-  const nodes = ast[url][2];
-
-  if (typeof nodes === "boolean") {
-    return nodes ? [] : false;
+  if (typeof ast[url] === "boolean") {
+    return ast[url] ? [] : false;
   }
 
-  const accumulatedPropertyNames = [];
-  for (const [keywordId, , keywordValue] of nodes) {
+  const accumulatedPropertyNames = new Set();
+  for (const [keywordId, , keywordValue] of ast[url]) {
     if (isTop && keywordId === "https://json-schema.org/keyword/unevaluatedProperties") {
       continue;
     }
@@ -109,13 +101,13 @@ const collectEvaluatedProperties = (url, instance, ast, dynamicAnchors, isTop =
     const keywordHandler = getKeyword(keywordId);
     const propertyNames = "collectEvaluatedProperties" in keywordHandler
       ? keywordHandler.collectEvaluatedProperties(keywordValue, instance, ast, dynamicAnchors, isTop)
-      : keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, isTop) && emptyPropertyNames;
+      : keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, true) && emptyPropertyNames;
 
     if (propertyNames === false) {
       return false;
     }
 
-    Array.prototype.push.apply(accumulatedPropertyNames, propertyNames);
+    propertyNames.forEach(Set.prototype.add.bind(accumulatedPropertyNames));
   }
 
   return accumulatedPropertyNames;
@@ -123,14 +115,12 @@ const collectEvaluatedProperties = (url, instance, ast, dynamicAnchors, isTop =
 
 const emptyItemIndexes = new Set();
 const collectEvaluatedItems = (url, instance, ast, dynamicAnchors, isTop = false) => {
-  const nodes = ast[url][2];
-
-  if (typeof nodes === "boolean") {
-    return nodes ? new Set() : false;
+  if (typeof ast[url] === "boolean") {
+    return ast[url] ? new Set() : false;
   }
 
   const accumulatedItemIndexes = new Set();
-  for (const [keywordId, , keywordValue] of nodes) {
+  for (const [keywordId, , keywordValue] of ast[url]) {
     if (isTop && keywordId === "https://json-schema.org/keyword/unevaluatedItems") {
       continue;
     }
@@ -138,7 +128,7 @@ const collectEvaluatedItems = (url, instance, ast, dynamicAnchors, isTop = false
     const keywordHandler = getKeyword(keywordId);
     const itemIndexes = "collectEvaluatedItems" in keywordHandler
       ? keywordHandler.collectEvaluatedItems(keywordValue, instance, ast, dynamicAnchors, isTop)
-      : keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, isTop) && emptyItemIndexes;
+      : keywordHandler.interpret(keywordValue, instance, ast, dynamicAnchors, true) && emptyItemIndexes;
 
     if (itemIndexes === false) {
       return false;

package/lib/keywords.js

@@ -39,7 +39,7 @@ export const loadDialect = (dialectId, dialect, allowUnknownKeywords = false) =>
             }
             _dialects[dialectId][keyword] = keywordId;
           });
-      } else {
+      } else if (!allowUnknownKeywords || isRequired) {
         delete _dialects[dialectId];
         throw Error(`Unrecognized vocabulary: ${vocabularyId}. You can define this vocabulary with the 'defineVocabulary' function.`);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "A JSON Schema validator with support for custom keywords, vocabularies, and dialects",
   "type": "module",
   "main": "./stable/index.js",
@@ -16,6 +16,8 @@
     "./experimental": "./lib/experimental.js",
     "./schema/experimental": "./lib/schema.js",
     "./instance/experimental": "./lib/instance.js",
+    "./annotations/experimental": "./annotations/index.js",
+    "./annotated-instance/experimental": "./annotations/annotated-instance.js",
     "./bundle": "./bundle/index.js"
   },
   "browser": {
@@ -24,7 +26,7 @@
   "scripts": {
     "clean": "xargs -a .gitignore rm -rf",
     "lint": "eslint lib stable draft-* openapi-*",
-    "test": "mocha 'lib/**/*.spec.ts' 'stable/**/*.spec.ts' 'draft-*/**/*.spec.ts' 'openapi-*/**/*.spec.ts' 'bundle/**/*.spec.ts'"
+    "test": "mocha 'lib/**/*.spec.ts' 'stable/**/*.spec.ts' 'draft-*/**/*.spec.ts' 'openapi-*/**/*.spec.ts' 'bundle/**/*.spec.ts' 'annotations/**/*.spec.ts'"
   },
   "repository": "github:hyperjump-io/json-schema",
   "keywords": [