@hyperjump/json-schema 0.21.0 → 0.22.0

package/dist/json-schema-umd.js

@@ -2763,13 +2763,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";
@@ -2783,19 +2792,19 @@
 	});
 
 	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`);
 	  }
@@ -2849,7 +2858,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] = {
@@ -2870,10 +2879,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`);
@@ -2896,13 +2905,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
@@ -2925,7 +2934,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) => {
@@ -2953,26 +2962,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,
 	  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;
@@ -2996,7 +2997,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];
@@ -3072,7 +3073,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;