@hyperjump/json-schema 0.23.3 → 1.0.0

package/draft-2020-12/index.js

@@ -0,0 +1,124 @@
+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 formatAnnotationMetaSchema from "./meta/format-annotation.js";
+import formatAssertionMetaSchema from "./meta/format-assertion.js";
+import contentMetaSchema from "./meta/content.js";
+import unevaluatedMetaSchema from "./meta/unevaluated.js";
+
+import contains from "../draft-2019-09/contains.js";
+import dynamicAnchor from "./dynamicAnchor.js";
+import dynamicRef from "./dynamicRef.js";
+
+
+addKeyword(contains);
+addKeyword(dynamicRef);
+addKeyword(dynamicAnchor);
+
+defineVocabulary("https://json-schema.org/draft/2020-12/vocab/core", {
+  "$anchor": "https://json-schema.org/keyword/anchor",
+  "$comment": "https://json-schema.org/keyword/comment",
+  "$defs": "https://json-schema.org/keyword/definitions",
+  "$dynamicAnchor": "https://json-schema.org/keyword/draft-2020-12/dynamicAnchor",
+  "$dynamicRef": "https://json-schema.org/keyword/draft-2020-12/dynamicRef",
+  "$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/2020-12/vocab/applicator", {
+  "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/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"
+});
+
+defineVocabulary("https://json-schema.org/draft/2020-12/vocab/validation", {
+  "const": "https://json-schema.org/keyword/const",
+  "dependentRequired": "https://json-schema.org/keyword/dependentRequired",
+  "enum": "https://json-schema.org/keyword/enum",
+  "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/2020-12/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/2020-12/vocab/format-annotation", {
+  "format": "https://json-schema.org/keyword/format"
+});
+
+defineVocabulary("https://json-schema.org/draft/2020-12/vocab/format-assertion", {
+  "format": "https://json-schema.org/keyword/format-assertion"
+});
+
+defineVocabulary("https://json-schema.org/draft/2020-12/vocab/content", {
+  "contentEncoding": "https://json-schema.org/keyword/contentEncoding",
+  "contentMediaType": "https://json-schema.org/keyword/contentMediaType",
+  "contentSchema": "https://json-schema.org/keyword/contentSchema"
+});
+
+defineVocabulary("https://json-schema.org/draft/2020-12/vocab/unevaluated", {
+  "unevaluatedItems": "https://json-schema.org/keyword/unevaluatedItems",
+  "unevaluatedProperties": "https://json-schema.org/keyword/unevaluatedProperties"
+});
+
+loadDialect("https://json-schema.org/draft/2020-12/schema", {
+  "https://json-schema.org/draft/2020-12/vocab/core": true,
+  "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+  "https://json-schema.org/draft/2020-12/vocab/validation": true,
+  "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+  "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+  "https://json-schema.org/draft/2020-12/vocab/content": true,
+  "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+}, true);
+
+addSchema(metaSchema);
+addSchema(coreMetaSchema);
+addSchema(applicatorMetaSchema);
+addSchema(validationMetaSchema);
+addSchema(metaDataMetaSchema);
+addSchema(formatAnnotationMetaSchema);
+addSchema(formatAssertionMetaSchema);
+addSchema(contentMetaSchema);
+addSchema(unevaluatedMetaSchema);
+
+export * from "../lib/index.js";

package/draft-2020-12/meta/applicator.js

@@ -0,0 +1,46 @@
+export default {
+  "$id": "https://json-schema.org/draft/2020-12/meta/applicator",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$dynamicAnchor": "meta",
+
+  "title": "Applicator vocabulary meta-schema",
+  "type": ["object", "boolean"],
+  "properties": {
+    "prefixItems": { "$ref": "#/$defs/schemaArray" },
+    "items": { "$dynamicRef": "#meta" },
+    "contains": { "$dynamicRef": "#meta" },
+    "additionalProperties": { "$dynamicRef": "#meta" },
+    "properties": {
+      "type": "object",
+      "additionalProperties": { "$dynamicRef": "#meta" },
+      "default": {}
+    },
+    "patternProperties": {
+      "type": "object",
+      "additionalProperties": { "$dynamicRef": "#meta" },
+      "propertyNames": { "format": "regex" },
+      "default": {}
+    },
+    "dependentSchemas": {
+      "type": "object",
+      "additionalProperties": {
+        "$dynamicRef": "#meta"
+      }
+    },
+    "propertyNames": { "$dynamicRef": "#meta" },
+    "if": { "$dynamicRef": "#meta" },
+    "then": { "$dynamicRef": "#meta" },
+    "else": { "$dynamicRef": "#meta" },
+    "allOf": { "$ref": "#/$defs/schemaArray" },
+    "anyOf": { "$ref": "#/$defs/schemaArray" },
+    "oneOf": { "$ref": "#/$defs/schemaArray" },
+    "not": { "$dynamicRef": "#meta" }
+  },
+  "$defs": {
+    "schemaArray": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$dynamicRef": "#meta" }
+    }
+  }
+};

package/draft-2020-12/meta/content.js

@@ -0,0 +1,14 @@
+export default {
+  "$id": "https://json-schema.org/draft/2020-12/meta/content",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$dynamicAnchor": "meta",
+
+  "title": "Content vocabulary meta-schema",
+
+  "type": ["object", "boolean"],
+  "properties": {
+    "contentMediaType": { "type": "string" },
+    "contentEncoding": { "type": "string" },
+    "contentSchema": { "$dynamicRef": "#meta" }
+  }
+};

package/draft-2020-12/meta/core.js

@@ -0,0 +1,54 @@
+export default {
+  "$id": "https://json-schema.org/draft/2020-12/meta/core",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$dynamicAnchor": "meta",
+
+  "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"
+    },
+    "$dynamicRef": {
+      "type": "string",
+      "format": "uri-reference"
+    },
+    "$dynamicAnchor": {
+      "type": "string",
+      "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
+    },
+    "$vocabulary": {
+      "type": "object",
+      "propertyNames": {
+        "type": "string",
+        "format": "uri"
+      },
+      "additionalProperties": {
+        "type": "boolean"
+      }
+    },
+    "$comment": {
+      "type": "string"
+    },
+    "$defs": {
+      "type": "object",
+      "additionalProperties": { "$dynamicRef": "#meta" },
+      "default": {}
+    }
+  }
+};

package/draft-2020-12/meta/format-annotation.js

@@ -0,0 +1,11 @@
+export default {
+  "$id": "https://json-schema.org/draft/2020-12/meta/format-annotation",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$dynamicAnchor": "meta",
+
+  "title": "Format vocabulary meta-schema for annotation results",
+  "type": ["object", "boolean"],
+  "properties": {
+    "format": { "type": "string" }
+  }
+};

package/draft-2020-12/meta/format-assertion.js

@@ -0,0 +1,11 @@
+export default {
+  "$id": "https://json-schema.org/draft/2020-12/meta/format-assertion",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$dynamicAnchor": "meta",
+
+  "title": "Format vocabulary meta-schema for assertion results",
+  "type": ["object", "boolean"],
+  "properties": {
+    "format": { "type": "string" }
+  }
+};

package/draft-2020-12/meta/meta-data.js

@@ -0,0 +1,34 @@
+export default {
+  "$id": "https://json-schema.org/draft/2020-12/meta/meta-data",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$dynamicAnchor": "meta",
+
+  "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-2020-12/meta/unevaluated.js

@@ -0,0 +1,12 @@
+export default {
+  "$id": "https://json-schema.org/draft/2020-12/meta/unevaluated",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$dynamicAnchor": "meta",
+
+  "title": "Unevaluated applicator vocabulary meta-schema",
+  "type": ["object", "boolean"],
+  "properties": {
+    "unevaluatedItems": { "$dynamicRef": "#meta" },
+    "unevaluatedProperties": { "$dynamicRef": "#meta" }
+  }
+};

package/draft-2020-12/meta/validation.js

@@ -0,0 +1,95 @@
+export default {
+  "$id": "https://json-schema.org/draft/2020-12/meta/validation",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$dynamicAnchor": "meta",
+
+  "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-2020-12/schema.js

@@ -0,0 +1,44 @@
+export default {
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://json-schema.org/draft/2020-12/schema",
+  "$vocabulary": {
+    "https://json-schema.org/draft/2020-12/vocab/core": true,
+    "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+    "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+    "https://json-schema.org/draft/2020-12/vocab/validation": true,
+    "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+    "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+    "https://json-schema.org/draft/2020-12/vocab/content": true
+  },
+  "$dynamicAnchor": "meta",
+
+  "title": "Core and Validation specifications meta-schema",
+  "allOf": [
+    { "$ref": "meta/core" },
+    { "$ref": "meta/applicator" },
+    { "$ref": "meta/unevaluated" },
+    { "$ref": "meta/validation" },
+    { "$ref": "meta/meta-data" },
+    { "$ref": "meta/format-annotation" },
+    { "$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": { "$dynamicRef": "#meta" },
+      "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": [
+          { "$dynamicRef": "#meta" },
+          { "$ref": "meta/validation#/$defs/stringArray" }
+        ]
+      }
+    }
+  }
+};

package/lib/common.d.ts

@@ -1 +1,5 @@
-export type JsonSchemaType = "object" | "array" | "string" | "number" | "integer" | "boolean" | "null";
+export type JsonType = "object" | "array" | "string" | "number" | "boolean" | "null";
+export type JsonSchemaType = JsonType | "integer";
+
+type PathRelative = (from: string, to: string) => string;
+export const pathRelative: PathRelative;

package/lib/common.js

@@ -1,13 +1,84 @@
 const isObject = (value) => typeof value === "object" && !Array.isArray(value) && value !== null;
-const escapeRegExp = (string) => string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&");
-
-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);
+const isType = {
+  null: (value) => value === null,
+  boolean: (value) => typeof value === "boolean",
+  object: isObject,
+  array: (value) => Array.isArray(value),
+  number: (value) => typeof value === "number",
+  integer: (value) => Number.isInteger(value),
+  string: (value) => typeof value === "string"
+};
+export const jsonTypeOf = (value, type) => isType[type](value);
 
-  return [decodeURI(urlReference), decodeURI(urlFragment)];
+export const resolveUrl = (url, baseUri = undefined) => {
+  const resolved = new URL(url, baseUri);
+  if (baseUri && new URL("", baseUri).protocol !== "file:" && resolved.protocol === "file:") {
+    throw Error(`Can't access file '${resolved.href}' resource from network context '${baseUri}'`);
+  }
+  return resolved.href;
 };
 
-module.exports = { isObject, escapeRegExp, splitUrl };
+export const urlFragment = (url) => decodeURIComponent(new URL(url).hash.slice(1));
+
+const CHAR_BACKWARD_SLASH = 47;
+
+export const pathRelative = (from, to) => {
+  if (from === to) {
+    return "";
+  }
+
+  let toStart = 1;
+  const fromLen = from.length - 1;
+  const toLen = to.length - toStart;
+
+  // Compare paths to find the longest common path from root
+  const length = fromLen < toLen ? fromLen : toLen;
+  let lastCommonSep = -1;
+  let i = 0;
+  for (; i < length; i++) {
+    const fromCode = from.charCodeAt(i + 1);
+    if (fromCode !== to.charCodeAt(toStart + i)) {
+      break;
+    } else if (fromCode === CHAR_BACKWARD_SLASH) {
+      lastCommonSep = i;
+    }
+  }
+
+  if (toLen > length) {
+    if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
+      return to.slice(toStart + i + 1);
+    }
+    if (i === 0) {
+      return to.slice(toStart + i);
+    }
+  }
+  if (fromLen > length) {
+    if (from.charCodeAt(i + 1) === CHAR_BACKWARD_SLASH) {
+      lastCommonSep = i;
+    } else if (length === 0) {
+      lastCommonSep = 0;
+    }
+  }
+
+  let out = "";
+  // Generate the relative path based on the path difference between `to` and `from`
+  for (i = lastCommonSep + 2; i <= from.length; ++i) {
+    if (i === from.length || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
+      out += out.length === 0 ? ".." : "/..";
+    }
+  }
+
+  toStart += lastCommonSep;
+
+  // Lastly, append the rest of the destination (`to`) path that comes after
+  // the common path parts
+  if (out.length > 0) {
+    return `${out}${to.slice(toStart, to.length)}`;
+  }
+
+  if (to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
+    ++toStart;
+  }
+
+  return to.slice(toStart, to.length);
+};

package/lib/configuration.d.ts

@@ -0,0 +1,9 @@
+import type { OutputFormat } from "./core.js";
+
+
+export const setMetaSchemaOutputFormat: (format: OutputFormat) => void;
+export const getMetaSchemaOutputFormat: () => OutputFormat;
+export const setShouldValidateSchema: (isEnabled: boolean) => void;
+export const getShouldValidateSchema: () => boolean;
+export const setExperimentalKeywordEnabled: (keywordId: string, isEnabled: boolean) => void;
+export const isExperimentalKeywordEnabled: (keywordId: string) => boolean;

package/lib/configuration.js

@@ -0,0 +1,18 @@
+let metaSchemaOutputFormat;
+let shouldValidateSchema = true;
+let enabledExperimentalKeywords = {};
+
+export const getMetaSchemaOutputFormat = () => metaSchemaOutputFormat;
+export const setMetaSchemaOutputFormat = (format) => {
+  metaSchemaOutputFormat = format;
+};
+
+export const getShouldValidateSchema = () => shouldValidateSchema;
+export const setShouldValidateSchema = (isEnabled) => {
+  shouldValidateSchema = isEnabled;
+};
+
+export const isExperimentalKeywordEnabled = (keywordId) => enabledExperimentalKeywords[keywordId];
+export const setExperimentalKeywordEnabled = (keywordId, isEnabled) => {
+  enabledExperimentalKeywords[keywordId] = isEnabled;
+};

package/lib/core.d.ts

@@ -0,0 +1,48 @@
+import type { add, Anchors } from "./schema.js";
+
+
+export const validate: (
+  (url: string, value: unknown, outputFormat?: OutputFormat) => Promise<OutputUnit>
+) & (
+  (url: string) => Promise<Validator>
+);
+export const compile: (url: string) => Promise<CompiledSchema>;
+export const interpret: (
+  (compiledSchema: CompiledSchema, value: unknown, outputFormat?: OutputFormat) => OutputUnit
+) & (
+  (compiledSchema: CompiledSchema) => Validator
+);
+export const FLAG: "FLAG";
+export const BASIC: "BASIC";
+export const DETAILED: "DETAILED";
+export const VERBOSE: "VERBOSE";
+export const addSchema: typeof add;
+
+export type Validator = (value: unknown, outputFormat?: OutputFormat) => OutputUnit;
+
+export type OutputFormat = "FLAG" | "BASIC" | "DETAILED" | "VERBOSE" | string;
+
+export type OutputUnit = {
+  keyword: string;
+  absoluteKeywordLocation: string;
+  instanceLocation: string;
+  valid: boolean;
+  errors?: OutputUnit[];
+};
+
+export type CompiledSchema = {
+  schemaUri: string;
+  ast: AST;
+};
+
+type AST = {
+  metaData: Record<string, MetaData>;
+} & Record<string, Node<Node<unknown>[] | boolean>>;
+
+type Node<A> = [keywordId: string, schemaUri: string, keywordValue: A];
+
+type MetaData = {
+  id: string;
+  dynamicAnchors: Anchors;
+  anchors: Anchors;
+};