@hyperjump/json-schema 0.18.0

package/lib/keywords/maxProperties.js

@@ -0,0 +1,7 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = (schema) => Schema.value(schema);
+const interpret = (maxProperties, instance) => !Instance.typeOf(instance, "object") || Instance.keys(instance).length <= maxProperties;
+
+module.exports = { compile, interpret };

package/lib/keywords/maximum-exclusiveMaximum.js

@@ -0,0 +1,20 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema, ast, parentSchema) => {
+  const exclusiveMaximum = await Schema.step("exclusiveMaximum", parentSchema);
+  const isExclusive = Schema.value(exclusiveMaximum);
+
+  return [Schema.value(schema), isExclusive];
+};
+
+const interpret = ([maximum, isExclusive], instance) => {
+  if (!Instance.typeOf(instance, "number")) {
+    return true;
+  }
+
+  const value = Instance.value(instance);
+  return isExclusive ? value < maximum : value <= maximum;
+};
+
+module.exports = { compile, interpret };

package/lib/keywords/maximum.js

@@ -0,0 +1,7 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema) => Schema.value(schema);
+const interpret = (maximum, instance) => !Instance.typeOf(instance, "number") || Instance.value(instance) <= maximum;
+
+module.exports = { compile, interpret };

package/lib/keywords/minItems.js

@@ -0,0 +1,7 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = (schema) => Schema.value(schema);
+const interpret = (minItems, instance) => !Instance.typeOf(instance, "array") || Instance.length(instance) >= minItems;
+
+module.exports = { compile, interpret };

package/lib/keywords/minLength.js

@@ -0,0 +1,7 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = (schema) => Schema.value(schema);
+const interpret = (minLength, instance) => !Instance.typeOf(instance, "string") || Instance.length(instance) >= minLength;
+
+module.exports = { compile, interpret };

package/lib/keywords/minLength6.js

@@ -0,0 +1,7 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = (schema) => Schema.value(schema);
+const interpret = (minLength, instance) => !Instance.typeOf(instance, "string") || [...Instance.value(instance)].length >= minLength;
+
+module.exports = { compile, interpret };

package/lib/keywords/minProperties.js

@@ -0,0 +1,7 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = (schema) => Schema.value(schema);
+const interpret = (minProperties, instance) => !Instance.typeOf(instance, "object") || Instance.keys(instance).length >= minProperties;
+
+module.exports = { compile, interpret };

package/lib/keywords/minimum-exclusiveMinimum.js

@@ -0,0 +1,20 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema, ast, parentSchema) => {
+  const exclusiveMinimum = await Schema.step("exclusiveMinimum", parentSchema);
+  const isExclusive = Schema.value(exclusiveMinimum);
+
+  return [Schema.value(schema), isExclusive];
+};
+
+const interpret = ([minimum, isExclusive], instance) => {
+  if (!Instance.typeOf(instance, "number")) {
+    return true;
+  }
+
+  const value = Instance.value(instance);
+  return isExclusive ? value > minimum : value >= minimum;
+};
+
+module.exports = { compile, interpret };

package/lib/keywords/minimum.js

@@ -0,0 +1,7 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema) => Schema.value(schema);
+const interpret = (minimum, instance) => !Instance.typeOf(instance, "number") || Instance.value(instance) >= minimum;
+
+module.exports = { compile, interpret };

package/lib/keywords/multipleOf.js

@@ -0,0 +1,17 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = (schema) => Schema.value(schema);
+
+const interpret = (multipleOf, instance) => {
+  if (!Instance.typeOf(instance, "number")) {
+    return true;
+  }
+
+  const remainder = Instance.value(instance) % multipleOf;
+  return numberEqual(0, remainder) || numberEqual(multipleOf, remainder);
+};
+
+const numberEqual = (a, b) => Math.abs(a - b) < 1.19209290e-7;
+
+module.exports = { compile, interpret };

package/lib/keywords/not.js

@@ -0,0 +1,7 @@
+const { Core } = require("@hyperjump/json-schema-core");
+
+
+const compile = Core.compileSchema;
+const interpret = (not, instance, ast, dynamicAnchors) => !Core.interpretSchema(not, instance, ast, dynamicAnchors);
+
+module.exports = { compile, interpret };

package/lib/keywords/oneOf.js

@@ -0,0 +1,48 @@
+const { Core, Schema } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema, ast) => {
+  const oneOf = await Schema.map((itemSchema) => Core.compileSchema(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)) {
+      validCount++;
+    }
+
+    if (validCount > 1) {
+      break;
+    }
+  }
+
+  return validCount === 1;
+};
+
+const collectEvaluatedProperties = (oneOf, instance, ast, dynamicAnchors) => {
+  let validCount = 0;
+  return oneOf.reduce((acc, schemaUrl) => {
+    if (validCount > 1) {
+      return false;
+    }
+
+    const propertyNames = Core.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
+    return propertyNames ? validCount++ === 0 && propertyNames : acc;
+  }, false);
+};
+
+const collectEvaluatedItems = (oneOf, instance, ast, dynamicAnchors) => {
+  let validCount = 0;
+  return oneOf.reduce((acc, schemaUrl) => {
+    if (validCount > 1) {
+      return false;
+    }
+
+    const itemIndexes = Core.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
+    return itemIndexes ? validCount++ === 0 && itemIndexes : acc;
+  }, false);
+};
+
+module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/pattern.js

@@ -0,0 +1,7 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+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 };

package/lib/keywords/patternProperties.js

@@ -0,0 +1,23 @@
+const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+const Pact = require("@hyperjump/pact");
+
+
+const compile = (schema, ast) => Pact.pipeline([
+  Schema.entries,
+  Pact.map(async ([pattern, propertySchema]) => [new RegExp(pattern, "u"), await Core.compileSchema(propertySchema, ast)]),
+  Pact.all
+], schema);
+
+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));
+  });
+};
+
+const collectEvaluatedProperties = (patternProperties, instance, ast, dynamicAnchors) => {
+  return interpret(patternProperties, instance, ast, dynamicAnchors) && patternProperties.map(([pattern]) => pattern);
+};
+
+module.exports = { compile, interpret, collectEvaluatedProperties };

package/lib/keywords/properties.js

@@ -0,0 +1,25 @@
+const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+const Pact = require("@hyperjump/pact");
+const { escapeRegExp } = require("../common");
+
+
+const compile = (schema, ast) => Pact.pipeline([
+  Schema.entries,
+  Pact.reduce(async (acc, [propertyName, propertySchema]) => {
+    acc[propertyName] = await Core.compileSchema(propertySchema, ast);
+    return acc;
+  }, Object.create(null))
+], schema);
+
+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));
+};
+
+const collectEvaluatedProperties = (properties, instance, ast, dynamicAnchors) => {
+  return interpret(properties, instance, ast, dynamicAnchors) && Object.keys(properties)
+    .map((propertyName) => new RegExp(`^${escapeRegExp(propertyName)}$`));
+};
+
+module.exports = { compile, interpret, collectEvaluatedProperties };

package/lib/keywords/propertyNames.js

@@ -0,0 +1,11 @@
+const { Core, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = (schema, ast) => Core.compileSchema(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));
+};
+
+module.exports = { compile, interpret };

package/lib/keywords/ref.js

@@ -0,0 +1,13 @@
+const { Core, Schema } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (ref, ast) => {
+  const referencedSchema = await Schema.get(Schema.value(ref), ref);
+  return Core.compileSchema(referencedSchema, ast);
+};
+
+const interpret = Core.interpretSchema;
+const collectEvaluatedProperties = Core.collectEvaluatedProperties;
+const collectEvaluatedItems = Core.collectEvaluatedItems;
+
+module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/required.js

@@ -0,0 +1,10 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+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 };

package/lib/keywords/then.js

@@ -0,0 +1,43 @@
+const { Core, Schema } = require("@hyperjump/json-schema-core");
+
+
+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)];
+  } else {
+    return [];
+  }
+};
+
+const interpret = ([guard, block], instance, ast, dynamicAnchors) => {
+  return guard === undefined || !quietInterpretSchema(guard, instance, ast, dynamicAnchors) || Core.interpretSchema(block, instance, ast, dynamicAnchors);
+};
+
+// Interpret a schema without events being emitted
+const quietInterpretSchema = (uri, instance, ast, dynamicAnchors) => {
+  const nodes = ast[uri][2];
+
+  return typeof nodes === "boolean" ? nodes : nodes
+    .every(([keywordId, , keywordValue]) => {
+      return Core.getKeyword(keywordId).interpret(keywordValue, instance, ast, dynamicAnchors);
+    });
+};
+
+const collectEvaluatedProperties = ([guard, block], instance, ast, dynamicAnchors) => {
+  if (guard === undefined || !quietInterpretSchema(guard, instance, ast, dynamicAnchors)) {
+    return [];
+  }
+
+  return Core.collectEvaluatedProperties(block, instance, ast, dynamicAnchors);
+};
+
+const collectEvaluatedItems = ([guard, block], instance, ast, dynamicAnchors) => {
+  if (guard === undefined || !quietInterpretSchema(guard, instance, ast, dynamicAnchors)) {
+    return new Set();
+  }
+
+  return Core.collectEvaluatedItems(block, instance, ast, dynamicAnchors);
+};
+
+module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/tupleItems.js

@@ -0,0 +1,24 @@
+const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+const Pact = require("@hyperjump/pact");
+
+
+const compile = (schema, ast) => {
+  return Pact.pipeline([
+    Schema.map((itemSchema) => Core.compileSchema(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) || Core.interpretSchema(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));
+};
+
+module.exports = { compile, interpret, collectEvaluatedItems };

package/lib/keywords/type.js

@@ -0,0 +1,7 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+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 };

package/lib/keywords/unevaluatedItems.js

@@ -0,0 +1,23 @@
+const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema, ast, parentSchema) => {
+  return [Schema.uri(parentSchema), await Core.compileSchema(schema, ast)];
+};
+
+const interpret = ([schemaUrl, unevaluatedItems], instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "array")) {
+    return true;
+  }
+
+  const itemIndexes = Core.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);
+  }, instance);
+};
+
+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 };

package/lib/keywords/unevaluatedProperties.js

@@ -0,0 +1,24 @@
+const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema, ast, parentSchema) => {
+  return [Schema.uri(parentSchema), await Core.compileSchema(schema, ast)];
+};
+
+const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "object")) {
+    return true;
+  }
+
+  const evaluatedPropertyNames = Core.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));
+};
+
+const collectEvaluatedProperties = (keywordValue, instance, ast, dynamicAnchors) =>{
+  return interpret(keywordValue, instance, ast, dynamicAnchors) && [new RegExp("")];
+};
+
+module.exports = { compile, interpret, collectEvaluatedProperties };

package/lib/keywords/uniqueItems.js

@@ -0,0 +1,16 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+const jsonStringify = require("fastest-stable-stringify");
+
+
+const compile = (schema) => Schema.value(schema);
+
+const interpret = (uniqueItems, instance) => {
+  if (!Instance.typeOf(instance, "array") || uniqueItems === false) {
+    return true;
+  }
+
+  const normalizedItems = Instance.map((item) => jsonStringify(Instance.value(item)), instance);
+  return new Set(normalizedItems).size === normalizedItems.length;
+};
+
+module.exports = { compile, interpret };

package/meta/draft/2019-09/meta/applicator.js

@@ -0,0 +1,55 @@
+module.exports = `{
+    "$id": "https://json-schema.org/draft/2019-09/meta/applicator",
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/applicator": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Applicator vocabulary meta-schema",
+    "properties": {
+        "additionalItems": { "$recursiveRef": "#" },
+        "unevaluatedItems": { "$recursiveRef": "#" },
+        "items": {
+            "anyOf": [
+                { "$recursiveRef": "#" },
+                { "$ref": "#/$defs/schemaArray" }
+            ]
+        },
+        "contains": { "$recursiveRef": "#" },
+        "additionalProperties": { "$recursiveRef": "#" },
+        "unevaluatedProperties": { "$recursiveRef": "#" },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependentSchemas": {
+            "type": "object",
+            "additionalProperties": {
+                "$recursiveRef": "#"
+            }
+        },
+        "propertyNames": { "$recursiveRef": "#" },
+        "if": { "$recursiveRef": "#" },
+        "then": { "$recursiveRef": "#" },
+        "else": { "$recursiveRef": "#" },
+        "allOf": { "$ref": "#/$defs/schemaArray" },
+        "anyOf": { "$ref": "#/$defs/schemaArray" },
+        "oneOf": { "$ref": "#/$defs/schemaArray" },
+        "not": { "$recursiveRef": "#" }
+    },
+    "$defs": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$recursiveRef": "#" }
+        }
+    }
+}`;

package/meta/draft/2019-09/meta/content.js

@@ -0,0 +1,17 @@
+module.exports = `{
+    "$id": "https://json-schema.org/draft/2019-09/meta/content",
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+      "https://json-schema.org/draft/2019-09/vocab/content": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Content vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "contentMediaType": { "type": "string" },
+        "contentEncoding": { "type": "string" },
+        "contentSchema": { "$recursiveRef": "#" }
+    }
+}`;

package/meta/draft/2019-09/meta/core.js

@@ -0,0 +1,57 @@
+module.exports = `{
+    "$id": "https://json-schema.org/draft/2019-09/meta/core",
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+      "https://json-schema.org/draft/2019-09/vocab/core": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Core vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "type": "string",
+            "format": "uri-reference",
+            "$comment": "Non-empty fragments not allowed.",
+            "pattern": "^[^#]*#?$"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$anchor": {
+            "type": "string",
+            "pattern": "^[A-Za-z][-A-Za-z0-9.:_]*$"
+        },
+        "$ref": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$recursiveRef": {
+            "type": "string",
+            "format": "uri-reference"
+        },
+        "$recursiveAnchor": {
+            "type": "boolean",
+            "default": false
+        },
+        "$vocabulary": {
+            "type": "object",
+            "propertyNames": {
+                "type": "string",
+                "format": "uri"
+            },
+            "additionalProperties": {
+                "type": "boolean"
+            }
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "$defs": {
+            "type": "object",
+            "additionalProperties": { "$recursiveRef": "#" },
+            "default": {}
+        }
+    }
+}`;

package/meta/draft/2019-09/meta/format.js

@@ -0,0 +1,14 @@
+module.exports = `{
+    "$id": "https://json-schema.org/draft/2019-09/meta/format",
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+      "https://json-schema.org/draft/2019-09/vocab/format": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Format vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "format": { "type": "string" }
+    }
+}`;

package/meta/draft/2019-09/meta/meta-data.js

@@ -0,0 +1,37 @@
+module.exports = `{
+    "$id": "https://json-schema.org/draft/2019-09/meta/meta-data",
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$vocabulary": {
+      "https://json-schema.org/draft/2019-09/vocab/meta-data": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Meta-data vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": true,
+        "deprecated": {
+            "type": "boolean",
+            "default": false
+        },
+        "readOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "writeOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "examples": {
+            "type": "array",
+            "items": true
+        }
+    }
+}`;