json-schema-library 5.2.1 → 6.1.0

package/dist/lib/config/strings.d.ts

@@ -1,40 +1,2 @@
-declare const _default: {
-    AdditionalItemsError: string;
-    AdditionalPropertiesError: string;
-    AnyOfError: string;
-    AllOfError: string;
-    EnumError: string;
-    FormatDateTimeError: string;
-    FormatEmailError: string;
-    FormatUrlError: string;
-    FormatUriError: string;
-    FormatHostnameError: string;
-    FormatIPV4Error: string;
-    FormatIPV6Error: string;
-    FormatRegExError: string;
-    MaximumError: string;
-    MaxItemsError: string;
-    MaxLengthError: string;
-    MaxPropertiesError: string;
-    MinimumError: string;
-    MinItemsError: string;
-    MinLengthError: string;
-    MinPropertiesError: string;
-    MissingOneOfPropertyError: string;
-    MissingDependencyError: string;
-    MultipleOfError: string;
-    MultipleOneOfError: string;
-    NoAdditionalPropertiesError: string;
-    NotError: string;
-    OneOfError: string;
-    OneOfPropertyError: string;
-    PatternError: string;
-    PatternPropertiesError: string;
-    RequiredPropertyError: string;
-    TypeError: string;
-    UndefinedValueError: string;
-    UnknownPropertyError: string;
-    UniqueItemsError: string;
-    ValueNotEmptyError: string;
-};
+declare const _default: Record<string, string>;
 export default _default;

package/dist/lib/cores/CoreInterface.d.ts

@@ -1,23 +1,42 @@
-import { JSONSchema, JSONPointer, JSONError } from "../types";
+import { JSONSchema, JSONPointer, JSONValidator, JSONTypeValidator, JSONError } from "../types";
+import { CreateError } from "../utils/createCustomError";
 export default class CoreInterface {
+    /** entry point of schema */
     __rootSchema: JSONSchema;
-    errors: any;
-    typeKeywords: any;
-    validateFormat: any;
-    validateKeyword: any;
-    validateType: any;
+    /** error creators by id */
+    errors: Record<string, CreateError>;
+    /** map for valid keywords of a type  */
+    typeKeywords: Record<string, string[]>;
+    /** keyword validators  */
+    validateKeyword: Record<string, JSONValidator>;
+    /** type validators  */
+    validateType: Record<string, JSONTypeValidator>;
+    /** format validators  */
+    validateFormat: Record<string, JSONValidator>;
     constructor(schema?: JSONSchema);
     get rootSchema(): JSONSchema;
     set rootSchema(rootSchema: JSONSchema);
     each(data: any, callback: any, schema?: JSONSchema, pointer?: JSONPointer): void;
-    validate(data: any, schema?: JSONSchema, pointer?: JSONPointer): Array<JSONError>;
+    validate(data: unknown, schema?: JSONSchema, pointer?: JSONPointer): Array<JSONError>;
     isValid(data: any, schema?: JSONSchema, pointer?: JSONPointer): boolean;
     resolveAnyOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema;
     resolveAllOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema;
     resolveRef(schema: JSONSchema): JSONSchema;
     resolveOneOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema;
     getSchema(pointer: JSONPointer, data: any, schema?: JSONSchema): void;
-    getTemplate(data: any, schema?: JSONSchema): void;
+    getTemplate(data?: unknown, schema?: JSONSchema): void;
     setSchema(schema: JSONSchema): void;
-    step(key: string, schema: JSONSchema, data: any, pointer?: JSONPointer): JSONSchema;
+    /**
+     * Returns the json-schema of the given object property or array item.
+     * e.g. it steps by one key into the data
+     * This helper determines the location of the property within the schema
+     * (additional properties, oneOf, ...) and returns the correct schema.
+     *
+     * @param key    property-name or array-index
+     * @param schema json schema of current data
+     * @param data   parent object or array of key
+     * @param [pointer] json pointer of parent object or array
+     * @return schema or error if failed resolving key
+     */
+    step(key: string | number, schema: JSONSchema, data: any, pointer?: JSONPointer): JSONSchema;
 }

package/dist/lib/cores/Draft04.d.ts

@@ -5,9 +5,9 @@ export default class Draft04Core extends CoreInterface {
     each(data: any, callback: any, schema?: JSONSchema, pointer?: JSONPointer): void;
     validate(data: any, schema?: JSONSchema, pointer?: JSONPointer): any;
     isValid(data: any, schema?: JSONSchema, pointer?: JSONPointer): any;
-    resolveOneOf(data: any, schema: JSONSchema, pointer: JSONPointer): JSONSchema | import("../types").JSONError;
+    resolveOneOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema | import("../types").JSONError;
     resolveRef(schema: JSONSchema): JSONSchema;
     getSchema(pointer: JSONPointer, data: any, schema?: JSONSchema): JSONSchema;
-    getTemplate(data: any, schema?: JSONSchema): any;
+    getTemplate(data?: unknown, schema?: JSONSchema): any;
     step(key: string, schema: JSONSchema, data: any, pointer?: JSONPointer): JSONSchema | import("../types").JSONError;
 }

package/dist/lib/cores/Draft06.d.ts

@@ -0,0 +1,15 @@
+import CoreInterface from "./CoreInterface";
+import { JSONSchema, JSONPointer } from "../types";
+export default class Draft06Core extends CoreInterface {
+    constructor(schema?: JSONSchema);
+    get rootSchema(): JSONSchema;
+    set rootSchema(rootSchema: JSONSchema);
+    each(data: any, callback: any, schema?: JSONSchema, pointer?: JSONPointer): void;
+    validate(data: any, schema?: JSONSchema, pointer?: JSONPointer): any;
+    isValid(data: any, schema?: JSONSchema, pointer?: JSONPointer): any;
+    resolveOneOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema | import("../types").JSONError;
+    resolveRef(schema: JSONSchema): JSONSchema;
+    getSchema(pointer: JSONPointer, data: any, schema?: JSONSchema): JSONSchema;
+    getTemplate(data?: unknown, schema?: JSONSchema): any;
+    step(key: string, schema: JSONSchema, data: any, pointer?: JSONPointer): JSONSchema | import("../types").JSONError;
+}

package/dist/lib/cores/Draft07.d.ts

@@ -0,0 +1,15 @@
+import CoreInterface from "./CoreInterface";
+import { JSONSchema, JSONPointer } from "../types";
+export default class Draft07Core extends CoreInterface {
+    constructor(schema?: JSONSchema);
+    get rootSchema(): JSONSchema;
+    set rootSchema(rootSchema: JSONSchema);
+    each(data: any, callback: any, schema?: JSONSchema, pointer?: JSONPointer): void;
+    validate(data: any, schema?: JSONSchema, pointer?: JSONPointer): any;
+    isValid(data: any, schema?: JSONSchema, pointer?: JSONPointer): any;
+    resolveOneOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema | import("../types").JSONError;
+    resolveRef(schema: JSONSchema): JSONSchema;
+    getSchema(pointer: JSONPointer, data: any, schema?: JSONSchema): JSONSchema;
+    getTemplate(data?: unknown, schema?: JSONSchema): any;
+    step(key: string, schema: JSONSchema, data: any, pointer?: JSONPointer): JSONSchema | import("../types").JSONError;
+}

package/dist/lib/cores/JsonEditor.d.ts

@@ -5,9 +5,9 @@ export default class JsonEditorCore extends CoreInterface {
     each(data: any, callback: any, schema?: JSONSchema, pointer?: JSONPointer): void;
     validate(data: any, schema?: JSONSchema, pointer?: JSONPointer): any;
     isValid(data: any, schema?: JSONSchema, pointer?: JSONPointer): any;
-    resolveOneOf(data: any, schema: JSONSchema, pointer: JSONPointer): JSONSchema | import("../types").JSONError;
+    resolveOneOf(data: any, schema: JSONSchema, pointer?: JSONPointer): JSONSchema | import("../types").JSONError;
     resolveRef(schema: JSONSchema): JSONSchema;
     getSchema(pointer: JSONPointer, data: any, schema?: JSONSchema): JSONSchema;
-    getTemplate(data: any, schema?: JSONSchema): any;
+    getTemplate(data?: any, schema?: JSONSchema): any;
     step(key: string, schema: JSONSchema, data: any, pointer?: JSONPointer): JSONSchema | import("../types").JSONError;
 }

package/dist/lib/draft06/addSchema.d.ts

@@ -0,0 +1,7 @@
+import { JSONSchema } from "../types";
+/**
+ * register a json-schema to be referenced from another json-schema
+ * @param url    base-url of json-schema (aka id)
+ * @param schema
+ */
+export default function addSchema(url: string, schema: JSONSchema): void;

package/dist/lib/draft06/compile/index.d.ts

@@ -0,0 +1,15 @@
+import { JSONSchema } from "../../types";
+/**
+ * @draft starting with _draft 06_ keyword `id` has been renamed to `$id`
+ *
+ * compiles the input root schema for $ref resolution and returns it again
+ * @attention this modifies input schema but maintains object-structure
+ *
+ * for a compiled json-schema you can call getRef on any contained schema (location of type).
+ * this resolves a $ref target to a valid schema (for a valid $ref)
+ *
+ * @param rootSchema root json-schema ($id, defs, ... ) to compile
+ * @param [force] = false force compile json-schema
+ * @return compiled json-schema
+ */
+export default function compile(rootSchema: JSONSchema, force?: boolean): JSONSchema;

package/dist/lib/draft06/validation/keyword.d.ts

@@ -0,0 +1,3 @@
+import { JSONValidator } from "../../types";
+declare const KeywordValidation: Record<string, JSONValidator>;
+export default KeywordValidation;

package/dist/lib/draft06/validation/type.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @todo: type is also a keyword, as is properties, items, etc
+ *
+ * An instance has one of six primitive types (http://json-schema.org/latest/json-schema-core.html#rfc.section.4.2)
+ * or seven in case of ajv https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#type
+ * 1 null, 2 boolean, 3 object, 4 array, 5 number, 6 string (7 integer)
+ */
+declare const _default: {
+    array: (core: any, schema: any, value: any, pointer: any) => any;
+    object: (core: any, schema: any, value: any, pointer: any) => any;
+    string: (core: any, schema: any, value: any, pointer: any) => any;
+    integer: (core: any, schema: any, value: any, pointer: any) => any;
+    number: (core: any, schema: any, value: any, pointer: any) => any;
+    boolean: (core: any, schema: any, value: any, pointer: any) => any;
+    null: (core: any, schema: any, value: any, pointer: any) => any;
+};
+export default _default;

package/dist/lib/draft06/validation/typeKeywordMapping.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Mapping, used in type validation to iterate over type-specific keywords to validate
+ *  - overview https://epoberezkin.github.io/ajv/keywords.html
+ */
+declare const _default: {
+    array: string[];
+    boolean: string[];
+    object: string[];
+    string: string[];
+    number: string[];
+    null: string[];
+};
+export default _default;

package/dist/lib/getChildSchemaSelection.d.ts

@@ -1,11 +1,13 @@
+import CoreInterface from "./cores/CoreInterface";
+import { JSONError, JSONSchema } from "./types";
 /**
  * Returns a list of possible child-schemas for the given property key. In case of a oneOf selection, multiple schemas
  * could be added at the given property (e.g. item-index), thus an array of options is returned. In all other cases
  * a list with a single item will be returned
  *
- * @param  {Core} core          - core to use
- * @param  {String} property    - parent schema of following property
- * @param  {Object} [schema]    - parent schema of following property
- * @return {Object}
+ * @param core          - core to use
+ * @param property    - parent schema of following property
+ * @param [schema]    - parent schema of following property
+ * @return
  */
-export default function getChildSchemaSelection(core: any, property: any, schema?: any): any;
+export default function getChildSchemaSelection(core: CoreInterface, property: string | number, schema?: JSONSchema): JSONSchema[] | JSONError;

package/dist/lib/getSchema.d.ts

@@ -13,4 +13,4 @@ import Core from "./cores/CoreInterface";
  * @param [schema] - the json schema to iterate. Defaults to core.rootSchema
  * @return json schema object of the json-pointer or an error
  */
-export default function getSchema(core: Core, pointer: JSONPointer, data?: any, schema?: JSONSchema): JSONSchema;
+export default function getSchema(core: Core, pointer: JSONPointer, data?: unknown, schema?: JSONSchema): JSONSchema;

package/dist/lib/getTemplate.d.ts

@@ -1,4 +1,8 @@
 import { JSONSchema } from "./types";
 import Core from "./cores/CoreInterface";
-declare const _default: (core: Core, data?: any, schema?: JSONSchema) => any;
+interface TemplateOptions {
+    /** Add all properties (required and optional) to the generated data */
+    addOptionalProps: boolean;
+}
+declare const _default: (core: Core, data?: any, schema?: JSONSchema, opts?: TemplateOptions) => any;
 export default _default;

package/dist/lib/getTypeOf.d.ts

@@ -1 +1,2 @@
-export default function getTypeOf(value: any): any;
+export declare type JSType = "array" | "bigint" | "boolean" | "function" | "null" | "number" | "object" | "string" | "symbol" | "undefined";
+export default function getTypeOf(value: unknown): JSType;

package/dist/lib/schema/getTypeId.d.ts

@@ -6,4 +6,4 @@ import { JSONSchema } from "../types";
  * @param schema
  * @return type id, if found
  */
-export default function getTypeId(schema: JSONSchema): string | undefined;
+export default function getTypeId(schema: JSONSchema): string | string[] | undefined;

package/dist/lib/step.d.ts

@@ -7,11 +7,11 @@ import Core from "./cores/CoreInterface";
  *  This helper determines the location of the property within the schema (additional properties, oneOf, ...) and
  *  returns the correct schema.
  *
- * @param  core     - validator
- * @param  key      - property-name or array-index
- * @param  schema          - json schema of current data
+ * @param  core      - validator
+ * @param  key       - property-name or array-index
+ * @param  schema    - json schema of current data
  * @param  data      - parent of key
- * @param  [pointer]
+ * @param  [pointer] - pointer to schema and data (parent of key)
  * @return Schema or Error if failed resolving key
  */
 export default function step(core: Core, key: string | number, schema: JSONSchema, data?: any, pointer?: JSONPointer): JSONSchema | JSONError;

package/dist/lib/types.d.ts

@@ -4,7 +4,7 @@ export declare type JSONSchema = {
 };
 export declare type JSONPointer = string;
 export declare type JSONError = {
-    type: "error" | "string";
+    type: "error";
     name: string;
     code: string;
     message: string;
@@ -13,6 +13,14 @@ export declare type JSONError = {
     };
     [p: string]: any;
 };
+/**
+ * ts type guard for json error
+ * @returns true if passed type is a JSONError
+ */
+export declare function isJSONError(error: any): error is JSONError;
 export interface JSONValidator {
-    (core: Core, schema: JSONSchema, value: any, pointer: JSONPointer): void | undefined | JSONError | Array<JSONError>;
+    (core: Core, schema: JSONSchema, value: any, pointer: JSONPointer): void | undefined | JSONError | JSONError[];
+}
+export interface JSONTypeValidator {
+    (core: Core, schema: JSONSchema, value: any, pointer: JSONPointer): Array<void | undefined | JSONError | JSONError[]>;
 }

package/dist/lib/utils/filter.d.ts

@@ -1,4 +1,3 @@
 export declare function isPromise(obj: any): boolean;
-export declare function isError(obj: any): boolean;
 export declare function errorOrPromise(error: any): boolean;
 export declare function errorsOnly(error: any): boolean;

package/dist/lib/utils/merge.d.ts

@@ -1,2 +1,5 @@
+/**
+ * returns a new json-schema, where properties are combined and arrays are replaced
+ */
 declare const _default: <T, K>(a: T, b: K) => T & K;
 export default _default;

package/dist/lib/validate.d.ts

@@ -9,4 +9,4 @@ import Core from "./cores/CoreInterface";
  * @param [pointer] - json pointer pointing to value (used for error-messages only)
  * @return list of errors or empty
  */
-export default function validate(core: Core, value: any, schema?: JSONSchema, pointer?: JSONPointer): Array<JSONError>;
+export default function validate(core: Core, value: unknown, schema?: JSONSchema, pointer?: JSONPointer): Array<JSONError>;

package/dist/lib/validation/format.d.ts

@@ -1,11 +1,17 @@
 declare const _default: {
+    date: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
     "date-time": (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
     email: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
     hostname: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
     ipv4: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
     ipv6: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
+    "json-pointer": (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
+    "relative-json-pointer": (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
     regex: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
+    time: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
     uri: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
+    "uri-reference": (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
+    "uri-template": (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
     url: (core: any, schema: any, value: any, pointer: any) => import("../types").JSONError;
 };
 export default _default;

package/dist/lib/validation/keyword.d.ts

@@ -1,28 +1,3 @@
-declare const KeywordValidation: {
-    additionalProperties: (core: any, schema: any, value: any, pointer: any) => any[];
-    allOf: (core: any, schema: any, value: any, pointer: any) => any[];
-    anyOf: (core: any, schema: any, value: any, pointer: any) => any;
-    dependencies: (core: any, schema: any, value: any, pointer: any) => any[];
-    enum: (core: any, schema: any, value: any, pointer: any) => any;
-    format: (core: any, schema: any, value: any, pointer: any) => any;
-    items: (core: any, schema: any, value: any, pointer: any) => any[];
-    maximum: (core: any, schema: any, value: any, pointer: any) => any;
-    maxItems: (core: any, schema: any, value: any, pointer: any) => any;
-    maxLength: (core: any, schema: any, value: any, pointer: any) => any;
-    maxProperties: (core: any, schema: any, value: any, pointer: any) => any;
-    minLength: (core: any, schema: any, value: any, pointer: any) => any;
-    minimum: (core: any, schema: any, value: any, pointer: any) => any;
-    minItems: (core: any, schema: any, value: any, pointer: any) => any;
-    minProperties: (core: any, schema: any, value: any, pointer: any) => any;
-    multipleOf: (core: any, schema: any, value: any, pointer: any) => any;
-    not: (core: any, schema: any, value: any, pointer: any) => any[];
-    oneOf: (core: any, schema: any, value: any, pointer: any) => any;
-    pattern: (core: any, schema: any, value: any, pointer: any) => any;
-    patternProperties: (core: any, schema: any, value: any, pointer: any) => any[];
-    properties: (core: any, schema: any, value: any, pointer: any) => any[];
-    propertiesRequired: (core: any, schema: any, value: any, pointer: any) => any[];
-    required: (core: any, schema: any, value: any, pointer: any) => any;
-    requiredNotEmpty: (core: any, schema: any, value: any, pointer: any) => any;
-    uniqueItems: (core: any, schema: any, value: any, pointer: any) => any[];
-};
+import { JSONValidator } from "../types";
+declare const KeywordValidation: Record<string, JSONValidator>;
 export default KeywordValidation;

package/dist/lib/validation/type.d.ts

@@ -1,12 +1,4 @@
-declare const _default: {
-    array: (core: any, schema: any, value: any, pointer: any) => any;
-    object: (core: any, schema: any, value: any, pointer: any) => any;
-    string: (core: any, schema: any, value: any, pointer: any) => any;
-    integer: (core: any, schema: any, value: any, pointer: any) => any;
-    number: (core: any, schema: any, value: any, pointer: any) => any;
-    boolean: (core: any, schema: any, value: any, pointer: any) => any;
-    null: (core: any, schema: any, value: any, pointer: any) => any;
-};
+import { JSONTypeValidator } from "../types";
 /**
  * @todo: type is also a keyword, as is properties, items, etc
  *
@@ -14,4 +6,5 @@ declare const _default: {
  * or seven in case of ajv https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#type
  * 1 null, 2 boolean, 3 object, 4 array, 5 number, 6 string (7 integer)
  */
-export default _default;
+declare const typeValidators: Record<string, JSONTypeValidator>;
+export default typeValidators;

package/dist/lib/validation/typeKeywordMapping.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Mapping, used in type validation to iterate over type-specific keywords to validate
+ *  - overview https://epoberezkin.github.io/ajv/keywords.html
+ */
 declare const _default: {
     array: string[];
     boolean: string[];
@@ -6,8 +10,4 @@ declare const _default: {
     number: string[];
     null: string[];
 };
-/**
- * Mapping, used in type validation to iterate over type-specific keywords to validate
- *  - overview https://epoberezkin.github.io/ajv/keywords.html
- */
 export default _default;

package/dist/module/index.js

@@ -1,26 +1,32 @@
-import strings from "./lib/config/strings";
-import Interface from "./lib/cores/CoreInterface";
-import Draft04 from "./lib/cores/Draft04";
-import JsonEditor from "./lib/cores/JsonEditor";
 import addSchema from "./lib/addSchema";
 import addValidator from "./lib/addValidator";
 import compileSchema from "./lib/compileSchema";
 import createCustomError from "./lib/utils/createCustomError";
 import createSchemaOf from "./lib/createSchemaOf";
+import Draft04 from "./lib/cores/Draft04";
+import Draft06 from "./lib/cores/Draft06";
+import Draft07 from "./lib/cores/Draft07";
 import each from "./lib/each";
 import eachSchema from "./lib/eachSchema";
 import getChildSchemaSelection from "./lib/getChildSchemaSelection";
 import getSchema from "./lib/getSchema";
 import getTemplate from "./lib/getTemplate";
 import getTypeOf from "./lib/getTypeOf";
+import Interface from "./lib/cores/CoreInterface";
 import isValid from "./lib/isValid";
+import JsonEditor from "./lib/cores/JsonEditor";
+import resolveOneOf from "./lib/resolveOneOf.strict";
+import resolveOneOfFuzzy from "./lib/resolveOneOf.fuzzy";
 import SchemaService from "./lib/SchemaService";
+import settings from "./lib/config/settings";
 import step from "./lib/step";
+import strings from "./lib/config/strings";
 import validate from "./lib/validate";
 import validateAsync from "./lib/validateAsync";
-import settings from "./lib/config/settings";
 const config = { strings };
 export { config, Interface, Draft04, // core implementing draft04 specs
+Draft06, // core implementing draft06 specs
+Draft07, // core implementing draft07 specs
 JsonEditor, // adjusted core of draft04 to better support the json-editor
 addSchema, // add a schema to be references via $ref
 addValidator, // add validation for keyword, format, datatype and customize errors
@@ -32,7 +38,8 @@ getSchema, // get schema of datapointer
 getTemplate, // create data which is valid to the given schema
 getTypeOf, // returns the javascript datatype
 isValid, // returns a boolean if the schema is valid
-settings, SchemaService, step, // steps into a json-schema, returning the matching child-schema
+resolveOneOf, resolveOneOfFuzzy, settings, SchemaService, step, // steps into a json-schema, returning the matching child-schema
 validate, // validates data by a schema
 validateAsync // async validation of data by a schema
  };
+export { isJSONError } from "./lib/types";

package/dist/module/lib/addValidator.js

@@ -22,11 +22,10 @@ function addFormat(core, formatType, validationFunction) {
     if (typeof validationFunction !== "function") {
         throw new Error(`Validation function expected. Received ${typeof validationFunction}`);
     }
-    if (core.validateFormat[formatType] == null) {
-        core.validateFormat[formatType] = validationFunction;
-        return;
+    if (core.validateFormat[formatType]) {
+        throw new Error(`A format '${formatType}' is already registered to validation`);
     }
-    throw new Error(`A format '${formatType}' is already registered to validation`);
+    core.validateFormat[formatType] = validationFunction;
 }
 /**
  * Adds a custom keyword validation to a specific type. May not override existing keywords.

package/dist/module/lib/compile/getRef.js

@@ -2,7 +2,7 @@ import { get } from "gson-pointer";
 import splitRef from "./splitRef";
 import getTypeOf from "../getTypeOf";
 const suffixes = /(#|\/)+$/g;
-const isObject = val => (getTypeOf(val) === "object");
+const isObject = (val) => (getTypeOf(val) === "object");
 // 1. combined is known
 // 2. base or pointer is known
 // 3. base + pointer is known

package/dist/module/lib/compile/index.js

@@ -8,6 +8,17 @@ const COMPILED_REF = "__ref";
 const GET_REF = "getRef";
 const GET_ROOT = "getRoot";
 const suffixes = /(#|\/)+$/g;
+/**
+ * compiles the input root schema for $ref resolution and returns it again
+ * @attention this modifies input schema but maintains object-structure
+ *
+ * for a compiled json-schema you can call getRef on any contained schema (location of type).
+ * this resolves a $ref target to a valid schema (for a valid $ref)
+ *
+ * @param rootSchema root json-schema ($id, defs, ... ) to compile
+ * @param [force] = false force compile json-schema
+ * @return compiled json-schema
+ */
 export default function compile(rootSchema, force = false) {
     if (rootSchema[COMPILED] !== undefined) {
         return rootSchema;

package/dist/module/lib/config/strings.js

@@ -5,15 +5,28 @@ export default {
     AdditionalPropertiesError: "Additional property `{{property}}` on `{{pointer}}` does not match schema `{{schema}}`",
     AnyOfError: "Value `{{value}}` at `{{pointer}}` does not match any schema of `{{anyOf}}`",
     AllOfError: "Value `{{value}}` at `{{pointer}}` does not match schema of `{{allOf}}`",
+    ConstError: "Expected value at `{{pointer}}` to be `{{expected}}`, but value given is `{{value}}`",
+    ContainsError: "The array at `{{pointer}}` must contain an element that matches `{{schema}}`",
+    ContainsArrayError: "The property at `{{pointer}}` must not be an array",
+    containsAnyError: "The array at `{{pointer}}` must contain at least one item",
     EnumError: "Expected given value `{{value}}` in `{{pointer}}` to be one of `{{values}}`",
+    FormatDateError: "Value `{{value}}` at `{{pointer}}` is not a valid date",
     FormatDateTimeError: "Value `{{value}}` at `{{pointer}}` is not a valid date-time",
     FormatEmailError: "Value `{{value}}` at `{{pointer}}` is not a valid email",
-    FormatUrlError: "Value `{{value}}` at `{{pointer}}` is not a valid url",
-    FormatUriError: "Value `{{value}}` at `{{pointer}}` is not a valid uri",
+    FormatURLError: "Value `{{value}}` at `{{pointer}}` is not a valid url",
+    FormatURIError: "Value `{{value}}` at `{{pointer}}` is not a valid uri",
+    FormatURIReferenceError: "Value `{{value}}` at `{{pointer}}` is not a valid uri-reference",
+    FormatURITemplateError: "Value `{{value}}` at `{{pointer}}` is not a valid uri-template",
     FormatHostnameError: "Value `{{value}}` at `{{pointer}}` is not a valid hostname",
     FormatIPV4Error: "Value `{{value}}` at `{{pointer}}` is not a valid IPv4 address",
+    FormatIPV4LeadingZeroError: "IPv4 addresses starting with zero are invalid, since they are interpreted as octals",
     FormatIPV6Error: "Value `{{value}}` at `{{pointer}}` is not a valid IPv6 address",
+    FormatIPV6LeadingZeroError: "IPv6 addresses starting with zero are invalid, since they are interpreted as octals",
+    FormatJSONPointerError: "Value `{{value}}` at `{{pointer}}` is not a valid json-pointer",
     FormatRegExError: "Value `{{value}}` at `{{pointer}}` is not a valid regular expression",
+    FormatTimeError: "Value `{{value}}` at `{{pointer}}` is not a valid time",
+    InvalidDataError: "No value may be specified in `{{pointer}}`",
+    InvalidPropertyNameError: "Invalid property name `{{property}}` at `{{pointer}}`",
     MaximumError: "Value in `{{pointer}}` is `{{length}}`, but should be `{{maximum}}` at maximum",
     MaxItemsError: "Too many items in `{{pointer}}`, should be `{{maximum}}` at most, but got `{{length}}`",
     MaxLengthError: "Value `{{pointer}}` should have a maximum length of `{{maxLength}}`, but got `{{length}}`.",

package/dist/module/lib/cores/CoreInterface.js

@@ -4,6 +4,16 @@ import resolveAllOf from "../resolveAllOf";
 /* eslint no-unused-vars: 0 no-empty-function: 0 */
 export default class CoreInterface {
     constructor(schema) {
+        /** error creators by id */
+        this.errors = {};
+        /** map for valid keywords of a type  */
+        this.typeKeywords = {};
+        /** keyword validators  */
+        this.validateKeyword = {};
+        /** type validators  */
+        this.validateType = {};
+        /** format validators  */
+        this.validateFormat = {};
         this.setSchema(schema);
     }
     get rootSchema() {
@@ -45,6 +55,18 @@ export default class CoreInterface {
     setSchema(schema) {
         this.rootSchema = schema;
     }
+    /**
+     * Returns the json-schema of the given object property or array item.
+     * e.g. it steps by one key into the data
+     * This helper determines the location of the property within the schema
+     * (additional properties, oneOf, ...) and returns the correct schema.
+     *
+     * @param key    property-name or array-index
+     * @param schema json schema of current data
+     * @param data   parent object or array of key
+     * @param [pointer] json pointer of parent object or array
+     * @return schema or error if failed resolving key
+     */
     step(key, schema, data, pointer = "#") {
         throw new Error("function 'step' is not implemented");
     }