@hyperjump/json-schema 0.23.3 → 1.0.0

package/draft-2019-09/index.js

@@ -0,0 +1,117 @@
+import { addKeyword, defineVocabulary, loadDialect } from "../lib/keywords.js";
+import { addSchema } from "../lib/core.js";
+
+import metaSchema from "./schema.js";
+import coreMetaSchema from "./meta/core.js";
+import applicatorMetaSchema from "./meta/applicator.js";
+import validationMetaSchema from "./meta/validation.js";
+import metaDataMetaSchema from "./meta/meta-data.js";
+import formatMetaSchema from "./meta/format.js";
+import contentMetaSchema from "./meta/content.js";
+
+import additionalItems from "../draft-04/additionalItems.js";
+import contains from "./contains.js";
+import items from "../draft-04/items.js";
+import recursiveAnchor from "./recursiveAnchor.js";
+import recursiveRef from "./recursiveRef.js";
+
+
+addKeyword(additionalItems);
+addKeyword(contains);
+addKeyword(items);
+addKeyword(recursiveAnchor);
+addKeyword(recursiveRef);
+
+defineVocabulary("https://json-schema.org/draft/2019-09/vocab/core", {
+  "$anchor": "https://json-schema.org/keyword/anchor",
+  "$comment": "https://json-schema.org/keyword/comment",
+  "$defs": "https://json-schema.org/keyword/definitions",
+  "$recursiveAnchor": "https://json-schema.org/keyword/draft-2019-09/recursiveAnchor",
+  "$recursiveRef": "https://json-schema.org/keyword/draft-2019-09/recursiveRef",
+  "$id": "https://json-schema.org/keyword/id",
+  "$ref": "https://json-schema.org/keyword/ref",
+  "$vocabulary": "https://json-schema.org/keyword/vocabulary"
+});
+
+defineVocabulary("https://json-schema.org/draft/2019-09/vocab/applicator", {
+  "additionalItems": "https://json-schema.org/keyword/draft-04/additionalItems",
+  "additionalProperties": "https://json-schema.org/keyword/additionalProperties",
+  "allOf": "https://json-schema.org/keyword/allOf",
+  "anyOf": "https://json-schema.org/keyword/anyOf",
+  "contains": "https://json-schema.org/keyword/draft-2019-09/contains",
+  "dependentSchemas": "https://json-schema.org/keyword/dependentSchemas",
+  "if": "https://json-schema.org/keyword/if",
+  "then": "https://json-schema.org/keyword/then",
+  "else": "https://json-schema.org/keyword/else",
+  "items": "https://json-schema.org/keyword/draft-04/items",
+  "not": "https://json-schema.org/keyword/not",
+  "oneOf": "https://json-schema.org/keyword/oneOf",
+  "patternProperties": "https://json-schema.org/keyword/patternProperties",
+  "prefixItems": "https://json-schema.org/keyword/prefixItems",
+  "properties": "https://json-schema.org/keyword/properties",
+  "propertyNames": "https://json-schema.org/keyword/propertyNames",
+  "unevaluatedItems": "https://json-schema.org/keyword/unevaluatedItems",
+  "unevaluatedProperties": "https://json-schema.org/keyword/unevaluatedProperties"
+});
+
+defineVocabulary("https://json-schema.org/draft/2019-09/vocab/validation", {
+  "const": "https://json-schema.org/keyword/const",
+  "enum": "https://json-schema.org/keyword/enum",
+  "dependentRequired": "https://json-schema.org/keyword/dependentRequired",
+  "exclusiveMaximum": "https://json-schema.org/keyword/exclusiveMaximum",
+  "exclusiveMinimum": "https://json-schema.org/keyword/exclusiveMinimum",
+  "maxContains": "https://json-schema.org/keyword/maxContains",
+  "maxItems": "https://json-schema.org/keyword/maxItems",
+  "maxLength": "https://json-schema.org/keyword/maxLength",
+  "maxProperties": "https://json-schema.org/keyword/maxProperties",
+  "maximum": "https://json-schema.org/keyword/maximum",
+  "minContains": "https://json-schema.org/keyword/minContains",
+  "minItems": "https://json-schema.org/keyword/minItems",
+  "minLength": "https://json-schema.org/keyword/minLength",
+  "minProperties": "https://json-schema.org/keyword/minProperties",
+  "minimum": "https://json-schema.org/keyword/minimum",
+  "multipleOf": "https://json-schema.org/keyword/multipleOf",
+  "pattern": "https://json-schema.org/keyword/pattern",
+  "required": "https://json-schema.org/keyword/required",
+  "type": "https://json-schema.org/keyword/type",
+  "uniqueItems": "https://json-schema.org/keyword/uniqueItems"
+});
+
+defineVocabulary("https://json-schema.org/draft/2019-09/vocab/meta-data", {
+  "default": "https://json-schema.org/keyword/default",
+  "deprecated": "https://json-schema.org/keyword/deprecated",
+  "description": "https://json-schema.org/keyword/description",
+  "examples": "https://json-schema.org/keyword/examples",
+  "readOnly": "https://json-schema.org/keyword/readOnly",
+  "title": "https://json-schema.org/keyword/title",
+  "writeOnly": "https://json-schema.org/keyword/writeOnly"
+});
+
+defineVocabulary("https://json-schema.org/draft/2019-09/vocab/format", {
+  "format": "https://json-schema.org/keyword/format"
+});
+
+defineVocabulary("https://json-schema.org/draft/2019-09/vocab/content", {
+  "contentEncoding": "https://json-schema.org/keyword/contentEncoding",
+  "contentMediaType": "https://json-schema.org/keyword/contentMediaType",
+  "contentSchema": "https://json-schema.org/keyword/contentSchema"
+});
+
+loadDialect("https://json-schema.org/draft/2019-09/schema", {
+  "https://json-schema.org/draft/2019-09/vocab/core": true,
+  "https://json-schema.org/draft/2019-09/vocab/applicator": true,
+  "https://json-schema.org/draft/2019-09/vocab/validation": true,
+  "https://json-schema.org/draft/2019-09/vocab/meta-data": true,
+  "https://json-schema.org/draft/2019-09/vocab/format": true,
+  "https://json-schema.org/draft/2019-09/vocab/content": true
+}, true);
+
+addSchema(metaSchema);
+addSchema(coreMetaSchema);
+addSchema(applicatorMetaSchema);
+addSchema(validationMetaSchema);
+addSchema(metaDataMetaSchema);
+addSchema(formatMetaSchema);
+addSchema(contentMetaSchema);
+
+export * from "../lib/index.js";

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

@@ -0,0 +1,55 @@
+export default {
+  "$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/draft-2019-09/meta/content.js

@@ -0,0 +1,17 @@
+export default {
+  "$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/draft-2019-09/meta/core.js

@@ -0,0 +1,57 @@
+export default {
+  "$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/draft-2019-09/meta/format.js

@@ -0,0 +1,14 @@
+export default {
+  "$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/draft-2019-09/meta/meta-data.js

@@ -0,0 +1,37 @@
+export default {
+  "$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
+    }
+  }
+};

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

@@ -0,0 +1,98 @@
+export default {
+  "$id": "https://json-schema.org/draft/2019-09/meta/validation",
+  "$schema": "https://json-schema.org/draft/2019-09/schema",
+  "$vocabulary": {
+    "https://json-schema.org/draft/2019-09/vocab/validation": true
+  },
+  "$recursiveAnchor": true,
+
+  "title": "Validation vocabulary meta-schema",
+  "type": ["object", "boolean"],
+  "properties": {
+    "multipleOf": {
+      "type": "number",
+      "exclusiveMinimum": 0
+    },
+    "maximum": {
+      "type": "number"
+    },
+    "exclusiveMaximum": {
+      "type": "number"
+    },
+    "minimum": {
+      "type": "number"
+    },
+    "exclusiveMinimum": {
+      "type": "number"
+    },
+    "maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+    "minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+    "pattern": {
+      "type": "string",
+      "format": "regex"
+    },
+    "maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+    "minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+    "uniqueItems": {
+      "type": "boolean",
+      "default": false
+    },
+    "maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+    "minContains": {
+      "$ref": "#/$defs/nonNegativeInteger",
+      "default": 1
+    },
+    "maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+    "minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+    "required": { "$ref": "#/$defs/stringArray" },
+    "dependentRequired": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/$defs/stringArray"
+      }
+    },
+    "const": true,
+    "enum": {
+      "type": "array",
+      "items": true
+    },
+    "type": {
+      "anyOf": [
+        { "$ref": "#/$defs/simpleTypes" },
+        {
+          "type": "array",
+          "items": { "$ref": "#/$defs/simpleTypes" },
+          "minItems": 1,
+          "uniqueItems": true
+        }
+      ]
+    }
+  },
+  "$defs": {
+    "nonNegativeInteger": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "nonNegativeIntegerDefault0": {
+      "$ref": "#/$defs/nonNegativeInteger",
+      "default": 0
+    },
+    "simpleTypes": {
+      "enum": [
+        "array",
+        "boolean",
+        "integer",
+        "null",
+        "number",
+        "object",
+        "string"
+      ]
+    },
+    "stringArray": {
+      "type": "array",
+      "items": { "type": "string" },
+      "uniqueItems": true,
+      "default": []
+    }
+  }
+};

package/draft-2019-09/recursiveAnchor.js

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

package/draft-2019-09/recursiveRef.js

@@ -0,0 +1,19 @@
+import Validation from "../lib/keywords/validation.js";
+
+
+const id = "https://json-schema.org/keyword/draft-2019-09/recursiveRef";
+
+const compile = async (schema) => schema.id;
+
+const interpret = (id, instance, ast, dynamicAnchors) => {
+  if ("" in ast.metaData[id].dynamicAnchors) {
+    return Validation.interpret(dynamicAnchors[""], instance, ast, dynamicAnchors);
+  } else {
+    return Validation.interpret(`${id}#`, instance, ast, dynamicAnchors);
+  }
+};
+
+const collectEvaluatedProperties = Validation.collectEvaluatedProperties;
+const collectEvaluatedItems = Validation.collectEvaluatedItems;
+
+export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/draft-2019-09/schema.js

@@ -0,0 +1,42 @@
+export default {
+  "$schema": "https://json-schema.org/draft/2019-09/schema",
+  "$id": "https://json-schema.org/draft/2019-09/schema",
+  "$vocabulary": {
+    "https://json-schema.org/draft/2019-09/vocab/core": true,
+    "https://json-schema.org/draft/2019-09/vocab/applicator": true,
+    "https://json-schema.org/draft/2019-09/vocab/validation": true,
+    "https://json-schema.org/draft/2019-09/vocab/meta-data": true,
+    "https://json-schema.org/draft/2019-09/vocab/format": false,
+    "https://json-schema.org/draft/2019-09/vocab/content": true
+  },
+  "$recursiveAnchor": true,
+
+  "title": "Core and Validation specifications meta-schema",
+  "allOf": [
+    { "$ref": "meta/core" },
+    { "$ref": "meta/applicator" },
+    { "$ref": "meta/validation" },
+    { "$ref": "meta/meta-data" },
+    { "$ref": "meta/format" },
+    { "$ref": "meta/content" }
+  ],
+  "type": ["object", "boolean"],
+  "properties": {
+    "definitions": {
+      "$comment": "While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.",
+      "type": "object",
+      "additionalProperties": { "$recursiveRef": "#" },
+      "default": {}
+    },
+    "dependencies": {
+      "$comment": "\"dependencies\" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to \"dependentSchemas\" and \"dependentRequired\"",
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [
+          { "$recursiveRef": "#" },
+          { "$ref": "meta/validation#/$defs/stringArray" }
+        ]
+      }
+    }
+  }
+};

package/draft-2020-12/dynamicAnchor.js

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

package/draft-2020-12/dynamicRef.js

@@ -0,0 +1,35 @@
+import Validation from "../lib/keywords/validation.js";
+import * as Schema from "../lib/schema.js";
+
+
+const id = "https://json-schema.org/keyword/draft-2020-12/dynamicRef";
+
+const compile = async (dynamicRef, ast) => {
+  const [, fragment] = splitUrl(Schema.value(dynamicRef));
+  const referencedSchema = await Schema.get(Schema.value(dynamicRef), dynamicRef);
+  await Validation.compile(referencedSchema, ast);
+  return [referencedSchema.id, fragment, Schema.uri(referencedSchema)];
+
+};
+
+const interpret = ([id, fragment, ref], instance, ast, dynamicAnchors) => {
+  if (fragment in ast.metaData[id].dynamicAnchors) {
+    return Validation.interpret(dynamicAnchors[fragment], instance, ast, dynamicAnchors);
+  } else {
+    return Validation.interpret(ref, instance, ast, dynamicAnchors);
+  }
+};
+
+const collectEvaluatedProperties = Validation.collectEvaluatedProperties;
+const collectEvaluatedItems = Validation.collectEvaluatedItems;
+
+const splitUrl = (url) => {
+  const indexOfHash = url.indexOf("#");
+  const ndx = indexOfHash === -1 ? url.length : indexOfHash;
+  const urlReference = url.slice(0, ndx);
+  const urlFragment = url.slice(ndx + 1);
+
+  return [decodeURI(urlReference), decodeURI(urlFragment)];
+};
+
+export default { id, compile, interpret, collectEvaluatedProperties, collectEvaluatedItems };

package/draft-2020-12/index.d.ts

@@ -0,0 +1,66 @@
+import type { Json } from "@hyperjump/json-pointer";
+import type { JsonSchemaType } from "../lib/common.js";
+
+
+export type JsonSchemaDraft202012 = boolean | {
+  $schema?: "https://json-schema.org/draft/2020-12/schema";
+  $id?: string;
+  $anchor?: string;
+  $ref?: string;
+  $dynamicRef?: string;
+  $dynamicAnchor?: string;
+  $vocabulary?: Record<string, boolean>;
+  $comment?: string;
+  $defs?: Record<string, JsonSchemaDraft202012>;
+  additionalItems?: JsonSchemaDraft202012;
+  unevaluatedItems?: JsonSchemaDraft202012;
+  prefixItems?: JsonSchemaDraft202012[];
+  items?: JsonSchemaDraft202012;
+  contains?: JsonSchemaDraft202012;
+  additionalProperties?: JsonSchemaDraft202012;
+  unevaluatedProperties?: JsonSchemaDraft202012;
+  properties?: Record<string, JsonSchemaDraft202012>;
+  patternProperties?: Record<string, JsonSchemaDraft202012>;
+  dependentSchemas?: Record<string, JsonSchemaDraft202012>;
+  propertyNames?: JsonSchemaDraft202012;
+  if?: JsonSchemaDraft202012;
+  then?: JsonSchemaDraft202012;
+  else?: JsonSchemaDraft202012;
+  allOf?: JsonSchemaDraft202012[];
+  anyOf?: JsonSchemaDraft202012[];
+  oneOf?: JsonSchemaDraft202012[];
+  not?: JsonSchemaDraft202012;
+  multipleOf?: number;
+  maximum?: number;
+  exclusiveMaximum?: number;
+  minimum?: number;
+  exclusiveMinimum?: number;
+  maxLength?: number;
+  minLength?: number;
+  pattern?: string;
+  maxItems?: number;
+  minItems?: number;
+  uniqueItems?: boolean;
+  maxContains?: number;
+  minContains?: number;
+  maxProperties?: number;
+  minProperties?: number;
+  required?: string[];
+  dependentRequired?: Record<string, string[]>;
+  const?: Json;
+  enum?: Json[];
+  type?: JsonSchemaType | JsonSchemaType[];
+  title?: string;
+  description?: string;
+  default?: Json;
+  deprecated?: boolean;
+  readOnly?: boolean;
+  writeOnly?: boolean;
+  examples?: Json[];
+  format?: "date-time" | "date" | "time" | "duration" | "email" | "idn-email" | "hostname" | "idn-hostname" | "ipv4" | "ipv6" | "uri" | "uri-reference" | "iri" | "iri-reference" | "uuid" | "uri-template" | "json-pointer" | "relative-json-pointer" | "regex";
+  contentMediaType?: string;
+  contentEncoding?: string;
+  contentSchema?: JsonSchemaDraft202012;
+};
+
+export * from "../lib/index.js";