@hyperjump/json-schema 0.20.0 → 0.23.0

package/dist/json-schema-esm.js

@@ -1909,7 +1909,7 @@ const compile$P = (pointer) => {
   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) => {
@@ -2028,7 +2028,7 @@ const applySegment = (value, segment, cursor = "") => {
 
 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");
@@ -2052,6 +2052,15 @@ const Reference$2 = reference;
 
 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);
@@ -2071,6 +2080,9 @@ const keys$1 = (doc) => Object.keys(value$1(doc));
 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)));
@@ -2086,7 +2098,92 @@ const some$1 = curry$8((fn, doc) => value$1(doc)
 
 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 = {};
 
@@ -2142,7 +2239,7 @@ var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
  */
 
 contentType.format = format$1;
-contentType.parse = parse;
+contentType.parse = parse$1;
 
 /**
  * Format object to media type.
@@ -2193,7 +2290,7 @@ function format$1 (obj) {
  * @public
  */
 
-function parse (string) {
+function parse$1 (string) {
   if (!string) {
     throw new TypeError('argument string is required')
   }
@@ -2311,102 +2408,54 @@ function ContentType (type) {
   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] = {};
   }
@@ -2414,10 +2463,8 @@ const setConfig = (jsonSchemaVersion, key, value) => {
 };
 
 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
@@ -2426,6 +2473,7 @@ const schemaStoreAlias = {};
 
 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, "");
@@ -2434,35 +2482,45 @@ const add$1 = (schema, url = "", defaultSchemaVersion = "") => {
   }
   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 = {};
@@ -2498,6 +2556,12 @@ const add$1 = (schema, url = "", defaultSchemaVersion = "") => {
   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;
@@ -2575,14 +2639,15 @@ const get = async (url, contextDoc = nil) => {
       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);
@@ -2719,12 +2784,22 @@ class InvalidSchemaError$3 extends Error {
 
 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";
@@ -2732,20 +2807,28 @@ const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED", VERBOSE = "VERBOSE"
 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`);
   }
@@ -2799,7 +2882,7 @@ const setShouldMetaValidate = (isEnabled) => {
 };
 
 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] = {
@@ -2820,10 +2903,10 @@ const compileSchema = async (schema, ast) => {
 
   // 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`);
@@ -2846,13 +2929,13 @@ const compileSchema = async (schema, ast) => {
 
   // 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
@@ -2875,7 +2958,7 @@ const compileSchema = async (schema, ast) => {
 };
 
 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) => {
@@ -2903,25 +2986,18 @@ const getKeywordId = (schemaUri, ast) => {
 };
 
 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;
@@ -2945,7 +3021,7 @@ const compile$M = async (schema, ast) => {
       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];
@@ -3021,7 +3097,7 @@ const collectEvaluatedItems$e = (uri, instance, ast, dynamicAnchors, isTop = fal
 
 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;
 
 
@@ -5625,6 +5701,7 @@ var lib = {
   interpret: Core.interpret,
   setMetaOutputFormat: Core.setMetaOutputFormat,
   setShouldMetaValidate: Core.setShouldMetaValidate,
+  addMediaTypePlugin: Core.addMediaTypePlugin,
   FLAG: Core.FLAG,
   BASIC: Core.BASIC,
   DETAILED: Core.DETAILED,