@hyperjump/json-schema 0.20.0 → 0.23.0

package/dist/json-schema-umd.js

@@ -1915,7 +1915,7 @@
 	  return pointer.split("/").slice(1).map(unescape);
 	};
 
-	const get$1 = (pointer, value = undefined) => {
+	const get$2 = (pointer, value = undefined) => {
 	  const ptr = compile$P(pointer);
 
 	  const fn = (value) => ptr.reduce(([value, pointer], segment) => {
@@ -2034,7 +2034,7 @@
 
 	const isScalar = (value) => value === null || typeof value !== "object";
 
-	var lib$3 = { nil: nil$2, append, get: get$1, set, assign, unset, remove };
+	var lib$3 = { nil: nil$2, append, get: get$2, set, assign, unset, remove };
 
 	const $__value = Symbol("$__value");
 	const $__href = Symbol("$__href");
@@ -2058,6 +2058,15 @@
 
 	const nil$1 = Object.freeze({ id: "", pointer: "", instance: undefined, value: undefined });
 	const cons = (instance, id = "") => Object.freeze({ ...nil$1, id: resolveUrl$2(id, ""), instance, value: instance });
+
+	const get$1 = (url, instance = nil$1) => {
+	  if (!url.startsWith("#")) {
+	    throw Error(`No JSON document found at '${url.split("#")[0]}'`);
+	  }
+
+	  return Object.freeze({ ...instance, pointer: url.substr(1) });
+	};
+
 	const uri$1 = (doc) => `${doc.id}#${encodeURI(doc.pointer)}`;
 	const value$1 = (doc) => Reference$2.isReference(doc.value) ? Reference$2.value(doc.value) : doc.value;
 	const has$1 = (key, doc) => key in value$1(doc);
@@ -2077,6 +2086,9 @@
 	const map$4 = curry$8((fn, doc) => value$1(doc)
 	  .map((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
 
+	const forEach = curry$8((fn, doc) => value$1(doc)
+	  .forEach((item, ndx, array, thisArg) => fn(step$1(ndx, doc), ndx, array, thisArg)));
+
 	const filter$1 = curry$8((fn, doc) => value$1(doc)
 	  .map((item, ndx, array, thisArg) => step$1(ndx, doc))
 	  .filter((item, ndx, array, thisArg) => fn(item, ndx, array, thisArg)));
@@ -2092,7 +2104,92 @@
 
 	const length$1 = (doc) => value$1(doc).length;
 
-	var instance = { nil: nil$1, cons, uri: uri$1, value: value$1, has: has$1, typeOf: typeOf$1, step: step$1, entries: entries$3, keys: keys$1, map: map$4, filter: filter$1, reduce: reduce$3, every: every$1, some: some$1, length: length$1 };
+	var instance = {
+	  nil: nil$1, cons, get: get$1, uri: uri$1, value: value$1, has: has$1, typeOf: typeOf$1, length: length$1,
+	  step: step$1, entries: entries$3, keys: keys$1, map: map$4, forEach, filter: filter$1, reduce: reduce$3, every: every$1, some: some$1
+	};
+
+	var entries$2 = async (doc) => Object.entries(await doc);
+
+	const curry$7 = justCurryIt;
+
+
+	var map$3 = curry$7(async (fn, doc) => (await doc).map(fn));
+
+	const curry$6 = justCurryIt;
+
+
+	var reduce$2 = curry$6(async (fn, acc, doc) => {
+	  return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
+	});
+
+	const curry$5 = justCurryIt;
+	const reduce$1 = reduce$2;
+
+
+	var filter = curry$5(async (fn, doc, options = {}) => {
+	  return reduce$1(async (acc, item) => {
+	    return (await fn(item)) ? acc.concat([item]) : acc;
+	  }, [], doc, options);
+	});
+
+	const curry$4 = justCurryIt;
+	const map$2 = map$3;
+
+
+	var some = curry$4(async (fn, doc) => {
+	  const results = await map$2(fn, doc);
+	  return (await Promise.all(results))
+	    .some((a) => a);
+	});
+
+	const curry$3 = justCurryIt;
+	const map$1 = map$3;
+
+
+	var every = curry$3(async (fn, doc) => {
+	  const results = await map$1(fn, doc);
+	  return (await Promise.all(results))
+	    .every((a) => a);
+	});
+
+	const curry$2 = justCurryIt;
+
+
+	var pipeline$1 = curry$2((fns, doc) => {
+	  return fns.reduce(async (acc, fn) => fn(await acc), doc);
+	});
+
+	var all = (doc) => Promise.all(doc);
+
+	const pipeline = pipeline$1;
+	const entries$1 = entries$2;
+	const reduce = reduce$2;
+
+
+	var allValues = (doc) => {
+	  return pipeline([
+	    entries$1,
+	    reduce(async (acc, [propertyName, propertyValue]) => {
+	      acc[propertyName] = await propertyValue;
+	      return acc;
+	    }, {})
+	  ], doc);
+	};
+
+	var lib$2 = {
+	  entries: entries$2,
+	  map: map$3,
+	  filter: filter,
+	  reduce: reduce$2,
+	  some: some,
+	  every: every,
+	  pipeline: pipeline$1,
+	  all: all,
+	  allValues: allValues
+	};
+
+	var fetch_browser = fetch;
 
 	var contentType = {};
 
@@ -2148,7 +2245,7 @@
 	 */
 
 	contentType.format = format$1;
-	contentType.parse = parse;
+	contentType.parse = parse$1;
 
 	/**
 	 * Format object to media type.
@@ -2199,7 +2296,7 @@
 	 * @public
 	 */
 
-	function parse (string) {
+	function parse$1 (string) {
 	  if (!string) {
 	    throw new TypeError('argument string is required')
 	  }
@@ -2317,102 +2414,54 @@
 	  this.type = type;
 	}
 
-	var entries$2 = async (doc) => Object.entries(await doc);
-
-	const curry$7 = justCurryIt;
-
-
-	var map$3 = curry$7(async (fn, doc) => (await doc).map(fn));
-
-	const curry$6 = justCurryIt;
-
-
-	var reduce$2 = curry$6(async (fn, acc, doc) => {
-	  return (await doc).reduce(async (acc, item) => fn(await acc, item), acc);
-	});
-
-	const curry$5 = justCurryIt;
-	const reduce$1 = reduce$2;
-
-
-	var filter = curry$5(async (fn, doc, options = {}) => {
-	  return reduce$1(async (acc, item) => {
-	    return (await fn(item)) ? acc.concat([item]) : acc;
-	  }, [], doc, options);
-	});
-
-	const curry$4 = justCurryIt;
-	const map$2 = map$3;
-
-
-	var some = curry$4(async (fn, doc) => {
-	  const results = await map$2(fn, doc);
-	  return (await Promise.all(results))
-	    .some((a) => a);
-	});
-
-	const curry$3 = justCurryIt;
-	const map$1 = map$3;
-
-
-	var every = curry$3(async (fn, doc) => {
-	  const results = await map$1(fn, doc);
-	  return (await Promise.all(results))
-	    .every((a) => a);
-	});
-
-	const curry$2 = justCurryIt;
-
+	const contentTypeParser = contentType;
 
-	var pipeline$1 = curry$2((fns, doc) => {
-	  return fns.reduce(async (acc, fn) => fn(await acc), doc);
-	});
 
-	var all = (doc) => Promise.all(doc);
-
-	const pipeline = pipeline$1;
-	const entries$1 = entries$2;
-	const reduce = reduce$2;
+	const mediaTypePlugins = {};
 
+	const addPlugin = (contentType, plugin) => {
+	  mediaTypePlugins[contentType] = plugin;
+	};
 
-	var allValues = (doc) => {
-	  return pipeline([
-	    entries$1,
-	    reduce(async (acc, [propertyName, propertyValue]) => {
-	      acc[propertyName] = await propertyValue;
-	      return acc;
-	    }, {})
-	  ], doc);
+	const parse = (response) => {
+	  const contentType = contentTypeParser.parse(response.headers.get("content-type"));
+	  if (!(contentType.type in mediaTypePlugins)) {
+	    throw Error(`${response.url} is not a schema. Found a document with media type: ${contentType.type}`);
+	  }
+	  return mediaTypePlugins[contentType.type].parse(response, contentType.parameters);
 	};
 
-	var lib$2 = {
-	  entries: entries$2,
-	  map: map$3,
-	  filter: filter,
-	  reduce: reduce$2,
-	  some: some,
-	  every: every,
-	  pipeline: pipeline$1,
-	  all: all,
-	  allValues: allValues
+	const getContentType = (path) => {
+	  for (const contentType in mediaTypePlugins) {
+	    if (mediaTypePlugins[contentType].matcher(path)) {
+	      return contentType;
+	    }
+	  }
+
+	  return "application/octet-stream";
 	};
 
-	var fetch_browser = fetch;
+	var mediaTypes = { addPlugin, parse, getContentType };
 
-	const contentTypeParser = contentType;
 	const curry$1 = justCurryIt;
 	const Pact$a = lib$2;
 	const JsonPointer = lib$3;
 	const { jsonTypeOf, resolveUrl: resolveUrl$1, urlFragment, pathRelative } = common$1;
 	const fetch$1 = fetch_browser;
 	const Reference$1 = reference;
+	const MediaTypes$1 = mediaTypes;
+
 
+	const core201909Id = "https://json-schema.org/draft/2019-09/vocab/core";
+	const core202012Id = "https://json-schema.org/draft/2020-12/vocab/core";
 
 	// Config
 	const config = {};
 	const dialectJsonSchemaVersion = {};
 
 	const setConfig = (jsonSchemaVersion, key, value) => {
+	  dialectJsonSchemaVersion[jsonSchemaVersion] = jsonSchemaVersion;
+
 	  if (!config[jsonSchemaVersion]) {
 	    config[jsonSchemaVersion] = {};
 	  }
@@ -2420,10 +2469,8 @@
 	};
 
 	const getConfig = (dialectId, key) => {
-	  const jsonSchemaVersion = dialectJsonSchemaVersion[dialectId] || dialectId;
-	  if (jsonSchemaVersion in config) {
-	    return config[jsonSchemaVersion][key];
-	  }
+	  const jsonSchemaVersion = dialectJsonSchemaVersion[dialectId];
+	  return config[jsonSchemaVersion]?.[key];
 	};
 
 	// Schema Management
@@ -2432,6 +2479,7 @@
 
 	const add$1 = (schema, url = "", defaultSchemaVersion = "") => {
 	  schema = JSON.parse(JSON.stringify(schema));
+	  const externalId = resolveUrl$1(url, "");
 
 	  // Dialect / JSON Schema Version
 	  const dialectId = resolveUrl$1(schema["$schema"] || defaultSchemaVersion, "");
@@ -2440,35 +2488,45 @@
 	  }
 	  delete schema["$schema"];
 
-	  let jsonSchemaVersion;
-	  if (schema.$vocabulary?.["https://json-schema.org/draft/2019-09/vocab/core"] === true) {
-	    jsonSchemaVersion = "https://json-schema.org/draft/2019-09/vocab/core";
-	  } else if (schema.$vocabulary?.["https://json-schema.org/draft/2020-12/vocab/core"] === true) {
-	    jsonSchemaVersion = "https://json-schema.org/draft/2020-12/vocab/core";
-	  } else {
-	    jsonSchemaVersion = dialectJsonSchemaVersion[dialectId] || dialectId;
+	  // Determine JSON Schema version
+	  if (!(dialectId in dialectJsonSchemaVersion)) {
+	    if (schema?.$vocabulary?.[core201909Id] === true && dialectId === getSchemaIdentifier(schema, externalId, core201909Id)[0]) {
+	      // Self describing 2019-09 meta-schema
+	      dialectJsonSchemaVersion[dialectId] = core201909Id;
+	    } else if (schema?.$vocabulary?.[core202012Id] === true && dialectId === getSchemaIdentifier(schema, externalId, core202012Id)[0]) {
+	      // Self describing 2020-12 meta-schema
+	      dialectJsonSchemaVersion[dialectId] = core202012Id;
+	    } else {
+	      // Need to look at meta-schema to determine version
+	      const metaSchema = schemaStore[dialectId];
+	      if (!metaSchema) {
+	        throw Error(`Couldn't determine JSON Schema version for dialect: '${dialectId}'`);
+	      } else if (metaSchema.vocabulary[core201909Id] === true) {
+	        dialectJsonSchemaVersion[dialectId] = core201909Id;
+	      } else if (metaSchema.vocabulary[core202012Id] === true) {
+	        dialectJsonSchemaVersion[dialectId] = core202012Id;
+	      } else {
+	        // Assume the jsonSchemaVersion is the meta-schema's dialectId (non-standard behavior)
+	        dialectJsonSchemaVersion[dialectId] = dialectJsonSchemaVersion[metaSchema.dialectId];
+	      }
+	    }
 	  }
 
-	  // Identifier
-	  const baseToken = getConfig(jsonSchemaVersion, "baseToken");
-	  const anchorToken = getConfig(jsonSchemaVersion, "anchorToken");
-	  const externalId = resolveUrl$1(url, "");
-	  if (!externalId && !resolveUrl$1(schema[baseToken] || "", "")) {
+	  // Internal Identifier
+	  const [id, fragment] = getSchemaIdentifier(schema, externalId, dialectJsonSchemaVersion[dialectId]);
+	  if (!id) {
 	    throw Error("Couldn't determine an identifier for the schema");
 	  }
-	  const internalUrl = resolveUrl$1(externalId, schema[baseToken] || "");
-	  const id = resolveUrl$1(internalUrl, "");
-	  const fragment = urlFragment(internalUrl);
+	  const baseToken = getConfig(dialectId, "baseToken");
 	  delete schema[baseToken];
-	  if (fragment && baseToken === anchorToken) {
-	    schema[anchorToken] = anchorToken !== baseToken ? encodeURI(fragment) : `#${encodeURI(fragment)}`;
-	  }
 	  if (externalId) {
 	    schemaStoreAlias[externalId] = id;
 	  }
 
-	  // JSON Schema version
-	  dialectJsonSchemaVersion[id] = jsonSchemaVersion;
+	  const anchorToken = getConfig(dialectId, "anchorToken");
+	  if (fragment && baseToken === anchorToken) {
+	    schema[anchorToken] = anchorToken !== baseToken ? encodeURI(fragment) : `#${encodeURI(fragment)}`;
+	  }
 
 	  // recursiveAnchor
 	  const dynamicAnchors = {};
@@ -2504,6 +2562,12 @@
 	  return id;
 	};
 
+	const getSchemaIdentifier = (schema, externalId, jsonSchemaVersion) => {
+	  const baseToken = config[jsonSchemaVersion]?.["baseToken"];
+	  const internalUrl = resolveUrl$1(externalId, schema[baseToken] || "");
+	  return [resolveUrl$1(internalUrl, ""), urlFragment(internalUrl)];
+	};
+
 	const processSchema = (subject, id, dialectId, pointer, anchors, dynamicAnchors) => {
 	  if (jsonTypeOf(subject, "object")) {
 	    const embeddedSchemaDialectId = typeof subject.$schema === "string" ? resolveUrl$1(subject.$schema, "") : dialectId;
@@ -2581,14 +2645,15 @@
 	      throw Error(`Failed to retrieve schema with id: ${id}`);
 	    }
 
-	    if (response.headers.has("content-type")) {
-	      const contentType = contentTypeParser.parse(response.headers.get("content-type")).type;
-	      if (contentType !== "application/schema+json") {
-	        throw Error(`${id} is not a schema. Found a document with media type: ${contentType}`);
-	      }
+	    const [schema, defaultDialectId] = await MediaTypes$1.parse(response);
+
+	    // Make sure the meta-schema is loaded if this isn't a known dialect
+	    const dialectId = resolveUrl$1(schema.$schema, "") || defaultDialectId;
+	    if (id !== dialectId && !(dialectId in dialectJsonSchemaVersion)) {
+	      await get(dialectId);
 	    }
 
-	    add$1(await response.json(), id);
+	    add$1(schema, id);
 	  }
 
 	  const storedSchema = getStoredSchema(id);
@@ -2725,12 +2790,22 @@
 
 	var invalidSchemaError = InvalidSchemaError$3;
 
+	const Schema$R = schema$5;
+
+
+	const compile$O = (schema) => Schema$R.value(schema);
+	const interpret$O = () => true;
+
+	var metaData$4 = { compile: compile$O, interpret: interpret$O };
+
 	const curry = justCurryIt;
 	const PubSub$1 = pubsub.exports;
 	const { resolveUrl } = common$1;
 	const Instance$E = instance;
-	const Schema$R = schema$5;
+	const Schema$Q = schema$5;
 	const InvalidSchemaError$2 = invalidSchemaError;
+	const MediaTypes = mediaTypes;
+	const metaData$3 = metaData$4;
 
 
 	const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED", VERBOSE = "VERBOSE";
@@ -2738,20 +2813,28 @@
 	let metaOutputFormat = DETAILED;
 	let shouldMetaValidate = true;
 
+	MediaTypes.addPlugin("application/schema+json", {
+	  parse: async (response, contentTypeParameters) => [
+	    await response.json(),
+	    contentTypeParameters.schema || contentTypeParameters.profile
+	  ],
+	  matcher: (path) => path.endsWith(".schema.json")
+	});
+
 	const validate$2 = async (schema, value = undefined, outputFormat = undefined) => {
-	  const compiled = await compile$O(schema);
-	  const interpretAst = (value, outputFormat) => interpret$O(compiled, Instance$E.cons(value), outputFormat);
+	  const compiled = await compile$N(schema);
+	  const interpretAst = (value, outputFormat) => interpret$N(compiled, Instance$E.cons(value), outputFormat);
 
 	  return value === undefined ? interpretAst : interpretAst(value, outputFormat);
 	};
 
-	const compile$O = async (schema) => {
+	const compile$N = async (schema) => {
 	  const ast = { metaData: {} };
 	  const schemaUri = await compileSchema(schema, ast);
 	  return { ast, schemaUri };
 	};
 
-	const interpret$O = curry(({ ast, schemaUri }, value, outputFormat = FLAG) => {
+	const interpret$N = curry(({ ast, schemaUri }, value, outputFormat = FLAG) => {
 	  if (![FLAG, BASIC, DETAILED, VERBOSE].includes(outputFormat)) {
 	    throw Error(`The '${outputFormat}' error format is not supported`);
 	  }
@@ -2805,7 +2888,7 @@
 	};
 
 	const _keywords = {};
-	const getKeyword = (id) => _keywords[id];
+	const getKeyword = (id) => _keywords[id] || metaData$3;
 	const hasKeyword = (id) => id in _keywords;
 	const addKeyword = (id, keywordHandler) => {
 	  _keywords[id] = {
@@ -2826,10 +2909,10 @@
 
 	  // Vocabularies
 	  if (!hasKeyword(`${schema.dialectId}#validate`)) {
-	    const metaSchema = await Schema$R.get(schema.dialectId);
+	    const metaSchema = await Schema$Q.get(schema.dialectId);
 
 	    // Check for mandatory vocabularies
-	    const mandatoryVocabularies = Schema$R.getConfig(metaSchema.id, "mandatoryVocabularies") || [];
+	    const mandatoryVocabularies = Schema$Q.getConfig(metaSchema.id, "mandatoryVocabularies") || [];
 	    mandatoryVocabularies.forEach((vocabularyId) => {
 	      if (!metaSchema.vocabulary[vocabularyId]) {
 	        throw Error(`Vocabulary '${vocabularyId}' must be explicitly declared and required`);
@@ -2852,13 +2935,13 @@
 
 	  // Meta validation
 	  if (shouldMetaValidate && !schema.validated) {
-	    Schema$R.markValidated(schema.id);
+	    Schema$Q.markValidated(schema.id);
 
 	    // Compile
 	    if (!(schema.dialectId in metaValidators)) {
-	      const metaSchema = await Schema$R.get(schema.dialectId);
-	      const compiledSchema = await compile$O(metaSchema);
-	      metaValidators[metaSchema.id] = interpret$O(compiledSchema);
+	      const metaSchema = await Schema$Q.get(schema.dialectId);
+	      const compiledSchema = await compile$N(metaSchema);
+	      metaValidators[metaSchema.id] = interpret$N(compiledSchema);
 	    }
 
 	    // Interpret
@@ -2881,7 +2964,7 @@
 	};
 
 	const followReferences = async (doc) => {
-	  return Schema$R.typeOf(doc, "string") ? followReferences(await Schema$R.get(Schema$R.value(doc), doc)) : doc;
+	  return Schema$Q.typeOf(doc, "string") ? followReferences(await Schema$Q.get(Schema$Q.value(doc), doc)) : doc;
 	};
 
 	const interpretSchema = (schemaUri, instance, ast, dynamicAnchors) => {
@@ -2909,25 +2992,18 @@
 	};
 
 	const add = (schema, url = "", defaultSchemaVersion = "") => {
-	  const id = Schema$R.add(schema, url, defaultSchemaVersion);
+	  const id = Schema$Q.add(schema, url, defaultSchemaVersion);
 	  delete metaValidators[id];
 	};
 
 	var core$2 = {
-	  validate: validate$2, compile: compile$O, interpret: interpret$O,
+	  validate: validate$2, compile: compile$N, interpret: interpret$N,
 	  setMetaOutputFormat, setShouldMetaValidate, FLAG, BASIC, DETAILED, VERBOSE,
 	  add, getKeyword, hasKeyword, defineVocabulary,
-	  compileSchema, interpretSchema, collectEvaluatedProperties: collectEvaluatedProperties$e, collectEvaluatedItems: collectEvaluatedItems$f
+	  compileSchema, interpretSchema, collectEvaluatedProperties: collectEvaluatedProperties$e, collectEvaluatedItems: collectEvaluatedItems$f,
+	  addMediaTypePlugin: MediaTypes.addPlugin
 	};
 
-	const Schema$Q = schema$5;
-
-
-	const compile$N = (schema) => Schema$Q.value(schema);
-	const interpret$N = () => true;
-
-	var metaData$3 = { compile: compile$N, interpret: interpret$N };
-
 	const Pact$9 = lib$2;
 	const PubSub = pubsub.exports;
 	const Core$x = core$2;
@@ -2951,7 +3027,7 @@
 	      typeof schemaValue === "boolean" ? schemaValue : await Pact$9.pipeline([
 	        Schema$P.entries,
 	        Pact$9.map(([keyword, keywordSchema]) => [`${schema.dialectId}#${keyword}`, keywordSchema]),
-	        Pact$9.filter(([keywordId]) => Core$x.hasKeyword(keywordId) && keywordId !== `${schema.dialectId}#validate`),
+	        Pact$9.filter(([keywordId]) => keywordId !== `${schema.dialectId}#validate`),
 	        Pact$9.map(async ([keywordId, keywordSchema]) => {
 	          const keywordAst = await Core$x.getKeyword(keywordId).compile(keywordSchema, ast, schema);
 	          return [keywordId, Schema$P.uri(keywordSchema), keywordAst];
@@ -3027,7 +3103,7 @@
 
 	var validate$1 = { compile: compile$M, interpret: interpret$M, collectEvaluatedProperties: collectEvaluatedProperties$d, collectEvaluatedItems: collectEvaluatedItems$e };
 
-	const metaData$2 = metaData$3;
+	const metaData$2 = metaData$4;
 	const validate = validate$1;
 
 
@@ -5631,6 +5707,7 @@
 	  interpret: Core.interpret,
 	  setMetaOutputFormat: Core.setMetaOutputFormat,
 	  setShouldMetaValidate: Core.setShouldMetaValidate,
+	  addMediaTypePlugin: Core.addMediaTypePlugin,
 	  FLAG: Core.FLAG,
 	  BASIC: Core.BASIC,
 	  DETAILED: Core.DETAILED,