@hyperjump/json-schema 1.6.7 → 1.7.0

package/lib/schema.js

@@ -1,44 +1,91 @@
-import { nil as nilPointer, append as pointerAppend, get as pointerGet } from "@hyperjump/json-pointer";
-import { toAbsoluteIri } from "@hyperjump/uri";
-import { jsonTypeOf, resolveUri, uriFragment, pathRelative, jsonStringify } from "./common.js";
-import { contextUri } from "./context-uri.js";
-import fetch from "./fetch.js";
-import { hasDialect, loadDialect, getKeywordName } from "./keywords.js";
-import { parseResponse, acceptableMediaTypes } from "./media-types.js";
-import * as Reference from "./reference.js";
+import contentTypeParser from "content-type";
+import { get as browserGet } from "@hyperjump/browser";
+import { Reference } from "@hyperjump/browser/jref";
+import { append } from "@hyperjump/json-pointer";
+import { resolveIri, toAbsoluteIri, normalizeIri } from "@hyperjump/uri";
+import { getKeywordName, loadDialect } from "./keywords.js";
+import { uriFragment, jsonStringify, jsonTypeOf, toRelativeIri } from "./common.js";
+
+
+export const schemaPlugin = {
+  parse: async (response) => {
+    const contentType = contentTypeParser.parse(response.headers.get("content-type") ?? "");
+    const contextDialectId = contentType.parameters.schema ?? contentType.parameters.profile;
+
+    return buildSchemaDocument(await response.json(), response.url, contextDialectId);
+  },
+  fileMatcher: (path) => path.endsWith(".schema.json")
+};
+
+const schemaRegistry = {};
 
+export const getSchema = async (uri, browser = undefined) => {
+  if (!browser) {
+    const cache = {};
+
+    for (const uri in schemaRegistry) {
+      cache[uri] = schemaRegistry[uri];
+    }
 
-// Schema Management
-const schemaStore = {};
-const schemaStoreAlias = {};
+    browser = { _cache: cache };
+  }
+
+  const schema = await browserGet(uri, browser);
+  if (typeof schema.document.dialectId !== "string") {
+    throw Error(`The document at ${schema.document.baseUri} is not a schema.`);
+  }
 
-export const add = (schema, retrievalUri = undefined, contextDialectId = undefined) => {
-  schema = JSON.parse(JSON.stringify(schema));
+  return schema;
+};
+
+export const registerSchema = (schema, retrievalUri, contextDialectId) => {
+  schema = structuredClone(schema);
+  const document = buildSchemaDocument(schema, retrievalUri, contextDialectId);
+
+  if (document.baseUri in schemaRegistry) {
+    throw Error(`A schema has already been registered for '${document.baseUri}. You can use 'unregisterSchema' to remove the old schema before registering the new one.`);
+  }
+
+  if (document.baseUri.startsWith("file:")) {
+    throw Error(`Registering a schema with a 'file:' URI scheme is not allowed: ${document.baseUri}`);
+  }
 
+  schemaRegistry[retrievalUri ? toAbsoluteIri(retrievalUri) : document.baseUri] = document;
+};
+
+export const unregisterSchema = (uri) => {
+  delete schemaRegistry[toAbsoluteIri(uri)];
+};
+
+export const buildSchemaDocument = (schema, id, dialectId, embedded = {}) => {
   // Dialect / JSON Schema Version
-  if ((typeof schema !== "object" || !("$schema" in schema)) && !contextDialectId) {
+  if (typeof schema.$schema === "string") {
+    dialectId = schema.$schema;
+    delete schema.$schema;
+  }
+
+  if (!dialectId) {
     throw Error("Unable to determine a dialect for the schema. The dialect can be declared in a number of ways, but the recommended way is to use the '$schema' keyword in your schema.");
   }
-  const dialectId = toAbsoluteIri(schema.$schema || contextDialectId);
-  delete schema.$schema;
+  dialectId = toAbsoluteIri(dialectId);
 
   // Identifiers
-  const idToken = getKeywordName(dialectId, "https://json-schema.org/keyword/id")
-    || getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/id");
-  if (!retrievalUri && typeof schema?.[idToken] !== "string") {
+  const legacyIdToken = getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/id");
+  const idToken = getKeywordName(dialectId, "https://json-schema.org/keyword/id") || legacyIdToken;
+  if (!schema[idToken] && !id) {
     throw Error(`Unable to determine an identifier for the schema. Use the '${idToken}' keyword or pass a retrievalUri when loading the schema.`);
   }
-  const internalUrl = resolveUri(schema[idToken] || retrievalUri, retrievalUri);
-  const id = toAbsoluteIri(internalUrl);
-  delete schema[idToken];
-  if (retrievalUri) {
-    const externalId = toAbsoluteIri(retrievalUri);
-    schemaStoreAlias[externalId] = id;
+  const resolvedId = resolveIri(schema[idToken] ?? "", id ?? "");
+  id = toAbsoluteIri(resolvedId);
+  if (legacyIdToken && resolvedId.length > id.length) {
+    schema[idToken] = "#" + uriFragment(resolvedId);
+  } else {
+    delete schema[idToken];
   }
 
   // Vocabulary
   const vocabularyToken = getKeywordName(dialectId, "https://json-schema.org/keyword/vocabulary");
-  if (jsonTypeOf(schema[vocabularyToken], "object")) {
+  if (jsonTypeOf(schema[vocabularyToken]) === "object") {
     const allowUnknownKeywords = schema[vocabularyToken]["https://json-schema.org/draft/2019-09/vocab/core"]
       || schema[vocabularyToken]["https://json-schema.org/draft/2020-12/vocab/core"];
 
@@ -46,280 +93,242 @@ export const add = (schema, retrievalUri = undefined, contextDialectId = undefin
     delete schema[vocabularyToken];
   }
 
+  const anchors = { "": "" };
   const dynamicAnchors = {};
 
-  // Recursive anchor
+  // Legacy Recursive anchor
   const recursiveAnchorToken = getKeywordName(dialectId, "https://json-schema.org/keyword/draft-2019-09/recursiveAnchor");
   if (schema[recursiveAnchorToken] === true) {
     dynamicAnchors[""] = `${id}#`;
   }
   delete schema[recursiveAnchorToken];
 
-  // Store Schema
-  const anchors = { "": "" };
-  schemaStore[id] = {
-    id: id,
+  embedded[id] = {
+    baseUri: id,
     dialectId: dialectId,
-    schema: processSchema(schema, id, dialectId, nilPointer, anchors, dynamicAnchors),
+    root: processSchema(schema, id, dialectId, "", embedded, anchors, dynamicAnchors),
+    anchorLocation: (fragment) => {
+      if (fragment === undefined) {
+        return "";
+      }
+
+      fragment = decodeURI(fragment);
+      if (fragment[0] === "/") {
+        return fragment;
+      } else if (!(fragment in anchors)) {
+        throw Error(`No such anchor '${id}#${encodeURI(fragment)}'`);
+      } else {
+        return anchors[fragment];
+      }
+    },
     anchors: anchors,
     dynamicAnchors: dynamicAnchors,
-    validated: false
+    embedded: embedded
   };
 
-  return id;
+  return embedded[id];
 };
 
-const processSchema = (subject, id, dialectId, pointer, anchors, dynamicAnchors) => {
-  if (jsonTypeOf(subject, "object")) {
+const processSchema = (json, id, dialectId, cursor, embedded, anchors, dynamicAnchors) => {
+  if (jsonTypeOf(json) === "object") {
     // Embedded Schema
-    const embeddedDialectId = typeof subject.$schema === "string" ? toAbsoluteIri(subject.$schema) : dialectId;
-
+    const embeddedDialectId = typeof json.$schema === "string" ? toAbsoluteIri(json.$schema) : dialectId;
     const idToken = getKeywordName(embeddedDialectId, "https://json-schema.org/keyword/id");
-    if (typeof subject[idToken] === "string") {
-      subject[idToken] = resolveUri(subject[idToken], id);
-      add(subject, undefined, dialectId);
-      return Reference.cons(subject[idToken], subject);
+
+    if (typeof json[idToken] === "string") {
+      const embeddedId = toAbsoluteIri(resolveIri(json[idToken], id));
+      json[idToken] = embeddedId;
+      embedded[embeddedId] = buildSchemaDocument(json, embeddedId, embeddedDialectId, embedded);
+      return new Reference(embeddedId, {});
     }
 
     // Legacy id
     const legacyIdToken = getKeywordName(embeddedDialectId, "https://json-schema.org/keyword/draft-04/id");
-    if (typeof subject[legacyIdToken] === "string") {
-      if (subject[legacyIdToken][0] === "#") {
-        const anchor = decodeURIComponent(subject[legacyIdToken].slice(1));
-        anchors[anchor] = pointer;
+    if (typeof json[legacyIdToken] === "string") {
+      if (json[legacyIdToken][0] === "#") {
+        const anchor = decodeURIComponent(json[legacyIdToken].slice(1));
+        anchors[anchor] = cursor;
+        delete json[legacyIdToken];
       } else {
-        delete subject[legacyIdToken].$schema;
-        subject[legacyIdToken] = resolveUri(subject[legacyIdToken], id);
-        add(subject, undefined, dialectId);
-        return Reference.cons(subject[legacyIdToken], subject);
+        const embeddedId = toAbsoluteIri(resolveIri(json[legacyIdToken], id));
+        json[legacyIdToken] = embeddedId;
+        embedded[embeddedId] = buildSchemaDocument(json, embeddedId, embeddedDialectId, embedded);
+        return new Reference(embeddedId, {});
       }
-      delete subject[legacyIdToken];
-    }
-
-    const dynamicAnchorToken = getKeywordName(dialectId, "https://json-schema.org/keyword/dynamicAnchor");
-    if (typeof subject[dynamicAnchorToken] === "string") {
-      dynamicAnchors[subject[dynamicAnchorToken]] = `${id}#${encodeURI(pointer)}`;
-      delete subject[dynamicAnchorToken];
-    }
-
-    // Legacy dynamic anchor
-    const legacyDynamicAnchorToken = getKeywordName(dialectId, "https://json-schema.org/keyword/draft-2020-12/dynamicAnchor");
-    if (typeof subject[legacyDynamicAnchorToken] === "string") {
-      dynamicAnchors[subject[legacyDynamicAnchorToken]] = `${id}#${encodeURI(pointer)}`;
-      anchors[subject[legacyDynamicAnchorToken]] = pointer;
-      delete subject[legacyDynamicAnchorToken];
-    }
-
-    const anchorToken = getKeywordName(dialectId, "https://json-schema.org/keyword/anchor");
-    if (typeof subject[anchorToken] === "string") {
-      anchors[subject[anchorToken]] = pointer;
-      delete subject[anchorToken];
     }
 
     // Legacy $ref
     const jrefToken = getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/ref");
-    if (typeof subject[jrefToken] === "string") {
-      return Reference.cons(subject[jrefToken], subject);
+    if (typeof json[jrefToken] === "string") {
+      return new Reference(json[jrefToken], json);
     }
 
-    for (const key in subject) {
-      subject[key] = processSchema(subject[key], id, dialectId, pointerAppend(key, pointer), anchors, dynamicAnchors);
-    }
-  } else if (Array.isArray(subject)) {
-    for (let index = 0; index < subject.length; index++) {
-      subject[index] = processSchema(subject[index], id, dialectId, pointerAppend(index, pointer), anchors, dynamicAnchors);
+    // Anchors
+    const anchorToken = getKeywordName(dialectId, "https://json-schema.org/keyword/anchor");
+    if (typeof json[anchorToken] === "string") {
+      anchors[json[anchorToken]] = cursor;
+      delete json[anchorToken];
     }
-  }
-
-  return subject;
-};
-
-const hasStoredSchema = (id) => id in schemaStore || id in schemaStoreAlias;
-const getStoredSchema = (id) => schemaStore[schemaStoreAlias[id]] || schemaStore[id];
-
-export const markValidated = (id) => {
-  schemaStore[id].validated = true;
-};
-
-// Schema Retrieval
-const nil = {
-  id: undefined,
-  dialectId: undefined,
-  pointer: nilPointer,
-  schema: undefined,
-  value: undefined,
-  anchors: {},
-  dynamicAnchors: {},
-  validated: true
-};
-
-export const get = async (url, contextDoc = nil) => {
-  const resolvedUrl = resolveUri(url, contextDoc.id || contextUri());
-  const id = toAbsoluteIri(resolvedUrl);
-  const fragment = uriFragment(resolvedUrl);
 
-  if (!hasStoredSchema(id)) {
-    const response = await fetch(id, { headers: { Accept: acceptableMediaTypes() } });
-    if (response.status >= 400) {
-      await response.text(); // Sometimes node hangs without this hack
-      throw Error(`Failed to retrieve ${id} (${response.status} ${response.statusText})`);
+    // Dynamic Anchors
+    const dynamicAnchorToken = getKeywordName(dialectId, "https://json-schema.org/keyword/dynamicAnchor");
+    if (typeof json[dynamicAnchorToken] === "string") {
+      dynamicAnchors[json[dynamicAnchorToken]] = `${id}#${encodeURI(cursor)}`;
+      delete json[dynamicAnchorToken];
     }
 
-    const [schema, contextDialectId] = await parseResponse(response);
+    // Legacy dynamic anchor
+    const legacyDynamicAnchorToken = getKeywordName(dialectId, "https://json-schema.org/keyword/draft-2020-12/dynamicAnchor");
+    if (typeof json[legacyDynamicAnchorToken] === "string") {
+      dynamicAnchors[json[legacyDynamicAnchorToken]] = `${id}#${encodeURI(cursor)}`;
+      anchors[json[legacyDynamicAnchorToken]] = cursor;
+      delete json[legacyDynamicAnchorToken];
+    }
 
-    // Try to determine the dialect from the meta-schema if it isn't already known
-    if (schema.$schema || contextDialectId) {
-      const dialectId = toAbsoluteIri(schema.$schema || contextDialectId);
-      if (!hasDialect(dialectId) && !hasStoredSchema(dialectId)) {
-        await get(dialectId);
+    for (const key in json) {
+      // References
+      const referenceToken = getKeywordName(dialectId, "https://json-schema.org/keyword/ref");
+      if (key === referenceToken && typeof json[key] === "string") {
+        json[key] = new Reference(json[key], json[key]);
+      } else {
+        json[key] = processSchema(json[key], id, dialectId, append(key, cursor), embedded, anchors, dynamicAnchors);
       }
     }
-
-    add(schema, id, contextDialectId);
-  }
-
-  const storedSchema = getStoredSchema(id);
-  const pointer = fragment[0] === "/" ? fragment : getAnchorPointer(storedSchema, fragment);
-  const doc = {
-    ...storedSchema,
-    pointer: pointer,
-    value: pointerGet(pointer, storedSchema.schema)
-  };
-
-  return followReferences(doc);
-};
-
-const followReferences = (doc) => Reference.isReference(doc.value) ? get(Reference.href(doc.value), doc) : doc;
-
-const getAnchorPointer = (schema, fragment) => {
-  if (!(fragment in schema.anchors)) {
-    throw Error(`No such anchor '${encodeURI(schema.id)}#${encodeURI(fragment)}'`);
-  }
-
-  return schema.anchors[fragment];
-};
-
-// Utility Functions
-export const uri = (doc) => doc.id ? `${doc.id}#${encodeURI(doc.pointer)}` : undefined;
-export const value = (doc) => doc.value;
-export const has = (key, doc) => key in value(doc);
-export const typeOf = (doc, type) => jsonTypeOf(value(doc), type);
-
-export const step = (key, doc) => {
-  const storedSchema = getStoredSchema(doc.id);
-  return followReferences({
-    ...doc,
-    pointer: pointerAppend(`${key}`, doc.pointer),
-    value: value(doc)[key],
-    validated: storedSchema.validated
-  });
-};
-
-export const iter = async function* (doc) {
-  for (let index = 0; index < value(doc).length; index++) {
-    yield step(index, doc);
-  }
-};
-
-export const keys = function* (doc) {
-  for (const key in value(doc)) {
-    yield key;
-  }
-};
-
-export const values = async function* (doc) {
-  for (const key in value(doc)) {
-    yield step(key, doc);
-  }
-};
-
-export const entries = async function* (doc) {
-  for (const key in value(doc)) {
-    yield [key, await step(key, doc)];
+  } else if (Array.isArray(json)) {
+    for (let index = 0; index < json.length; index++) {
+      json[index] = processSchema(json[index], id, dialectId, append(index, cursor), embedded, anchors, dynamicAnchors);
+    }
   }
-};
-
-export const length = (doc) => value(doc).length;
 
-const toSchemaDefaultOptions = {
-  parentId: "",
-  parentDialect: "",
-  includeEmbedded: true
+  return json;
 };
-export const toSchema = (schemaDoc, options = {}) => {
-  const fullOptions = { ...toSchemaDefaultOptions, ...options };
 
-  const idToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/id")
-    || getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/draft-04/id");
-  const anchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/anchor");
-  const legacyAnchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/draft-04/id");
-  const dynamicAnchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/dynamicAnchor");
-  const legacyDynamicAnchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/draft-2020-12/dynamicAnchor");
-  const recursiveAnchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/recursiveAnchor");
+export const canonicalUri = (browser) => `${browser.document.baseUri}#${encodeURI(browser.cursor)}`;
 
+export const toSchema = (browser, options = {}) => {
   const anchors = {};
-  for (const anchor in schemaDoc.anchors) {
-    if (anchor !== "" && !schemaDoc.dynamicAnchors[anchor]) {
-      anchors[schemaDoc.anchors[anchor]] = anchor;
+  for (const anchor in browser.document.anchors) {
+    if (anchor !== "" && !browser.document.dynamicAnchors[anchor]) {
+      anchors[browser.document.anchors[anchor]] = anchor;
     }
   }
 
   const dynamicAnchors = {};
-  for (const anchor in schemaDoc.dynamicAnchors) {
-    const pointer = uriFragment(schemaDoc.dynamicAnchors[anchor]);
+  for (const anchor in browser.document.dynamicAnchors) {
+    const pointer = uriFragment(browser.document.dynamicAnchors[anchor]);
     dynamicAnchors[pointer] = anchor;
   }
 
-  const schema = JSON.parse(jsonStringify(schemaDoc.schema, (_key, value, pointer) => {
-    if (Reference.isReference(value)) {
-      const refValue = Reference.value(value);
-      if (fullOptions.includeEmbedded || !(idToken in refValue)) {
-        return Reference.value(value);
+  const legacyIdToken = getKeywordName(browser.document.dialectId, "https://json-schema.org/keyword/draft-04/id");
+  const idToken = getKeywordName(browser.document.dialectId, "https://json-schema.org/keyword/id") || legacyIdToken;
+  const anchorToken = getKeywordName(browser.document.dialectId, "https://json-schema.org/keyword/anchor");
+  const legacyAnchorToken = getKeywordName(browser.document.dialectId, "https://json-schema.org/keyword/draft-04/id");
+  const dynamicAnchorToken = getKeywordName(browser.document.dialectId, "https://json-schema.org/keyword/dynamicAnchor");
+  const legacyDynamicAnchorToken = getKeywordName(browser.document.dialectId, "https://json-schema.org/keyword/draft-2020-12/dynamicAnchor");
+  const recursiveAnchorToken = getKeywordName(browser.document.dialectId, "https://json-schema.org/keyword/draft-2019-09/recursiveAnchor");
+  const refToken = getKeywordName(browser.document.dialectId, "https://json-schema.org/keyword/ref");
+  const legacyRefToken = getKeywordName(browser.document.dialectId, "https://json-schema.org/keyword/draft-04/ref");
+
+  let schema = JSON.parse(jsonStringify(browser.document.root, (key, value, pointer) => {
+    if (value instanceof Reference) {
+      if (key === refToken) {
+        return value.href;
+      } else if (legacyIdToken) {
+        if (JSON.stringify(value.toJSON()) === "{}") {
+          return toSchema({ document: browser.document.embedded[toAbsoluteIri(value.href)] }, {
+            ...options,
+            contextDialectId: browser.document.dialectId,
+            selfIdentify: true,
+            contextUri: browser.document.baseUri
+          });
+        } else {
+          return { [legacyRefToken]: value.href };
+        }
+      } else if (options.includeEmbedded ?? true) {
+        return toSchema({ document: browser.document.embedded[toAbsoluteIri(value.href)] }, {
+          ...options,
+          contextDialectId: browser.document.dialectId,
+          selfIdentify: true,
+          contextUri: browser.document.baseUri
+        });
+      } else {
+        return;
       }
-    } else {
+    }
+
+    if (jsonTypeOf(value) === "object") {
+      value = { ...value };
       if (pointer in anchors) {
         if (anchorToken) {
-          value = { [anchorToken]: anchors[pointer], ...value };
+          value[anchorToken] = anchors[pointer];
         }
 
         // Legacy anchor
         if (legacyAnchorToken) {
-          value = { [legacyAnchorToken]: `#${anchors[pointer]}`, ...value };
+          value[legacyAnchorToken] = `#${anchors[pointer]}`;
         }
       }
+
       if (pointer in dynamicAnchors) {
         if (dynamicAnchorToken) {
-          value = { [dynamicAnchorToken]: dynamicAnchors[pointer], ...value };
+          value[dynamicAnchorToken] = dynamicAnchors[pointer];
         }
 
         // Legacy dynamic anchor
         if (legacyDynamicAnchorToken) {
-          value = { [legacyDynamicAnchorToken]: dynamicAnchors[pointer], ...value };
+          value[legacyDynamicAnchorToken] = dynamicAnchors[pointer];
         }
 
         // Recursive anchor
         if (recursiveAnchorToken) {
-          value = { [recursiveAnchorToken]: true, ...value };
+          value[recursiveAnchorToken] = true;
         }
       }
-      return value;
     }
+
+    return value;
   }));
 
-  const id = relativeUri(fullOptions.parentId, schemaDoc.id);
-  const dialect = fullOptions.parentDialect === schemaDoc.dialectId ? "" : schemaDoc.dialectId;
-  return {
-    ...id && { [idToken]: id },
-    ...dialect && { $schema: dialect },
-    ...schema
-  };
-};
+  const definitionsToken = getKeywordName(browser.document.dialectId, "https://json-schema.org/keyword/definitions");
+  if (Reflect.ownKeys(schema[definitionsToken] ?? {}).length === 0) {
+    delete schema[definitionsToken];
+  }
 
-const relativeUri = (from, to) => {
-  if (to.startsWith("file://")) {
-    const pathToSchema = from.slice(7, from.lastIndexOf("/"));
-    return from === "" ? "" : pathRelative(pathToSchema, to.slice(7));
-  } else {
-    return to;
+  // Self-identification
+  if (options.selfIdentify ?? false) {
+    if (options.contextUri) {
+      schema = {
+        [idToken]: toRelativeIri(normalizeIri(options.contextUri), browser.document.baseUri),
+        ...schema
+      };
+    } else {
+      schema = {
+        [idToken]: browser.document.baseUri,
+        ...schema
+      };
+    }
+  }
+
+  // $schema
+  switch (options.includeDialect ?? "auto") {
+    case "auto":
+      if (browser.document.dialectId === options.contextDialectId) {
+        break;
+      }
+    case "always":
+      schema = {
+        $schema: browser.document.dialectId,
+        ...schema
+      };
+      if (legacyIdToken) {
+        schema.$schema += "#";
+      }
+      break;
+    case "never":
+      break;
+    default:
+      throw Error(`Unsupported value ToSchemaOptions.includeDialect: '${options.includeDialect}'`);
   }
+
+  return schema;
 };

package/openapi-3-0/index.js

@@ -1,9 +1,9 @@
 import { addKeyword, defineVocabulary, loadDialect } from "../lib/keywords.js";
-import { addSchema } from "../lib/index.js";
+import { registerSchema } from "../lib/index.js";
 import "../lib/openapi.js";
 
 import dialectSchema from "./dialect.js";
-import schema20210928 from "./schema/2021-09-28.js";
+import schema from "./schema.js";
 
 import discriminator from "./discriminator.js";
 import example from "./example.js";
@@ -69,9 +69,9 @@ loadDialect("https://spec.openapis.org/oas/3.0/schema", {
   [jsonSchemaVersion]: true
 });
 
-addSchema(dialectSchema);
+registerSchema(dialectSchema);
 
-addSchema(schema20210928, "https://spec.openapis.org/oas/3.0/schema");
-addSchema(schema20210928, "https://spec.openapis.org/oas/3.0/schema/latest");
+registerSchema(schema, "https://spec.openapis.org/oas/3.0/schema");
+registerSchema(schema, "https://spec.openapis.org/oas/3.0/schema/latest");
 
 export * from "../draft-04/index.js";

package/openapi-3-0/type.js

@@ -1,16 +1,22 @@
-import { getKeywordName } from "../lib/keywords.js";
-import * as Schema from "../lib/schema.js";
+import * as Browser from "@hyperjump/browser";
 import * as Instance from "../lib/instance.js";
+import { getKeywordName } from "../lib/experimental.js";
 
 
 const id = "https://spec.openapis.org/oas/3.0/keyword/type";
 
-const compile = async (schema, ast, parentSchema) => {
-  const nullableKeyword = getKeywordName(schema.dialectId, "https://spec.openapis.org/oas/3.0/keyword/nullable");
-  const nullable = await Schema.step(nullableKeyword, parentSchema);
-  return Schema.value(nullable) === true ? ["null", Schema.value(schema)] : Schema.value(schema);
+const compile = async (schema, _ast, parentSchema) => {
+  const nullableKeyword = getKeywordName(schema.document.dialectId, "https://spec.openapis.org/oas/3.0/keyword/nullable");
+  const nullable = await Browser.step(nullableKeyword, parentSchema);
+  return Browser.value(nullable) === true ? ["null", Browser.value(schema)] : Browser.value(schema);
 };
 
-const interpret = (type, instance) => typeof type === "string" ? Instance.typeOf(instance, type) : type.some(Instance.typeOf(instance));
+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 };