@hyperjump/json-schema 1.6.7 → 1.7.0

package/lib/keywords/minProperties.js

@@ -1,12 +1,12 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/minProperties";
 
-const compile = (schema) => Schema.value(schema);
+const compile = (schema) => Browser.value(schema);
 const interpret = (minProperties, instance) => {
-  return !Instance.typeOf(instance, "object") || [...Instance.keys(instance)].length >= minProperties;
+  return Instance.typeOf(instance) !== "object" || [...Instance.keys(instance)].length >= minProperties;
 };
 
 export default { id, compile, interpret };

package/lib/keywords/minimum.js

@@ -1,10 +1,10 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/minimum";
 
-const compile = (schema) => Schema.value(schema);
-const interpret = (minimum, instance) => !Instance.typeOf(instance, "number") || Instance.value(instance) >= minimum;
+const compile = (schema) => Browser.value(schema);
+const interpret = (minimum, instance) => Instance.typeOf(instance) !== "number" || Instance.value(instance) >= minimum;
 
 export default { id, compile, interpret };

package/lib/keywords/multipleOf.js

@@ -1,13 +1,13 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/multipleOf";
 
-const compile = (schema) => Schema.value(schema);
+const compile = (schema) => Browser.value(schema);
 
 const interpret = (multipleOf, instance) => {
-  if (!Instance.typeOf(instance, "number")) {
+  if (Instance.typeOf(instance) !== "number") {
     return true;
   }
 

package/lib/keywords/not.js

@@ -1,4 +1,4 @@
-import Validation from "./validation.js";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/not";

package/lib/keywords/oneOf.js

@@ -1,12 +1,12 @@
 import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
-import Validation from "./validation.js";
+import * as Browser from "@hyperjump/browser";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/oneOf";
 
 const compile = (schema, ast) => pipe(
-  Schema.iter(schema),
+  Browser.iter(schema),
   asyncMap((itemSchema) => Validation.compile(itemSchema, ast)),
   asyncCollectArray
 );

package/lib/keywords/pattern.js

@@ -1,10 +1,10 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/pattern";
 
-const compile = (schema) => new RegExp(Schema.value(schema), "u");
-const interpret = (pattern, instance) => !Instance.typeOf(instance, "string") || pattern.test(Instance.value(instance));
+const compile = (schema) => new RegExp(Browser.value(schema), "u");
+const interpret = (pattern, instance) => Instance.typeOf(instance) !== "string" || pattern.test(Instance.value(instance));
 
 export default { id, compile, interpret };

package/lib/keywords/patternProperties.js

@@ -1,13 +1,13 @@
 import { pipe, asyncMap, asyncCollectArray, filter, every } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
-import Validation from "./validation.js";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/patternProperties";
 
 const compile = (schema, ast) => pipe(
-  Schema.entries(schema),
+  Browser.entries(schema),
   asyncMap(async ([pattern, propertySchema]) => [
     new RegExp(pattern, "u"),
     await Validation.compile(propertySchema, ast)
@@ -16,7 +16,7 @@ const compile = (schema, ast) => pipe(
 );
 
 const interpret = (patternProperties, instance, ast, dynamicAnchors, quiet) => {
-  return !Instance.typeOf(instance, "object") || patternProperties.every(([pattern, schemaUrl]) => {
+  return Instance.typeOf(instance) !== "object" || patternProperties.every(([pattern, schemaUrl]) => {
     return pipe(
       Instance.entries(instance),
       filter(([propertyName]) => pattern.test(propertyName)),
@@ -26,7 +26,7 @@ const interpret = (patternProperties, instance, ast, dynamicAnchors, quiet) => {
 };
 
 const collectEvaluatedProperties = (patternProperties, instance, ast, dynamicAnchors) => {
-  if (!Instance.typeOf(instance, "object")) {
+  if (Instance.typeOf(instance) !== "object") {
     return false;
   }
 

package/lib/keywords/prefixItems.js

@@ -1,19 +1,19 @@
 import { pipe, asyncMap, asyncCollectArray, every, zip, take } from "@hyperjump/pact";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
-import * as Schema from "../schema.js";
-import Validation from "./validation.js";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/prefixItems";
 
 const compile = (schema, ast) => pipe(
-  Schema.iter(schema),
+  Browser.iter(schema),
   asyncMap((itemSchema) => Validation.compile(itemSchema, ast)),
   asyncCollectArray
 );
 
 const interpret = (prefixItems, instance, ast, dynamicAnchors, quiet) => {
-  return !Instance.typeOf(instance, "array") || pipe(
+  return Instance.typeOf(instance) !== "array" || pipe(
     zip(prefixItems, Instance.iter(instance)),
     take(Instance.length(instance)),
     every(([prefixItem, item]) => Validation.interpret(prefixItem, item, ast, dynamicAnchors, quiet))
@@ -21,7 +21,7 @@ const interpret = (prefixItems, instance, ast, dynamicAnchors, quiet) => {
 };
 
 const collectEvaluatedItems = (items, instance, ast, dynamicAnchors) => {
-  return interpret(items, instance, ast, dynamicAnchors, true) && new Set(items.map((item, ndx) => ndx));
+  return interpret(items, instance, ast, dynamicAnchors, true) && new Set(items.map((_item, ndx) => ndx));
 };
 
 export default { id, compile, interpret, collectEvaluatedItems };

package/lib/keywords/properties.js

@@ -1,19 +1,19 @@
 import { pipe, asyncMap, asyncCollectObject, filter, every } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
-import Validation from "./validation.js";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/properties";
 
 const compile = (schema, ast) => pipe(
-  Schema.entries(schema),
+  Browser.entries(schema),
   asyncMap(async ([propertyName, propertySchema]) => [propertyName, await Validation.compile(propertySchema, ast)]),
   asyncCollectObject
 );
 
 const interpret = (properties, instance, ast, dynamicAnchors, quiet) => {
-  return !Instance.typeOf(instance, "object") || pipe(
+  return Instance.typeOf(instance) !== "object" || pipe(
     Instance.entries(instance),
     filter(([propertyName]) => propertyName in properties),
     every(([propertyName, property]) => Validation.interpret(properties[propertyName], property, ast, dynamicAnchors, quiet))
@@ -21,7 +21,7 @@ const interpret = (properties, instance, ast, dynamicAnchors, quiet) => {
 };
 
 const collectEvaluatedProperties = (properties, instance, ast, dynamicAnchors) => {
-  if (!Instance.typeOf(instance, "object")) {
+  if (Instance.typeOf(instance) !== "object") {
     return false;
   }
 

package/lib/keywords/propertyDependencies.js

@@ -1,18 +1,17 @@
 import { pipe, asyncMap, asyncCollectObject } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
-import Validation from "./validation.js";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/propertyDependencies";
-const experimental = true;
 
 const compile = (schema, ast) => {
   return pipe(
-    Schema.entries(schema),
+    Browser.entries(schema),
     asyncMap(async ([propertyName, valueMappings]) => {
       return [propertyName, await pipe(
-        Schema.entries(valueMappings),
+        Browser.entries(valueMappings),
         asyncMap(async ([propertyValue, conditionalSchema]) => [propertyValue, await Validation.compile(conditionalSchema, ast)]),
         asyncCollectObject
       )];
@@ -22,7 +21,7 @@ const compile = (schema, ast) => {
 };
 
 const interpret = (propertyDependencies, instance, ast, dynamicAnchors, quiet) => {
-  return !Instance.typeOf(instance, "object") || Object.entries(propertyDependencies).every(([propertyName, valueMappings]) => {
+  return Instance.typeOf(instance) !== "object" || Object.entries(propertyDependencies).every(([propertyName, valueMappings]) => {
     const propertyValue = Instance.value(instance)[propertyName];
     return !Instance.has(propertyName, instance)
       || !(propertyValue in valueMappings)
@@ -44,4 +43,4 @@ const collectEvaluatedProperties = (propertyDependencies, instance, ast, dynamic
     }, []);
 };
 
-export default { id, experimental, compile, interpret, collectEvaluatedProperties };
+export default { id, compile, interpret, collectEvaluatedProperties };

package/lib/keywords/propertyNames.js

@@ -1,6 +1,6 @@
 import { every } from "@hyperjump/pact";
 import * as Instance from "../instance.js";
-import Validation from "./validation.js";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/propertyNames";
@@ -8,7 +8,7 @@ const id = "https://json-schema.org/keyword/propertyNames";
 const compile = (schema, ast) => Validation.compile(schema, ast);
 
 const interpret = (propertyNames, instance, ast, dynamicAnchors) => {
-  return !Instance.typeOf(instance, "object") || every((key) => {
+  return Instance.typeOf(instance) !== "object" || every((key) => {
     return Validation.interpret(propertyNames, Instance.cons(key), ast, dynamicAnchors, true);
   }, Instance.keys(instance));
 };

package/lib/keywords/ref.js

@@ -1,14 +1,9 @@
-import * as Schema from "../schema.js";
-import Validation from "./validation.js";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/ref";
 
-const compile = async (ref, ast) => {
-  const referencedSchema = await Schema.get(Schema.value(ref), ref);
-  return Validation.compile(referencedSchema, ast);
-};
-
+const compile = Validation.compile;
 const interpret = Validation.interpret;
 const collectEvaluatedProperties = Validation.collectEvaluatedProperties;
 const collectEvaluatedItems = Validation.collectEvaluatedItems;

package/lib/keywords/requireAllExcept.js

@@ -1,16 +1,15 @@
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
-import { getKeywordName } from "../keywords.js";
-import * as Schema from "../schema.js";
+import { getKeywordName } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/requireAllExcept";
-const experimental = true;
 
-const compile = async (schema, ast, parentSchema) => {
-  const requireAllExcept = await Schema.value(schema);
+const compile = async (schema, _ast, parentSchema) => {
+  const requireAllExcept = await Browser.value(schema);
   const propertiesKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/properties");
-  const propertiesSchema = await Schema.step(propertiesKeyword, parentSchema);
-  const propertyNames = Schema.typeOf(propertiesSchema, "object") ? Schema.keys(propertiesSchema) : [];
+  const propertiesSchema = await Browser.step(propertiesKeyword, parentSchema);
+  const propertyNames = Browser.typeOf(propertiesSchema) === "object" ? Browser.keys(propertiesSchema) : [];
 
   const required = new Set(propertyNames);
   requireAllExcept.forEach((propertyName) => propertyNames.remove(propertyName));
@@ -18,7 +17,7 @@ const compile = async (schema, ast, parentSchema) => {
 };
 
 const interpret = (required, instance) => {
-  return !Instance.typeOf(instance, "object") || required.every((propertyName) => Object.hasOwn(Instance.value(instance), propertyName));
+  return Instance.typeOf(instance) !== "object" || required.every((propertyName) => Object.hasOwn(Instance.value(instance), propertyName));
 };
 
-export default { id, experimental, compile, interpret };
+export default { id, compile, interpret };

package/lib/keywords/required.js

@@ -1,13 +1,13 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/required";
 
-const compile = (schema) => Schema.value(schema);
+const compile = (schema) => Browser.value(schema);
 
 const interpret = (required, instance) => {
-  return !Instance.typeOf(instance, "object") || required.every((propertyName) => Object.hasOwn(Instance.value(instance), propertyName));
+  return Instance.typeOf(instance) !== "object" || required.every((propertyName) => Object.hasOwn(Instance.value(instance), propertyName));
 };
 
 export default { id, compile, interpret };

package/lib/keywords/then.js

@@ -1,14 +1,14 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import { getKeywordName } from "../keywords.js";
-import Validation from "./validation.js";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/then";
 
 const compile = async (schema, ast, parentSchema) => {
-  const ifKeyword = getKeywordName(schema.dialectId, "https://json-schema.org/keyword/if");
-  if (Schema.has(ifKeyword, parentSchema)) {
-    const ifSchema = await Schema.step(ifKeyword, parentSchema);
+  const ifKeyword = getKeywordName(schema.document.dialectId, "https://json-schema.org/keyword/if");
+  if (Browser.has(ifKeyword, parentSchema)) {
+    const ifSchema = await Browser.step(ifKeyword, parentSchema);
     return [await Validation.compile(ifSchema, ast), await Validation.compile(schema, ast)];
   } else {
     return [];

package/lib/keywords/type.js

@@ -1,10 +1,16 @@
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/type";
 
-const compile = (schema) => Schema.value(schema);
-const interpret = (type, instance) => typeof type === "string" ? Instance.typeOf(instance, type) : type.some(Instance.typeOf(instance));
+const compile = (schema) => Browser.value(schema);
+const interpret = (type, instance) => typeof type === "string"
+  ? isTypeOf(instance)(type)
+  : type.some(isTypeOf(instance));
+
+const isTypeOf = (instance) => (type) => type === "integer"
+  ? Instance.typeOf(instance) === "number" && Number.isInteger(Instance.value(instance))
+  : Instance.typeOf(instance) === type;
 
 export default { id, compile, interpret };

package/lib/keywords/unevaluatedItems.js

@@ -1,17 +1,17 @@
 import { pipe, filter, every, zip, range } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
+import { canonicalUri } from "../schema.js";
 import * as Instance from "../instance.js";
-import Validation from "./validation.js";
+import { Validation } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/unevaluatedItems";
 
 const compile = async (schema, ast, parentSchema) => {
-  return [Schema.uri(parentSchema), await Validation.compile(schema, ast)];
+  return [canonicalUri(parentSchema), await Validation.compile(schema, ast)];
 };
 
 const interpret = ([schemaUrl, unevaluatedItems], instance, ast, dynamicAnchors, quiet) => {
-  if (!Instance.typeOf(instance, "array")) {
+  if (Instance.typeOf(instance) !== "array") {
     return true;
   }
 

package/lib/keywords/unevaluatedProperties.js

@@ -1,17 +1,16 @@
 import { pipe, filter, every } from "@hyperjump/pact";
-import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
-import Validation from "./validation.js";
+import { Validation, canonicalUri } from "../experimental.js";
 
 
 const id = "https://json-schema.org/keyword/unevaluatedProperties";
 
 const compile = async (schema, ast, parentSchema) => {
-  return [Schema.uri(parentSchema), await Validation.compile(schema, ast)];
+  return [canonicalUri(parentSchema), await Validation.compile(schema, ast)];
 };
 
 const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnchors, quiet) => {
-  if (!Instance.typeOf(instance, "object")) {
+  if (Instance.typeOf(instance) !== "object") {
     return true;
   }
 
@@ -25,7 +24,7 @@ const interpret = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnc
 };
 
 const collectEvaluatedProperties = ([schemaUrl, unevaluatedProperties], instance, ast, dynamicAnchors) => {
-  if (!Instance.typeOf(instance, "object")) {
+  if (Instance.typeOf(instance) !== "object") {
     return true;
   }
 

package/lib/keywords/uniqueItems.js

@@ -1,14 +1,14 @@
 import jsonStringify from "fastest-stable-stringify";
-import * as Schema from "../schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../instance.js";
 
 
 const id = "https://json-schema.org/keyword/uniqueItems";
 
-const compile = (schema) => Schema.value(schema);
+const compile = (schema) => Browser.value(schema);
 
 const interpret = (uniqueItems, instance) => {
-  if (!Instance.typeOf(instance, "array") || uniqueItems === false) {
+  if (Instance.typeOf(instance) !== "array" || uniqueItems === false) {
     return true;
   }
 

package/lib/keywords/validation.js

@@ -1,10 +1,10 @@
+import { value, entries } from "@hyperjump/browser";
 import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
+import { append as pointerAppend } from "@hyperjump/json-pointer";
 import { publishAsync, publish } from "../pubsub.js";
-import { isExperimentalKeywordEnabled } from "../configuration.js";
 import * as Instance from "../instance.js";
-import { getKeywordId, getKeyword } from "../keywords.js";
 import { toAbsoluteUri } from "../common.js";
-import * as Schema from "../schema.js";
+import { canonicalUri, getKeyword, getKeywordByName } from "../experimental.js";
 
 
 const id = "https://json-schema.org/evaluation/validate";
@@ -14,40 +14,28 @@ const compile = async (schema, ast) => {
   await publishAsync("validate.metaValidate", schema);
 
   // Dynamic Scope
-  if (!(schema.id in ast.metaData)) {
-    ast.metaData[schema.id] = {
-      dynamicAnchors: schema.dynamicAnchors
+  if (!(schema.document.baseUri in ast.metaData)) {
+    ast.metaData[schema.document.baseUri] = {
+      dynamicAnchors: schema.document.dynamicAnchors
     };
   }
 
   // Compile
-  const url = Schema.uri(schema);
+  const url = canonicalUri(schema);
   if (!(url in ast)) {
     ast[url] = false; // Place dummy entry in ast to avoid recursive loops
 
-    const schemaValue = Schema.value(schema);
+    const schemaValue = value(schema);
     if (!["object", "boolean"].includes(typeof schemaValue)) {
       throw Error(`No schema found at '${url}'`);
     }
 
     ast[url] = typeof schemaValue === "boolean" ? schemaValue : await pipe(
-      Schema.entries(schema),
+      entries(schema),
       asyncMap(async ([keyword, keywordSchema]) => {
-        const keywordId = getKeywordId(schema.dialectId, keyword);
-        if (!keywordId) {
-          throw Error(`Encountered unknown keyword '${keyword}' at ${url}`);
-        }
-
-        const keywordHandler = getKeyword(keywordId);
-        if (!keywordHandler) {
-          throw Error(`Encountered unsupported keyword ${keyword} at '${url}'. You can provide an implementation for the '${keywordId}' keyword using the 'addKeyword' function.`);
-        }
-        if (keywordHandler.experimental && !isExperimentalKeywordEnabled(keywordId)) {
-          throw Error(`Encountered experimental keyword ${keyword} at '${url}'. You can enable this keyword with: setExperimentalKeywordEnabled('${keywordId}', true)`);
-        }
-
+        const keywordHandler = getKeywordByName(keyword, schema.document.dialectId);
         const keywordAst = await keywordHandler.compile(keywordSchema, ast, schema);
-        return [keywordId, Schema.uri(keywordSchema), keywordAst];
+        return [keywordHandler.id, pointerAppend(keyword, canonicalUri(schema)), keywordAst];
       }),
       asyncCollectArray
     );

package/lib/keywords.js

@@ -4,6 +4,20 @@ import { toAbsoluteUri } from "./common.js";
 const _keywords = {};
 export const getKeyword = (id) => _keywords[toAbsoluteUri(id)];
 
+export const getKeywordByName = (keyword, dialectId) => {
+  const keywordId = getKeywordId(keyword, dialectId);
+  if (!keywordId) {
+    throw Error(`Encountered unknown keyword '${keyword}'`);
+  }
+
+  const keywordHandler = getKeyword(keywordId);
+  if (!keywordHandler) {
+    throw Error(`Encountered unsupported keyword ${keyword}. You can provide an implementation for the '${keywordId}' keyword using the 'addKeyword' function.`);
+  }
+
+  return keywordHandler;
+};
+
 export const addKeyword = (keywordHandler) => {
   _keywords[keywordHandler.id] = keywordHandler;
 };
@@ -16,26 +30,25 @@ export const defineVocabulary = (id, keywords) => {
 const _dialects = {};
 const _allowUnknownKeywords = {};
 
-export const getKeywordId = (dialectId, keyword) => {
-  if (!hasDialect(dialectId)) {
-    throw Error(`Encountered unknown dialect '${dialectId}'`);
-  }
+export const getKeywordId = (keyword, dialectId) => getDialect(dialectId)?.[keyword]
+  || (_allowUnknownKeywords[dialectId] || keyword.startsWith("x-"))
+  && `https://json-schema.org/keyword/unknown#${keyword}`;
 
-  return _dialects[dialectId]?.[keyword]
-    || (_allowUnknownKeywords[dialectId] || keyword.startsWith("x-"))
-    && `https://json-schema.org/keyword/unknown#${keyword}`;
+export const getKeywordName = (dialectId, keywordId) => {
+  const dialect = getDialect(dialectId);
+  for (const keyword in dialect) {
+    if (dialect[keyword] === keywordId) {
+      return keyword;
+    }
+  }
 };
 
-export const getKeywordName = (dialectId, keywordId) => {
-  if (!hasDialect(dialectId)) {
+const getDialect = (dialectId) => {
+  if (!(dialectId in _dialects)) {
     throw Error(`Encountered unknown dialect '${dialectId}'`);
   }
 
-  for (const keyword in _dialects[dialectId]) {
-    if (_dialects[dialectId][keyword] === keywordId) {
-      return keyword;
-    }
-  }
+  return _dialects[dialectId];
 };
 
 export const hasDialect = (dialectId) => dialectId in _dialects;

package/lib/openapi.js

@@ -1,15 +1,18 @@
-import { addMediaTypePlugin } from "./media-types.js";
+import contentTypeParser from "content-type";
+import { addMediaTypePlugin } from "@hyperjump/browser";
+import { buildSchemaDocument } from "./schema.js";
 
 
 const is31 = RegExp.prototype.test.bind(/^3\.1\.\d+(-.+)?$/);
 const is30 = RegExp.prototype.test.bind(/^3\.0\.\d+(-.+)?$/);
 
 addMediaTypePlugin("application/openapi+json", {
-  parse: async (response, contentTypeParameters) => {
+  parse: async (response) => {
     const doc = await response.json();
 
     let defaultDialect;
-    const version = doc.openapi || contentTypeParameters.version;
+    const contentType = contentTypeParser.parse(response.headers.get("content-type") ?? "");
+    const version = doc.openapi || contentType.parameters.version;
 
     if (!version) {
       throw Error("Invalid OpenAPI document. Add the 'openapi' field and try again.");
@@ -18,14 +21,24 @@ addMediaTypePlugin("application/openapi+json", {
     } else if (is31(version)) {
       if (!("jsonSchemaDialect" in doc) || doc.jsonSchemaDialect === "https://spec.openapis.org/oas/3.1/dialect/base") {
         defaultDialect = "https://spec.openapis.org/oas/3.1/schema-base";
+      } else if (doc.jsonSchemaDialect === "https://json-schema.org/draft/2020-12/schema") {
+        defaultDialect = `https://spec.openapis.org/oas/3.1/schema-draft-2020-12`;
+      } else if (doc.jsonSchemaDialect === "https://json-schema.org/draft/2019-09/schema") {
+        defaultDialect = `https://spec.openapis.org/oas/3.1/schema-draft-2019-09`;
+      } else if (doc.jsonSchemaDialect === "http://json-schema.org/draft-07/schema#") {
+        defaultDialect = `https://spec.openapis.org/oas/3.1/schema-draft-07`;
+      } else if (doc.jsonSchemaDialect === "http://json-schema.org/draft-06/schema#") {
+        defaultDialect = `https://spec.openapis.org/oas/3.1/schema-draft-06`;
+      } else if (doc.jsonSchemaDialect === "http://json-schema.org/draft-04/schema#") {
+        defaultDialect = `https://spec.openapis.org/oas/3.1/schema-draft-04`;
       } else {
-        defaultDialect = `https://spec.openapis.org/oas/3.1/schema-${encodeURIComponent(doc.jsonSchemaDialect)}`;
+        defaultDialect = `https://spec.openapis.org/oas/3.1/schema?${encodeURIComponent(doc.jsonSchemaDialect)}`;
       }
     } else {
       throw Error(`Encountered unsupported OpenAPI version '${version}' in ${response.url}`);
     }
 
-    return [doc, defaultDialect];
+    return buildSchemaDocument(doc, response.url, defaultDialect);
   },
-  matcher: (path) => /(\/|\.)openapi\.json$/.test(path)
+  fileMatcher: (path) => /(\/|\.)openapi\.json$/.test(path)
 });