@hyperjump/json-schema 0.18.0

package/lib/index.d.ts

@@ -0,0 +1,28 @@
+import type { Core, Schema, Keywords, InvalidSchemaError } from "@hyperjump/json-schema-core";
+
+
+export type JsonSchema = {
+  add: typeof Schema.add;
+  get: typeof Schema.get;
+  validate: typeof Core.validate;
+  compile: typeof Core.compile;
+  interpret: typeof Core.interpret;
+  setMetaOutputFormat: typeof Core.setMetaOutputFormat;
+  setShouldMetaValidate: typeof Core.setShouldMetaValidate;
+  FLAG: typeof Core.FLAG;
+  BASIC: typeof Core.BASIC;
+  DETAILED: typeof Core.DETAILED;
+  VERBOSE: typeof Core.VERBOSE;
+  Keywords: typeof Keywords;
+  InvalidSchemaError: typeof InvalidSchemaError;
+};
+
+export * from "@hyperjump/json-schema-core";
+export * from "./draft-04";
+export * from "./draft-06";
+export * from "./draft-07";
+export * from "./draft-2019-09";
+export * from "./draft-2020-12";
+
+declare const jsonSchema: JsonSchema;
+export default jsonSchema;

package/lib/index.js

@@ -0,0 +1,26 @@
+const { Core, Schema, InvalidSchemaError } = require("@hyperjump/json-schema-core");
+const Keywords = require("./keywords");
+
+require("./draft-04");
+require("./draft-06");
+require("./draft-07");
+require("./draft-2019-09");
+require("./draft-2020-12");
+
+
+module.exports = {
+  add: Core.add,
+  get: Schema.get,
+  validate: Core.validate,
+  compile: Core.compile,
+  interpret: Core.interpret,
+  setMetaOutputFormat: Core.setMetaOutputFormat,
+  setShouldMetaValidate: Core.setShouldMetaValidate,
+  FLAG: Core.FLAG,
+  BASIC: Core.BASIC,
+  DETAILED: Core.DETAILED,
+  VERBOSE: Core.VERBOSE,
+  Keywords: Keywords,
+  InvalidSchemaError: InvalidSchemaError
+};
+

package/lib/index.mjs

@@ -0,0 +1,18 @@
+import JsonSchema from "./index.js";
+
+
+export const add = JsonSchema.add;
+export const get = JsonSchema.get;
+export const validate = JsonSchema.validate;
+export const compile = JsonSchema.compile;
+export const interpret = JsonSchema.interpret;
+export const setMetaOutputFormat = JsonSchema.setMetaOutputFormat;
+export const setShouldMetaValidate = JsonSchema.setShouldMetaValidate;
+export const FLAG = JsonSchema.FLAG;
+export const BASIC = JsonSchema.BASIC;
+export const DETAILED = JsonSchema.DETAILED;
+export const VERBOSE = JsonSchema.VERBOSE;
+export const Keywords = JsonSchema.Keywords;
+export const InvalidSchemaError = JsonSchema.InvalidSchemaError;
+
+export default JsonSchema;

package/lib/keywords/additionalItems.js

@@ -0,0 +1,27 @@
+const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema, ast, parentSchema) => {
+  const items = await Schema.step("items", parentSchema);
+  const numberOfItems = Schema.typeOf(items, "array") ? Schema.length(items) : Number.MAX_SAFE_INTEGER;
+
+  if (Schema.typeOf(schema, "boolean")) {
+    return [numberOfItems, Schema.value(schema)];
+  } else {
+    return [numberOfItems, await Core.compileSchema(schema, ast)];
+  }
+};
+
+const interpret = ([numberOfItems, additionalItems], instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "array")) {
+    return true;
+  }
+
+  if (typeof additionalItems === "string") {
+    return Instance.every((item, ndx) => ndx < numberOfItems || Core.interpretSchema(additionalItems, item, ast, dynamicAnchors), instance);
+  } else {
+    return Instance.every((item, ndx) => ndx < numberOfItems ? true : additionalItems, instance);
+  }
+};
+
+module.exports = { compile, interpret };

package/lib/keywords/additionalItems6.js

@@ -0,0 +1,23 @@
+const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema, ast, parentSchema) => {
+  const items = await Schema.step("items", parentSchema);
+  const numberOfItems = Schema.typeOf(items, "array") ? Schema.length(items) : Number.MAX_SAFE_INTEGER;
+
+  return [numberOfItems, await Core.compileSchema(schema, ast)];
+};
+
+const interpret = ([numberOfItems, additionalItems], instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "array")) {
+    return true;
+  }
+
+  return Instance.every((item, ndx) => ndx < numberOfItems || Core.interpretSchema(additionalItems, item, 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/additionalProperties.js

@@ -0,0 +1,33 @@
+const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema, ast, parentSchema) => {
+  const properties = await Schema.step("properties", parentSchema);
+  const propertyNames = Schema.typeOf(properties, "object") ? Schema.keys(properties) : [];
+
+  const patternProperties = await Schema.step("patternProperties", parentSchema);
+  const propertyNamePatterns = Schema.typeOf(patternProperties, "object") ? Schema.keys(patternProperties).map((pattern) => new RegExp(pattern)) : [];
+
+  if (Schema.typeOf(schema, "boolean")) {
+    return [propertyNames, propertyNamePatterns, Schema.value(schema)];
+  } else {
+    return [propertyNames, propertyNamePatterns, await Core.compileSchema(schema, ast)];
+  }
+};
+
+const interpret = ([propertyNames, propertyNamePatterns, additionalProperties], instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "object")) {
+    return true;
+  }
+
+  const properties = Instance.entries(instance)
+    .filter(([propertyName]) => !propertyNames.includes(propertyName) && !propertyNamePatterns.some((pattern) => pattern.test(propertyName)));
+
+  if (typeof additionalProperties === "string") {
+    return properties.every(([, property]) => Core.interpretSchema(additionalProperties, property, ast, dynamicAnchors));
+  } else {
+    return properties.length === 0 || additionalProperties;
+  }
+};
+
+module.exports = { compile, interpret };

package/lib/keywords/additionalProperties6.js

@@ -0,0 +1,28 @@
+const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema, ast, parentSchema) => {
+  const propertiesSchema = await Schema.step("properties", parentSchema);
+  const propertyNames = Schema.typeOf(propertiesSchema, "object") ? Schema.keys(propertiesSchema) : [];
+
+  const patternProperties = await Schema.step("patternProperties", parentSchema);
+  const propertyNamePatterns = Schema.typeOf(patternProperties, "object") ? Schema.keys(patternProperties).map((pattern) => new RegExp(pattern)) : [];
+
+  return [propertyNames, propertyNamePatterns, await Core.compileSchema(schema, ast)];
+};
+
+const interpret = ([propertyNames, propertyNamePatterns, additionalProperties], instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "object")) {
+    return true;
+  }
+
+  return Instance.entries(instance)
+    .filter(([propertyName]) => !propertyNames.includes(propertyName) && !propertyNamePatterns.some((pattern) => pattern.test(propertyName)))
+    .every(([, property]) => Core.interpretSchema(additionalProperties, 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/allOf.js

@@ -0,0 +1,28 @@
+const { Core, Schema } = require("@hyperjump/json-schema-core");
+const Pact = require("@hyperjump/pact");
+
+
+const compile = (schema, ast) => Pact.pipeline([
+  Schema.map(async (itemSchema) => Core.compileSchema(await itemSchema, ast)),
+  Pact.all
+], schema);
+
+const interpret = (allOf, instance, ast, dynamicAnchors) => {
+  return allOf.every((schemaUrl) => Core.interpretSchema(schemaUrl, instance, ast, dynamicAnchors));
+};
+
+const collectEvaluatedProperties = (allOf, instance, ast, dynamicAnchors) => {
+  return allOf.reduce((acc, schemaUrl) => {
+    const propertyNames = acc && Core.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
+    return propertyNames !== false && [...acc, ...propertyNames];
+  }, []);
+};
+
+const collectEvaluatedItems = (allOf, instance, ast, dynamicAnchors) => {
+  return allOf.reduce((acc, schemaUrl) => {
+    const itemIndexes = acc !== false && Core.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
+    return itemIndexes !== false && new Set([...acc, ...itemIndexes]);
+  }, new Set());
+};
+
+module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/anyOf.js

@@ -0,0 +1,29 @@
+const { Core, Schema } = require("@hyperjump/json-schema-core");
+const Pact = require("@hyperjump/pact");
+
+
+const compile = (schema, ast) => Pact.pipeline([
+  Schema.map(async (itemSchema) => Core.compileSchema(await itemSchema, ast)),
+  Pact.all
+], schema);
+
+const interpret = (anyOf, instance, ast, dynamicAnchors) => {
+  const matches = anyOf.filter((schemaUrl) => Core.interpretSchema(schemaUrl, instance, ast, dynamicAnchors));
+  return matches.length > 0;
+};
+
+const collectEvaluatedProperties = (anyOf, instance, ast, dynamicAnchors) => {
+  return anyOf.reduce((acc, schemaUrl) => {
+    const propertyNames = Core.collectEvaluatedProperties(schemaUrl, instance, ast, dynamicAnchors);
+    return propertyNames !== false ? [...acc || [], ...propertyNames] : acc;
+  }, false);
+};
+
+const collectEvaluatedItems = (anyOf, instance, ast, dynamicAnchors) => {
+  return anyOf.reduce((acc, schemaUrl) => {
+    const itemIndexes = Core.collectEvaluatedItems(schemaUrl, instance, ast, dynamicAnchors);
+    return itemIndexes !== false ? new Set([...acc || [], ...itemIndexes]) : acc;
+  }, false);
+};
+
+module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/const.js

@@ -0,0 +1,8 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+const jsonStringify = require("fastest-stable-stringify");
+
+
+const compile = (schema) => jsonStringify(Schema.value(schema));
+const interpret = (const_, instance) => jsonStringify(Instance.value(instance)) === const_;
+
+module.exports = { compile, interpret };

package/lib/keywords/contains-minContains-maxContains.js

@@ -0,0 +1,33 @@
+const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema, ast, parentSchema) => {
+  const contains = await Core.compileSchema(schema, ast);
+
+  const minContainsSchema = await Schema.step("minContains", parentSchema);
+  const minContains = Schema.typeOf(minContainsSchema, "number") ? Schema.value(minContainsSchema) : 1;
+
+  const maxContainsSchema = await Schema.step("maxContains", parentSchema);
+  const maxContains = Schema.typeOf(maxContainsSchema, "number") ? Schema.value(maxContainsSchema) : Number.MAX_SAFE_INTEGER;
+
+  return { contains, minContains, maxContains };
+};
+
+const interpret = ({ contains, minContains, maxContains }, instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "array")) {
+    return true;
+  }
+
+  const matches = Instance.reduce((matches, item) => {
+    return Core.interpretSchema(contains, item, ast, dynamicAnchors) ? matches + 1 : matches;
+  }, 0, instance);
+  return matches >= minContains && matches <= maxContains;
+};
+
+const collectEvaluatedItems = (keywordValue, instance, ast, dynamicAnchors) => {
+  return interpret(keywordValue, instance, ast, dynamicAnchors) && Instance.reduce((matchedIndexes, item, itemIndex) => {
+    return Core.interpretSchema(keywordValue.contains, item, ast, dynamicAnchors) ? matchedIndexes.add(itemIndex) : matchedIndexes;
+  }, new Set(), instance);
+};
+
+module.exports = { compile, interpret, collectEvaluatedItems };

package/lib/keywords/contains.js

@@ -0,0 +1,10 @@
+const { Core, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = (schema, ast) => Core.compileSchema(schema, ast);
+
+const interpret = (contains, instance, ast, dynamicAnchors) => {
+  return !Instance.typeOf(instance, "array") || Instance.some((item) => Core.interpretSchema(contains, item, ast, dynamicAnchors), instance);
+};
+
+module.exports = { compile, interpret };

package/lib/keywords/definitions.js

@@ -0,0 +1,15 @@
+const { Core, Schema } = require("@hyperjump/json-schema-core");
+const Pact = require("@hyperjump/pact");
+
+
+const compile = async (schema, ast) => {
+  await Pact.pipeline([
+    Schema.entries,
+    Pact.map(([, definitionSchema]) => Core.compileSchema(definitionSchema, ast)),
+    Pact.all
+  ], schema);
+};
+
+const interpret = () => true;
+
+module.exports = { compile, interpret };

package/lib/keywords/dependencies.js

@@ -0,0 +1,29 @@
+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 ([key, dependency]) => {
+    return [key, Schema.typeOf(dependency, "array") ? Schema.value(dependency) : await Core.compileSchema(dependency, ast)];
+  }),
+  Pact.all
+], schema);
+
+const interpret = (dependencies, instance, ast, dynamicAnchors) => {
+  const value = Instance.value(instance);
+
+  return !Instance.typeOf(instance, "object") || dependencies.every(([propertyName, dependency]) => {
+    if (!(propertyName in value)) {
+      return true;
+    }
+
+    if (Array.isArray(dependency)) {
+      return dependency.every((key) => key in value);
+    } else {
+      return Core.interpretSchema(dependency, instance, ast, dynamicAnchors);
+    }
+  });
+};
+
+module.exports = { compile, interpret };

package/lib/keywords/dependentRequired.js

@@ -0,0 +1,19 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+const Pact = require("@hyperjump/pact");
+
+
+const compile = (schema) => Pact.pipeline([
+  Schema.entries,
+  Pact.map(([key, dependentRequired]) => [key, Schema.value(dependentRequired)]),
+  Pact.all
+], schema);
+
+const interpret = (dependentRequired, instance) => {
+  const value = Instance.value(instance);
+
+  return !Instance.typeOf(instance, "object") || dependentRequired.every(([propertyName, required]) => {
+    return !(propertyName in value) || required.every((key) => key in value);
+  });
+};
+
+module.exports = { compile, interpret };

package/lib/keywords/dependentSchemas.js

@@ -0,0 +1,30 @@
+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 ([key, dependentSchema]) => [key, await Core.compileSchema(dependentSchema, ast)]),
+  Pact.all
+], schema);
+
+const interpret = (dependentSchemas, instance, ast, dynamicAnchors) => {
+  const value = Instance.value(instance);
+
+  return !Instance.typeOf(instance, "object") || dependentSchemas.every(([propertyName, dependentSchema]) => {
+    return !(propertyName in value) || Core.interpretSchema(dependentSchema, instance, ast, dynamicAnchors);
+  });
+};
+
+const collectEvaluatedProperties = (dependentSchemas, instance, ast, dynamicAnchors) => {
+  return dependentSchemas.reduce((acc, [propertyName, dependentSchema]) => {
+    if (!acc || !Instance.has(propertyName, instance)) {
+      return acc;
+    }
+
+    const propertyNames = Core.collectEvaluatedProperties(dependentSchema, instance, ast, dynamicAnchors);
+    return propertyNames !== false && acc.concat(propertyNames);
+  }, []);
+};
+
+module.exports = { compile, interpret, collectEvaluatedProperties };

package/lib/keywords/dynamicRef.js

@@ -0,0 +1,24 @@
+const { Core, Schema } = require("@hyperjump/json-schema-core");
+const { splitUrl } = require("../common");
+
+
+const compile = async (dynamicRef, ast) => {
+  const [, fragment] = splitUrl(Schema.value(dynamicRef));
+  const referencedSchema = await Schema.get(Schema.value(dynamicRef), dynamicRef);
+  await Core.compileSchema(referencedSchema, ast);
+  return [referencedSchema.id, fragment];
+};
+
+const interpret = ([id, fragment], instance, ast, dynamicAnchors) => {
+  if (fragment in ast.metaData[id].dynamicAnchors) {
+    return Core.interpretSchema(dynamicAnchors[fragment], instance, ast, dynamicAnchors);
+  } else {
+    const pointer = Schema.getAnchorPointer(ast.metaData[id], fragment);
+    return Core.interpretSchema(`${id}#${encodeURI(pointer)}`, instance, ast, dynamicAnchors);
+  }
+};
+
+const collectEvaluatedProperties = Core.collectEvaluatedProperties;
+const collectEvaluatedItems = Core.collectEvaluatedItems;
+
+module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/else.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/enum.js

@@ -0,0 +1,8 @@
+const { Schema, Instance } = require("@hyperjump/json-schema-core");
+const jsonStringify = require("fastest-stable-stringify");
+
+
+const compile = (schema) => Schema.value(schema).map(jsonStringify);
+const interpret = (enum_, instance) => enum_.some((enumValue) => jsonStringify(Instance.value(instance)) === enumValue);
+
+module.exports = { compile, interpret };

package/lib/keywords/exclusiveMaximum.js

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

package/lib/keywords/exclusiveMinimum.js

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

package/lib/keywords/if.js

@@ -0,0 +1,19 @@
+const { Core } = require("@hyperjump/json-schema-core");
+
+
+const compile = (schema, ast) => Core.compileSchema(schema, ast);
+
+const interpret = (ifSchema, instance, ast, dynamicAnchors) => {
+  Core.interpretSchema(ifSchema, instance, ast, dynamicAnchors);
+  return true;
+};
+
+const collectEvaluatedProperties = (ifSchema, instance, ast, dynamicAnchors) => {
+  return Core.collectEvaluatedProperties(ifSchema, instance, ast, dynamicAnchors) || [];
+};
+
+const collectEvaluatedItems = (ifSchema, instance, ast, dynamicAnchors) => {
+  return Core.collectEvaluatedItems(ifSchema, instance, ast, dynamicAnchors) || new Set();
+};
+
+module.exports = { compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/lib/keywords/index.js

@@ -0,0 +1,55 @@
+const { Keywords } = require("@hyperjump/json-schema-core");
+
+
+module.exports = {
+  additionalItems: require("./additionalItems"),
+  additionalItems6: require("./additionalItems6"),
+  additionalProperties: require("./additionalProperties"),
+  additionalProperties6: require("./additionalProperties6"),
+  allOf: require("./allOf"),
+  anyOf: require("./anyOf"),
+  const: require("./const"),
+  contains: require("./contains"),
+  containsMinContainsMaxContains: require("./contains-minContains-maxContains"),
+  definitions: require("./definitions"),
+  dependencies: require("./dependencies"),
+  dependentRequired: require("./dependentRequired"),
+  dependentSchemas: require("./dependentSchemas"),
+  enum: require("./enum"),
+  exclusiveMaximum: require("./exclusiveMaximum"),
+  exclusiveMinimum: require("./exclusiveMinimum"),
+  if: require("./if"),
+  then: require("./then"),
+  else: require("./else"),
+  items: require("./items"),
+  items202012: require("./items202012"),
+  maxItems: require("./maxItems"),
+  maxLength: require("./maxLength"),
+  maxLength6: require("./maxLength6"),
+  maxProperties: require("./maxProperties"),
+  maximumExclusiveMaximum: require("./maximum-exclusiveMaximum"),
+  maximum: require("./maximum"),
+  metaData: Keywords.metaData,
+  minItems: require("./minItems"),
+  minLength: require("./minLength"),
+  minLength6: require("./minLength6"),
+  minProperties: require("./minProperties"),
+  minimumExclusiveMinimum: require("./minimum-exclusiveMinimum"),
+  minimum: require("./minimum"),
+  multipleOf: require("./multipleOf"),
+  not: require("./not"),
+  oneOf: require("./oneOf"),
+  pattern: require("./pattern"),
+  patternProperties: require("./patternProperties"),
+  properties: require("./properties"),
+  propertyNames: require("./propertyNames"),
+  dynamicRef: require("./dynamicRef"),
+  ref: require("./ref"),
+  required: require("./required"),
+  tupleItems: require("./tupleItems"),
+  type: require("./type"),
+  unevaluatedItems: require("./unevaluatedItems"),
+  unevaluatedProperties: require("./unevaluatedProperties"),
+  uniqueItems: require("./uniqueItems"),
+  validate: Keywords.validate
+};

package/lib/keywords/items.js

@@ -0,0 +1,31 @@
+const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema, ast) => {
+  if (Schema.typeOf(schema, "array")) {
+    const tupleItems = await Schema.map((itemSchema) => Core.compileSchema(itemSchema, ast), schema);
+    return Promise.all(tupleItems);
+  } else {
+    return Core.compileSchema(schema, ast);
+  }
+};
+
+const interpret = (items, instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "array")) {
+    return true;
+  }
+
+  if (typeof items === "string") {
+    return Instance.every((itemValue) => Core.interpretSchema(items, itemValue, ast, dynamicAnchors), instance);
+  } else {
+    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) && (typeof items === "string"
+    ? new Set(Instance.map((item, itemIndex) => itemIndex, instance))
+    : new Set(items.map((item, itemIndex) => itemIndex)));
+};
+
+module.exports = { compile, interpret, collectEvaluatedItems };

package/lib/keywords/items202012.js

@@ -0,0 +1,23 @@
+const { Core, Schema, Instance } = require("@hyperjump/json-schema-core");
+
+
+const compile = async (schema, ast, parentSchema) => {
+  const items = await Schema.step("prefixItems", parentSchema);
+  const numberOfPrefixItems = Schema.typeOf(items, "array") ? Schema.length(items) : 0;
+
+  return [numberOfPrefixItems, await Core.compileSchema(schema, ast)];
+};
+
+const interpret = ([numberOfPrefixItems, items], instance, ast, dynamicAnchors) => {
+  if (!Instance.typeOf(instance, "array")) {
+    return true;
+  }
+
+  return Instance.every((item, ndx) => ndx < numberOfPrefixItems || Core.interpretSchema(items, item, 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/maxItems.js

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

package/lib/keywords/maxLength.js

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

package/lib/keywords/maxLength6.js

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