@hyperjump/json-schema 1.6.7 → 1.7.0

package/draft-06/contains.js

@@ -1,6 +1,6 @@
 import { some } from "@hyperjump/pact";
 import * as Instance from "../lib/instance.js";
-import Validation from "../lib/keywords/validation.js";
+import { Validation } from "../lib/experimental.js";
 
 
 const id = "https://json-schema.org/keyword/draft-06/contains";
@@ -8,7 +8,7 @@ const id = "https://json-schema.org/keyword/draft-06/contains";
 const compile = (schema, ast) => Validation.compile(schema, ast);
 
 const interpret = (contains, instance, ast, dynamicAnchors, quiet) => {
-  return !Instance.typeOf(instance, "array") || some((item) => Validation.interpret(contains, item, ast, dynamicAnchors, quiet), Instance.iter(instance));
+  return Instance.typeOf(instance) !== "array" || some((item) => Validation.interpret(contains, item, ast, dynamicAnchors, quiet), Instance.iter(instance));
 };
 
 export default { id, compile, interpret };

package/draft-06/index.js

@@ -1,5 +1,6 @@
 import { addKeyword, defineVocabulary, loadDialect } from "../lib/keywords.js";
-import { addSchema } from "../lib/core.js";
+import { registerSchema } from "../lib/index.js";
+
 import metaSchema from "./schema.js";
 import additionalItems from "../draft-04/additionalItems.js";
 import contains from "./contains.js";
@@ -61,6 +62,6 @@ loadDialect(jsonSchemaVersion, {
   [jsonSchemaVersion]: true
 }, true);
 
-addSchema(metaSchema);
+registerSchema(metaSchema);
 
 export * from "../lib/index.js";

package/draft-07/index.js

@@ -1,5 +1,6 @@
 import { addKeyword, defineVocabulary, loadDialect } from "../lib/keywords.js";
-import { addSchema } from "../lib/core.js";
+import { registerSchema } from "../lib/index.js";
+
 import metaSchema from "./schema.js";
 import additionalItems from "../draft-04/additionalItems.js";
 import contains from "../draft-06/contains.js";
@@ -67,6 +68,6 @@ loadDialect(jsonSchemaVersion, {
   [jsonSchemaVersion]: true
 }, true);
 
-addSchema(metaSchema);
+registerSchema(metaSchema);
 
 export * from "../lib/index.js";

package/draft-2019-09/index.js

@@ -1,5 +1,5 @@
 import { addKeyword, defineVocabulary, loadDialect } from "../lib/keywords.js";
-import { addSchema } from "../lib/core.js";
+import { registerSchema } from "../lib/index.js";
 
 import metaSchema from "./schema.js";
 import coreMetaSchema from "./meta/core.js";
@@ -10,14 +10,12 @@ import formatMetaSchema from "./meta/format.js";
 import contentMetaSchema from "./meta/content.js";
 
 import additionalItems from "../draft-04/additionalItems.js";
-import contains from "./contains.js";
 import items from "../draft-04/items.js";
 import recursiveAnchor from "./recursiveAnchor.js";
 import recursiveRef from "../draft-2020-12/dynamicRef.js";
 
 
 addKeyword(additionalItems);
-addKeyword(contains);
 addKeyword(items);
 addKeyword(recursiveAnchor);
 addKeyword(recursiveRef);
@@ -38,7 +36,7 @@ defineVocabulary("https://json-schema.org/draft/2019-09/vocab/applicator", {
   "additionalProperties": "https://json-schema.org/keyword/additionalProperties",
   "allOf": "https://json-schema.org/keyword/allOf",
   "anyOf": "https://json-schema.org/keyword/anyOf",
-  "contains": "https://json-schema.org/keyword/draft-2019-09/contains",
+  "contains": "https://json-schema.org/keyword/contains",
   "dependentSchemas": "https://json-schema.org/keyword/dependentSchemas",
   "if": "https://json-schema.org/keyword/if",
   "then": "https://json-schema.org/keyword/then",
@@ -105,12 +103,12 @@ loadDialect("https://json-schema.org/draft/2019-09/schema", {
   "https://json-schema.org/draft/2019-09/vocab/content": true
 }, true);
 
-addSchema(metaSchema);
-addSchema(coreMetaSchema);
-addSchema(applicatorMetaSchema);
-addSchema(validationMetaSchema);
-addSchema(metaDataMetaSchema);
-addSchema(formatMetaSchema);
-addSchema(contentMetaSchema);
+registerSchema(metaSchema);
+registerSchema(coreMetaSchema);
+registerSchema(applicatorMetaSchema);
+registerSchema(validationMetaSchema);
+registerSchema(metaDataMetaSchema);
+registerSchema(formatMetaSchema);
+registerSchema(contentMetaSchema);
 
 export * from "../lib/index.js";

package/draft-2020-12/dynamicRef.js

@@ -1,15 +1,15 @@
-import Validation from "../lib/keywords/validation.js";
-import * as Schema from "../lib/schema.js";
+import * as Browser from "@hyperjump/browser";
+import { Validation, canonicalUri } from "../lib/experimental.js";
 import { uriFragment } from "../lib/common.js";
 
 
 const id = "https://json-schema.org/keyword/draft-2020-12/dynamicRef";
 
 const compile = async (dynamicRef, ast) => {
-  const fragment = uriFragment(Schema.value(dynamicRef));
-  const referencedSchema = await Schema.get(Schema.value(dynamicRef), dynamicRef);
+  const fragment = uriFragment(Browser.value(dynamicRef));
+  const referencedSchema = await Browser.get(Browser.value(dynamicRef), dynamicRef);
   await Validation.compile(referencedSchema, ast);
-  return [referencedSchema.id, fragment, Schema.uri(referencedSchema)];
+  return [referencedSchema.document.baseUri, fragment, canonicalUri(referencedSchema)];
 };
 
 const evaluate = (strategy) => ([id, fragment, ref], instance, ast, dynamicAnchors, quiet) => {

package/draft-2020-12/index.js

@@ -1,5 +1,5 @@
 import { addKeyword, defineVocabulary, loadDialect } from "../lib/keywords.js";
-import { addSchema } from "../lib/core.js";
+import { registerSchema } from "../lib/index.js";
 
 import metaSchema from "./schema.js";
 import coreMetaSchema from "./meta/core.js";
@@ -11,12 +11,10 @@ import formatAssertionMetaSchema from "./meta/format-assertion.js";
 import contentMetaSchema from "./meta/content.js";
 import unevaluatedMetaSchema from "./meta/unevaluated.js";
 
-import contains from "../draft-2019-09/contains.js";
 import dynamicAnchor from "./dynamicAnchor.js";
 import dynamicRef from "./dynamicRef.js";
 
 
-addKeyword(contains);
 addKeyword(dynamicRef);
 addKeyword(dynamicAnchor);
 
@@ -35,7 +33,7 @@ defineVocabulary("https://json-schema.org/draft/2020-12/vocab/applicator", {
   "additionalProperties": "https://json-schema.org/keyword/additionalProperties",
   "allOf": "https://json-schema.org/keyword/allOf",
   "anyOf": "https://json-schema.org/keyword/anyOf",
-  "contains": "https://json-schema.org/keyword/draft-2019-09/contains",
+  "contains": "https://json-schema.org/keyword/contains",
   "dependentSchemas": "https://json-schema.org/keyword/dependentSchemas",
   "if": "https://json-schema.org/keyword/if",
   "then": "https://json-schema.org/keyword/then",
@@ -111,14 +109,14 @@ loadDialect("https://json-schema.org/draft/2020-12/schema", {
   "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
 }, true);
 
-addSchema(metaSchema);
-addSchema(coreMetaSchema);
-addSchema(applicatorMetaSchema);
-addSchema(validationMetaSchema);
-addSchema(metaDataMetaSchema);
-addSchema(formatAnnotationMetaSchema);
-addSchema(formatAssertionMetaSchema);
-addSchema(contentMetaSchema);
-addSchema(unevaluatedMetaSchema);
+registerSchema(metaSchema);
+registerSchema(coreMetaSchema);
+registerSchema(applicatorMetaSchema);
+registerSchema(validationMetaSchema);
+registerSchema(metaDataMetaSchema);
+registerSchema(formatAnnotationMetaSchema);
+registerSchema(formatAssertionMetaSchema);
+registerSchema(contentMetaSchema);
+registerSchema(unevaluatedMetaSchema);
 
 export * from "../lib/index.js";

package/lib/common.d.ts

@@ -1,7 +1,7 @@
 export type JsonType = "object" | "array" | "string" | "number" | "boolean" | "null";
 export type JsonSchemaType = JsonType | "integer";
 
-export const pathRelative: (from: string, to: string) => string;
+export const toRelativeIri: (from: string, to: string) => string;
 
 export type Replacer = (key: string, value: unknown) => unknown;
 export const jsonStringify: (value: unknown, replacer?: Replacer, space?: string) => string;

package/lib/common.js

@@ -1,18 +1,29 @@
-import { resolveIri, parseIriReference } from "@hyperjump/uri";
+import { resolveIri, parseIriReference, parseAbsoluteIri } from "@hyperjump/uri";
 import * as JsonPointer from "@hyperjump/json-pointer";
 
 
-const isObject = (value) => typeof value === "object" && !Array.isArray(value) && value !== null;
-const isType = {
-  null: (value) => value === null,
-  boolean: (value) => typeof value === "boolean",
-  object: isObject,
-  array: (value) => Array.isArray(value),
-  number: (value) => typeof value === "number",
-  integer: (value) => Number.isInteger(value),
-  string: (value) => typeof value === "string"
+export const jsonTypeOf = (value) => {
+  const jsType = typeof value;
+
+  switch (jsType) {
+    case "number":
+    case "string":
+    case "boolean":
+    case "undefined":
+      return jsType;
+    case "object":
+      if (Array.isArray(value)) {
+        return "array";
+      } else if (value === null) {
+        return "null";
+      } else if (Object.getPrototypeOf(value) === Object.prototype) {
+        return "object";
+      }
+    default:
+      const type = jsType === "object" ? Object.getPrototypeOf(value).constructor.name || "anonymous" : jsType;
+      throw Error(`Not a JSON compatible type: ${type}`);
+  }
 };
-export const jsonTypeOf = (value, type) => isType[type](value);
 
 export const resolveUri = (uri, baseUri) => {
   const resolved = resolveIri(uri, baseUri);
@@ -30,70 +41,43 @@ export const toAbsoluteUri = (uri) => {
 
 export const uriFragment = (uri) => decodeURIComponent(parseIriReference(uri).fragment || "");
 
-const CHAR_BACKWARD_SLASH = 47;
+export const toRelativeIri = (from, to) => {
+  const fromUri = parseAbsoluteIri(from);
+  const toUri = parseAbsoluteIri(to);
 
-export const pathRelative = (from, to) => {
-  if (from === to) {
-    return "";
+  if (toUri.scheme !== fromUri.scheme) {
+    return to;
   }
 
-  let toStart = 1;
-  const fromLen = from.length - 1;
-  const toLen = to.length - toStart;
-
-  // Compare paths to find the longest common path from root
-  const length = fromLen < toLen ? fromLen : toLen;
-  let lastCommonSep = -1;
-  let i = 0;
-  for (; i < length; i++) {
-    const fromCode = from.charCodeAt(i + 1);
-    if (fromCode !== to.charCodeAt(toStart + i)) {
-      break;
-    } else if (fromCode === CHAR_BACKWARD_SLASH) {
-      lastCommonSep = i;
-    }
+  if (toUri.authority !== fromUri.authority) {
+    return to;
   }
 
-  if (toLen > length) {
-    if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
-      return to.slice(toStart + i + 1);
-    }
-    if (i === 0) {
-      return to.slice(toStart + i);
-    }
-  }
-  if (fromLen > length) {
-    if (from.charCodeAt(i + 1) === CHAR_BACKWARD_SLASH) {
-      lastCommonSep = i;
-    } else if (length === 0) {
-      lastCommonSep = 0;
-    }
+  if (from === to) {
+    return "";
   }
 
-  let out = "";
-  // Generate the relative path based on the path difference between `to` and `from`
-  for (i = lastCommonSep + 2; i <= from.length; ++i) {
-    if (i === from.length || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
-      out += out.length === 0 ? ".." : "/..";
-    }
-  }
+  const fromSegments = fromUri.path.split("/");
+  const toSegments = toUri.path.split("/");
 
-  toStart += lastCommonSep;
+  let position = 0;
+  while (fromSegments[position] === toSegments[position] && position < fromSegments.length - 1 && position < toSegments.length - 1) {
+    position++;
+  }
 
-  // Lastly, append the rest of the destination (`to`) path that comes after
-  // the common path parts
-  if (out.length > 0) {
-    return `${out}${to.slice(toStart, to.length)}`;
+  const segments = [];
+  for (let index = position + 1; index < fromSegments.length; index++) {
+    segments.push("..");
   }
 
-  if (to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
-    ++toStart;
+  for (let index = position; index < toSegments.length; index++) {
+    segments.push(toSegments[index]);
   }
 
-  return to.slice(toStart, to.length);
+  return segments.join("/");
 };
 
-const defaultReplacer = (key, value) => value;
+const defaultReplacer = (_key, value) => value;
 export const jsonStringify = (value, replacer = defaultReplacer, space = "") => {
   return stringifyValue(value, replacer, space, "", JsonPointer.nil, 1);
 };

package/lib/configuration.js

@@ -1,6 +1,5 @@
 let metaSchemaOutputFormat;
 let shouldValidateSchema = true;
-const enabledExperimentalKeywords = {};
 
 export const getMetaSchemaOutputFormat = () => metaSchemaOutputFormat;
 export const setMetaSchemaOutputFormat = (format) => {
@@ -11,8 +10,3 @@ export const getShouldValidateSchema = () => shouldValidateSchema;
 export const setShouldValidateSchema = (isEnabled) => {
   shouldValidateSchema = isEnabled;
 };
-
-export const isExperimentalKeywordEnabled = (keywordId) => enabledExperimentalKeywords[keywordId];
-export const setExperimentalKeywordEnabled = (keywordId, isEnabled) => {
-  enabledExperimentalKeywords[keywordId] = isEnabled;
-};

package/lib/core.js

@@ -1,15 +1,15 @@
 import curry from "just-curry-it";
+import { resolveIri, toAbsoluteIri } from "@hyperjump/uri";
 import { subscribe, unsubscribe } from "./pubsub.js";
 import {
   setMetaSchemaOutputFormat,
   getShouldValidateSchema,
-  isExperimentalKeywordEnabled,
-  setExperimentalKeywordEnabled,
   getMetaSchemaOutputFormat
 } from "./configuration.js";
 import * as Instance from "./instance.js";
 import { InvalidSchemaError } from "./invalid-schema-error.js";
-import * as Schema from "./schema.js";
+import { getSchema, registerSchema, unregisterSchema as schemaUnregister } from "./schema.js";
+import { getKeywordName } from "./keywords.js";
 import Validation from "./keywords/validation.js";
 
 
@@ -17,14 +17,14 @@ export const FLAG = "FLAG", BASIC = "BASIC", DETAILED = "DETAILED", VERBOSE = "V
 setMetaSchemaOutputFormat(FLAG);
 
 export const validate = async (url, value = undefined, outputFormat = undefined) => {
-  const compiled = await compile(url);
+  const schema = await getSchema(url);
+  const compiled = await compile(schema);
   const interpretAst = (value, outputFormat) => interpret(compiled, Instance.cons(value), outputFormat);
 
   return value === undefined ? interpretAst : interpretAst(value, outputFormat);
 };
 
-export const compile = async (url) => {
-  const schema = await Schema.get(url);
+export const compile = async (schema) => {
   const ast = { metaData: {} };
   const schemaUri = await Validation.compile(schema, ast);
   return { ast, schemaUri };
@@ -79,39 +79,41 @@ const outputHandler = (outputFormat, output) => {
 };
 
 const metaValidators = {};
-subscribe("validate.metaValidate", async (message, schema) => {
-  if (getShouldValidateSchema() && !schema.validated) {
-    Schema.markValidated(schema.id);
+subscribe("validate.metaValidate", async (_message, schema) => {
+  if (getShouldValidateSchema() && !schema.document.validated) {
+    schema.document.validated = true;
 
     // Compile
-    if (!(schema.dialectId in metaValidators)) {
-      // Dynamic references are experimental, but are necessary for meta-validation
-      const dyanmicRefKeywordId = "https://json-schema.org/keyword/dynamicRef";
-      const isDynamicRefEnabled = isExperimentalKeywordEnabled(dyanmicRefKeywordId);
-      setExperimentalKeywordEnabled(dyanmicRefKeywordId, true);
-
-      // itemPattern is experimental, but is necessary for meta-validation
-      const itemPatternKeywordId = "https://json-schema.org/keyword/itemPattern";
-      const isItemPatternEnabled = isExperimentalKeywordEnabled(itemPatternKeywordId);
-      setExperimentalKeywordEnabled(itemPatternKeywordId, true);
-
-      const compiledSchema = await compile(schema.dialectId);
-      metaValidators[schema.dialectId] = interpret(compiledSchema);
-
-      setExperimentalKeywordEnabled(itemPatternKeywordId, isItemPatternEnabled);
-      setExperimentalKeywordEnabled(dyanmicRefKeywordId, isDynamicRefEnabled);
+    if (!(schema.document.dialectId in metaValidators)) {
+      const metaSchema = await getSchema(schema.document.dialectId);
+      const compiledSchema = await compile(metaSchema);
+      metaValidators[schema.document.dialectId] = interpret(compiledSchema);
     }
 
     // Interpret
-    const schemaInstance = Instance.cons(schema.schema, schema.id);
-    const metaResults = metaValidators[schema.dialectId](schemaInstance, getMetaSchemaOutputFormat());
+    const schemaInstance = Instance.cons(schema.document.root, schema.document.baseUri);
+    const metaResults = metaValidators[schema.document.dialectId](schemaInstance, getMetaSchemaOutputFormat());
     if (!metaResults.valid) {
       throw new InvalidSchemaError(metaResults);
     }
   }
 });
 
-export const addSchema = (schema, url = undefined, defaultSchemaVersion = undefined) => {
-  const id = Schema.add(schema, url, defaultSchemaVersion);
-  delete metaValidators[id];
+/**
+ * @deprecated since 1.7.0. Use registerSchema instead.
+ */
+export const addSchema = (schema, retrievalUri = undefined, contextDialectId = undefined) => {
+  const dialectId = typeof schema.$schema === "string" ? toAbsoluteIri(schema.$schema) : contextDialectId;
+  const idToken = getKeywordName(dialectId, "https://json-schema.org/keyword/id")
+    || getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/id");
+  const id = typeof schema[idToken] === "string" ? resolveIri(schema[idToken], retrievalUri) : retrievalUri;
+
+  unregisterSchema(id);
+
+  registerSchema(schema, retrievalUri, contextDialectId);
+};
+
+export const unregisterSchema = (uri) => {
+  schemaUnregister(uri);
+  delete metaValidators[uri];
 };

package/lib/experimental.d.ts

@@ -1,8 +1,78 @@
-import type { Keyword } from "./keywords.js";
+import type { Browser, Document } from "@hyperjump/browser";
+import type { Validator, OutputUnit, OutputFormat, SchemaObject } from "./index.js";
+import type { JsonDocument } from "./instance.js";
 
 
-export { compile, interpret, BASIC, DETAILED, VERBOSE } from "./core.js";
-export { isExperimentalKeywordEnabled, setExperimentalKeywordEnabled } from "./configuration.js";
-export { getKeyword, addKeyword, defineVocabulary, getKeywordName, loadDialect } from "./keywords.js";
-export type { Keyword } from "./keywords.js";
+// Compile/interpret
+export const compile: (url: string) => Promise<CompiledSchema>;
+export const interpret: (
+  (compiledSchema: CompiledSchema, value: unknown, outputFormat?: OutputFormat) => OutputUnit
+) & (
+  (compiledSchema: CompiledSchema) => Validator
+);
+
+export type CompiledSchema = {
+  schemaUri: string;
+  ast: AST;
+};
+
+type AST = {
+  metaData: Record<string, MetaData>;
+} & Record<string, Node<Node<unknown>[] | boolean>>;
+
+type Node<A> = [keywordId: string, schemaUri: string, keywordValue: A];
+
+type MetaData = {
+  id: string;
+  dynamicAnchors: Anchors;
+  anchors: Anchors;
+};
+
+type Anchors = Record<string, string>;
+
+// Output Formats
+export const BASIC: "BASIC";
+export const DETAILED: "DETAILED";
+export const VERBOSE: "VERBOSE";
+
+// Schema
+export const getSchema: (uri: string, browser?: Browser) => Promise<Browser<SchemaDocument>>;
+export const buildSchemaDocument: (schema: SchemaObject | boolean, retrievalUri?: string, contextDialectId?: string) => SchemaDocument;
+export const canonicalUri: (browser: Browser<SchemaDocument>) => string;
+export const toSchema: (browser: Browser<SchemaDocument>, options?: ToSchemaOptions) => SchemaObject;
+
+export type ToSchemaOptions = {
+  contextDialectId?: string;
+  includeDialect?: "auto" | "always" | "never";
+  selfIdentify?: boolean;
+  contextUri?: string;
+  includeEmbedded?: boolean;
+};
+
+export type SchemaDocument = Document & {
+  dialectId: string;
+  anchors: Record<string, string>;
+  dynamicAnchors: Record<string, string>;
+};
+
+// Vocabulary System
+export const addKeyword: <A>(keywordHandler: Keyword<A>) => void;
+export const getKeywordName: (dialectId: string, keywordId: string) => string;
+export const getKeyword: <A>(id: string) => Keyword<A>;
+export const getKeywordByName: <A>(keywordName: string, dialectId: string) => Keyword<A>;
+export const getKeywordId: (keywordName: string, dialectId: string) => string;
+export const defineVocabulary: (id: string, keywords: { [keyword: string]: string }) => void;
+export const loadDialect: (dialectId: string, dialect: { [vocabularyId: string]: boolean }, allowUnknownKeywords?: boolean) => void;
+export const hasDialect: (dialectId: string) => boolean;
+
+export type Keyword<A> = {
+  id: string;
+  compile: (schema: Browser<SchemaDocument>, ast: AST, parentSchema: Browser<SchemaDocument>) => Promise<A>;
+  interpret: (compiledKeywordValue: A, instance: JsonDocument, ast: AST, dynamicAnchors: Anchors) => boolean;
+  collectEvaluatedProperties?: (compiledKeywordValue: A, instance: JsonDocument, ast: AST, dynamicAnchors: Anchors, isTop?: boolean) => Set<string> | false;
+  collectEvaluatedItems?: (compiledKeywordValue: A, instance: JsonDocument, ast: AST, dynamicAnchors: Anchors, isTop?: boolean) => Set<number> | false;
+  collectExternalIds?: (visited: Set<string>, parentSchema: Browser<SchemaDocument>, schema: Browser<SchemaDocument>) => Promise<Set<string>>;
+  annotation?: <B>(compiledKeywordValue: A) => B;
+};
+
 export const Validation: Keyword<string>;

package/lib/experimental.js

@@ -1,4 +1,4 @@
 export { compile, interpret, BASIC, DETAILED, VERBOSE } from "./core.js";
-export { isExperimentalKeywordEnabled, setExperimentalKeywordEnabled } from "./configuration.js";
-export { getKeyword, addKeyword, defineVocabulary, getKeywordName, loadDialect } from "./keywords.js";
+export { getKeyword, getKeywordByName, addKeyword, defineVocabulary, getKeywordName, getKeywordId, loadDialect, hasDialect } from "./keywords.js";
+export { getSchema, toSchema, canonicalUri, buildSchemaDocument } from "./schema.js";
 export { default as Validation } from "./keywords/validation.js";

package/lib/index.d.ts

@@ -1,11 +1,43 @@
-export { addSchema, validate, FLAG } from "./core.js";
-export type { Validator, OutputFormat, CompiledSchema, OutputUnit } from "./core.js";
-export {
-  getMetaSchemaOutputFormat,
-  setMetaSchemaOutputFormat,
-  getShouldValidateSchema,
-  setShouldValidateSchema
-} from "./configuration.js";
-export { InvalidSchemaError } from "./invalid-schema-error.js";
-export { addMediaTypePlugin } from "./media-types.js";
-export type { MediaTypePlugin } from "./media-types.js";
+export type SchemaFragment = string | number | boolean | null | SchemaObject | SchemaFragment[];
+export type SchemaObject = {
+  [keyword: string]: SchemaFragment;
+};
+
+export const registerSchema: (schema: SchemaObject | boolean, retrievalUri?: string, contextDialectId?: string) => void;
+export const unregisterSchema: (retrievalUri: string) => void;
+
+/**
+ * @deprecated since 1.7.0. Use registerSchema instead.
+ */
+export const addSchema: typeof registerSchema;
+
+export const validate: (
+  (url: string, value: unknown, outputFormat?: OutputFormat) => Promise<OutputUnit>
+) & (
+  (url: string) => Promise<Validator>
+);
+
+export type Validator = (value: unknown, outputFormat?: OutputFormat) => OutputUnit;
+
+export type OutputUnit = {
+  keyword: string;
+  absoluteKeywordLocation: string;
+  instanceLocation: string;
+  valid: boolean;
+  errors?: OutputUnit[];
+};
+
+export const FLAG: "FLAG";
+
+export type OutputFormat = "FLAG" | "BASIC" | "DETAILED" | "VERBOSE";
+
+export const setMetaSchemaOutputFormat: (format: OutputFormat) => void;
+export const getMetaSchemaOutputFormat: () => OutputFormat;
+export const setShouldValidateSchema: (isEnabled: boolean) => void;
+export const getShouldValidateSchema: () => boolean;
+
+export class InvalidSchemaError extends Error {
+  public output: OutputUnit;
+
+  public constructor(output: OutputUnit);
+}

package/lib/index.js

@@ -1,5 +1,6 @@
+import { addMediaTypePlugin } from "@hyperjump/browser";
 import { addKeyword } from "./keywords.js";
-import { addMediaTypePlugin } from "./media-types.js";
+import { schemaPlugin } from "./schema.js";
 
 import additionalProperties from "./keywords/additionalProperties.js";
 import allOf from "./keywords/allOf.js";
@@ -64,13 +65,7 @@ import vocabulary from "./keywords/vocabulary.js";
 import writeOnly from "./keywords/writeOnly.js";
 
 
-addMediaTypePlugin("application/schema+json", {
-  parse: async (response, contentTypeParameters) => [
-    await response.json(),
-    contentTypeParameters.schema || contentTypeParameters.profile
-  ],
-  matcher: (path) => path.endsWith(".schema.json")
-});
+addMediaTypePlugin("application/schema+json", schemaPlugin);
 
 addKeyword(additionalProperties);
 addKeyword(allOf);
@@ -134,7 +129,12 @@ addKeyword(unknown);
 addKeyword(vocabulary);
 addKeyword(writeOnly);
 
-export { addSchema, validate, FLAG } from "./core.js";
-export { getMetaSchemaOutputFormat, setMetaSchemaOutputFormat, getShouldValidateSchema, setShouldValidateSchema } from "./configuration.js";
+export { addSchema, unregisterSchema, validate, FLAG } from "./core.js";
+export { registerSchema } from "./schema.js";
+export {
+  getMetaSchemaOutputFormat,
+  setMetaSchemaOutputFormat,
+  getShouldValidateSchema,
+  setShouldValidateSchema
+} from "./configuration.js";
 export { InvalidSchemaError } from "./invalid-schema-error.js";
-export { addMediaTypePlugin } from "./media-types.js";

package/lib/instance.d.ts

@@ -8,23 +8,7 @@ export const get: (url: string, context?: JsonDocument) => JsonDocument;
 export const uri: (doc: JsonDocument) => string;
 export const value: <A extends Json>(doc: JsonDocument<A>) => A;
 export const has: (key: string, doc: JsonDocument<JsonObject>) => boolean;
-export const typeOf: (
-  (doc: JsonDocument, type: "null") => doc is JsonDocument<null>
-) & (
-  (doc: JsonDocument, type: "boolean") => doc is JsonDocument<boolean>
-) & (
-  (doc: JsonDocument, type: "object") => doc is JsonDocument<JsonObject>
-) & (
-  (doc: JsonDocument, type: "array") => doc is JsonDocument<Json[]>
-) & (
-  (doc: JsonDocument, type: "number" | "integer") => doc is JsonDocument<number>
-) & (
-  (doc: JsonDocument, type: "string") => doc is JsonDocument<string>
-) & (
-  (doc: JsonDocument, type: JsonType) => boolean
-) & (
-  (doc: JsonDocument) => (type: JsonType) => boolean
-);
+export const typeOf: (doc: JsonDocument) => JsonType;
 export const step: (key: string, doc: JsonDocument<JsonObject | Json[]>) => JsonDocument<typeof doc.value>;
 export const iter: (doc: JsonDocument<JsonObject>) => Generator<JsonDocument>;
 export const keys: (doc: JsonDocument<JsonObject>) => Generator<string>;