@hyperjump/json-schema 0.21.0 → 0.22.0

package/dist/json-schema-esm.js

@@ -2757,13 +2757,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";
@@ -2777,19 +2786,19 @@ MediaTypes.addPlugin("application/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`);
   }
@@ -2843,7 +2852,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] = {
@@ -2864,10 +2873,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`);
@@ -2890,13 +2899,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
@@ -2919,7 +2928,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) => {
@@ -2947,26 +2956,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,
   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;
@@ -2990,7 +2991,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];
@@ -3066,7 +3067,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;