dist: update

dist/lib/draft/index.d.ts

@@ -114,9 +114,9 @@ export declare class Draft {
     getTemplate(data?: unknown, schema?: JsonSchema, opts?: TemplateOptions): any;
     isValid(data: unknown, schema?: JsonSchema, pointer?: JsonPointer): boolean;
     resolveAnyOf(data: any, schema: JsonSchema, pointer?: JsonPointer): SchemaNode | JsonError;
-    resolveAllOf(data: any, schema: JsonSchema): JsonSchema;
+    resolveAllOf(data: any, schema: JsonSchema): SchemaNode | JsonError;
     resolveRef(node: SchemaNode): SchemaNode;
-    resolveOneOf(data: any, schema: JsonSchema, pointer?: JsonPointer): SchemaNode | JsonError;
+    resolveOneOf(node: SchemaNode, data: unknown): SchemaNode | JsonError;
     setSchema(schema: JsonSchema): void;
     step(node: SchemaNode, key: string | number, data: any): SchemaNode | JsonError;
     /**

dist/lib/each.d.ts

@@ -1,5 +1,4 @@
-import { Draft } from "./draft";
-import { JsonSchema, JsonPointer } from "./types";
+import { JsonSchema, JsonPointer, SchemaNode } from "./types";
 export type EachCallback = (schema: JsonSchema, data: unknown, pointer: JsonPointer) => void;
 /**
  * Iterates over data, retrieving its schema
@@ -10,4 +9,4 @@ export type EachCallback = (schema: JsonSchema, data: unknown, pointer: JsonPoin
  * @param [schema] - the schema matching the data. Defaults to rootSchema
  * @param [pointer] - pointer to current data. Default to rootPointer
  */
-export declare function each(draft: Draft, data: any, callback: EachCallback, schema?: JsonSchema, pointer?: JsonPointer): void;
+export declare function each(schemaNode: SchemaNode, data: any, callback: EachCallback): void;

dist/lib/features/allOf.d.ts

@@ -8,7 +8,7 @@ import { Draft } from "../draft";
  * when complete this will have much duplication to step.object etc
  */
 export declare function resolveSchema(node: SchemaNode, data: unknown): SchemaNode | JsonError;
-export declare function resolveAllOf(draft: Draft, data: any, schema?: JsonSchema): JsonSchema | JsonError;
+export declare function resolveAllOf(node: SchemaNode, data: any): SchemaNode | JsonError;
 /**
  * @attention: subschemas have to be resolved upfront (e.g. if-else that do not apply)
  * Merge all allOf sub schema into a single schema. Returns undefined for

dist/lib/features/anyOf.d.ts

@@ -1,12 +1,11 @@
-import { JsonSchema, JsonValidator, JsonError, SchemaNode } from "../types";
-import { Draft } from "../draft";
+import { JsonValidator, JsonError, SchemaNode } from "../types";
 /**
  * returns merged schema of all valid anyOf subschemas for the given input data.
  * Does not merge with rest input schema.
  *
  * @returns merged anyOf subschemas which are valid to the given input data.
  */
-export declare function mergeValidAnyOfSchema(draft: Draft, schema: JsonSchema, data: unknown): JsonSchema;
+export declare function mergeValidAnyOfSchema(node: SchemaNode, data: unknown): SchemaNode;
 /**
  * @unused this function is only exposed via draft and not used otherwise
  * @returns extended input schema with valid anyOf subschemas or JsonError if

dist/lib/resolveDynamicSchema.d.ts

@@ -17,6 +17,6 @@ export declare function isDynamicSchema(schema: JsonData): boolean;
  * @returns static schema from resolved dynamic schema definitions for this
  *  specific input data
  */
-export declare function resolveDynamicSchema(_node: SchemaNode, data: unknown): SchemaNode | JsonError<import("./types").ErrorData<{
+export declare function resolveDynamicSchema(schemaNode: SchemaNode, data: unknown): SchemaNode | JsonError<import("./types").ErrorData<{
     [p: string]: unknown;
 }>>;

dist/module/lib/compile/index.js

@@ -29,12 +29,14 @@ export default function compileSchema(draft, schemaToCompile, rootSchema = schem
     const context = { ids: {}, remotes: draft.remotes };
     const rootSchemaAsString = JSON.stringify(schemaToCompile);
     const compiledSchema = JSON.parse(rootSchemaAsString);
-    // flag this schema as compiled
-    Object.defineProperty(compiledSchema, COMPILED, { enumerable: false, value: true });
-    // add getRef-helper to this object
-    Object.defineProperty(compiledSchema, GET_REF, {
-        enumerable: false,
-        value: getRef.bind(null, context, compiledSchema)
+    Object.defineProperties(compiledSchema, {
+        // flag this schema as compiled
+        [COMPILED]: { enumerable: false, value: true },
+        // add getRef-helper to this object
+        [GET_REF]: {
+            enumerable: false,
+            value: getRef.bind(null, context, compiledSchema)
+        }
     });
     // bail early, when no $refs are defined
     if (force === false && rootSchemaAsString.includes("$ref") === false) {

dist/module/lib/draft/index.js

@@ -55,7 +55,8 @@ export class Draft {
      * @param [pointer] - pointer to current data. Default to rootPointer
      */
     each(data, callback, schema, pointer) {
-        return this.config.each(this, data, callback, schema, pointer);
+        const node = createNode(this, schema !== null && schema !== void 0 ? schema : this.rootSchema, pointer);
+        return this.config.each(node, data, callback);
     }
     eachSchema(callback, schema = this.rootSchema) {
         return this.config.eachSchema(schema, callback);
@@ -106,13 +107,13 @@ export class Draft {
         return this.config.resolveAnyOf(node, data);
     }
     resolveAllOf(data, schema) {
-        return this.config.resolveAllOf(this, data, schema);
+        const node = createNode(this, schema, data);
+        return this.config.resolveAllOf(node, data);
     }
     resolveRef(node) {
         return this.config.resolveRef(node);
     }
-    resolveOneOf(data, schema, pointer) {
-        const node = createNode(this, schema, pointer);
+    resolveOneOf(node, data) {
         return this.config.resolveOneOf(node, data);
     }
     setSchema(schema) {

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

@@ -39,11 +39,13 @@ export default function compileSchema(draft, schemaToCompile, rootSchema = schem
     const context = { ids: {}, anchors: {}, remotes: draft.remotes };
     const rootSchemaAsString = JSON.stringify(schemaToCompile);
     const compiledSchema = JSON.parse(rootSchemaAsString);
-    Object.defineProperty(compiledSchema, COMPILED, { enumerable: false, value: true });
-    Object.defineProperty(compiledSchema, GET_CONTEXT, { enumerable: false, value: () => context });
-    Object.defineProperty(compiledSchema, GET_REF, {
-        enumerable: false,
-        value: getRef.bind(null, context, compiledSchema)
+    Object.defineProperties(compiledSchema, {
+        [COMPILED]: { enumerable: false, value: true },
+        [GET_CONTEXT]: { enumerable: false, value: () => context },
+        [GET_REF]: {
+            enumerable: false,
+            value: getRef.bind(null, context, compiledSchema)
+        }
     });
     // bail early, when no $refs are defined
     if (force === false && rootSchemaAsString.includes("$ref") === false) {

dist/module/lib/draft2019/step.js

@@ -80,7 +80,7 @@ const stepType = {
             if (targetNode && Array.isArray(targetNode.schema.oneOf)) {
                 // @special case: this is a mix of a schema and optional definitions
                 // we resolve the schema here and add the original schema to `oneOfSchema`
-                return draft.resolveOneOf(data[key], targetNode.schema, `${pointer}/${key}`);
+                return draft.resolveOneOf(targetNode, data[key]);
             }
             return targetNode;
         }

dist/module/lib/draft2019/validation/keyword.js

@@ -1,5 +1,4 @@
 import Keywords from "../../draft06/validation/keyword";
-import { createNode } from "../../types";
 import { isObject } from "../../utils/isObject";
 import { reduceSchema } from "../../reduceSchema";
 import { validateDependentSchemas, validateDependentRequired } from "../../features/dependencies";
@@ -10,17 +9,17 @@ const getPatternTests = (patternProperties) => isObject(patternProperties) ?
     Object.keys(patternProperties).map((pattern) => new RegExp(pattern))
     : [];
 /** tests if a property is evaluated by the given schema */
-function isPropertyEvaluated(draft, objectSchema, propertyName, value) {
+function isPropertyEvaluated(schemaNode, propertyName, value) {
     var _a, _b;
-    const node = createNode(draft, objectSchema, propertyName);
-    const schema = draft.resolveRef(node).schema;
+    const node = schemaNode.draft.resolveRef(schemaNode);
+    const { schema } = node;
     if (schema.additionalProperties === true) {
         return true;
     }
     // PROPERTIES
     if ((_a = schema.properties) === null || _a === void 0 ? void 0 : _a[propertyName]) {
         const nextSchema = (_b = schema.properties) === null || _b === void 0 ? void 0 : _b[propertyName];
-        if (draft.isValid(value, nextSchema)) {
+        if (node.draft.isValid(value, nextSchema)) {
             return true;
         }
     }
@@ -32,7 +31,7 @@ function isPropertyEvaluated(draft, objectSchema, propertyName, value) {
     // ADDITIONAL-PROPERTIES
     if (isObject(schema.additionalProperties)) {
         const nextSchema = schema.additionalProperties;
-        return draft.validate(value, nextSchema);
+        return node.draft.validate(value, nextSchema);
     }
     return false;
 }
@@ -73,7 +72,7 @@ const KeywordValidation = {
             }
             // special case: an evaluation in if statement counts too
             // we have an unevaluated prop only if the if-schema does not match
-            if (isObject(schema.if) && isPropertyEvaluated(draft, { type: "object", ...schema.if }, key, value[key])) {
+            if (isObject(schema.if) && isPropertyEvaluated(node.next({ type: "object", ...schema.if }), key, value[key])) {
                 return false;
             }
             if (testPatterns.find(pattern => pattern.test(key))) {
@@ -100,10 +99,11 @@ const KeywordValidation = {
             return errors;
         }
         unevaluated.forEach(key => {
-            // note: only key changes
-            const nextSchemaNode = resolvedSchema.unevaluatedProperties;
-            const keyErrors = draft.validate(value[key], nextSchemaNode, `${pointer}/${key}`);
-            errors.push(...keyErrors);
+            if (isObject(resolvedSchema.unevaluatedProperties)) {
+                // note: only key changes
+                const keyErrors = draft.validate(node.next(resolvedSchema.unevaluatedProperties, key), value[key]);
+                errors.push(...keyErrors);
+            }
         });
         return errors;
     },
@@ -137,14 +137,14 @@ const KeywordValidation = {
         }
         if (isObject(resolvedSchema.items)) {
             const nextSchemaNode = { ...resolvedSchema, unevaluatedItems: undefined };
-            const errors = draft.validate(value, nextSchemaNode, pointer);
+            const errors = draft.validate(node.next(nextSchemaNode), value);
             return errors.map(e => draft.errors.unevaluatedItemsError({ ...e.data }));
         }
         if (Array.isArray(resolvedSchema.items)) {
             const items = [];
             for (let i = resolvedSchema.items.length; i < value.length; i += 1) {
                 if (i < resolvedSchema.items.length) {
-                    if (!draft.isValid(value[i], resolvedSchema.items[i])) {
+                    if (draft.validate(node.next(resolvedSchema.items[i], i), value[i]).length > 0) {
                         items.push({ index: i, value: value[i] });
                     }
                 }

dist/module/lib/each.js

@@ -1,5 +1,5 @@
 import getTypeOf from "./getTypeOf";
-import { createNode } from "./types";
+import { isSchemaNode } from "./types";
 /**
  * Iterates over data, retrieving its schema
  *
@@ -9,22 +9,25 @@ import { createNode } from "./types";
  * @param [schema] - the schema matching the data. Defaults to rootSchema
  * @param [pointer] - pointer to current data. Default to rootPointer
  */
-export function each(draft, data, callback, schema = draft.rootSchema, pointer = "#") {
-    const node = createNode(draft, schema, pointer);
-    schema = draft.resolveRef(node).schema;
+export function each(schemaNode, data, callback) {
+    const node = schemaNode.draft.resolveRef(schemaNode);
+    const { draft, schema, pointer } = node;
     callback(schema, data, pointer);
     const dataType = getTypeOf(data);
     if (dataType === "object") {
         Object.keys(data).forEach((key) => {
-            const nextNode = draft.step(key, schema, data, pointer); // not save
-            const next = data[key]; // save
-            draft.each(next, callback, nextNode.schema, `${pointer}/${key}`);
+            const nextNode = draft.step(node, key, data);
+            if (isSchemaNode(nextNode)) {
+                each(nextNode, data[key], callback);
+            }
         });
     }
     else if (dataType === "array") {
         data.forEach((next, key) => {
-            const nextNode = draft.step(key, schema, data, pointer);
-            draft.each(next, callback, nextNode.schema, `${pointer}/${key}`);
+            const nextNode = draft.step(node, key, data);
+            if (isSchemaNode(nextNode)) {
+                each(nextNode, data[key], callback);
+            }
         });
     }
 }

dist/module/lib/features/allOf.js

@@ -18,16 +18,17 @@ export function resolveSchema(node, data) {
     }
     return node.next(omit(schema, "if", "then", "else"));
 }
-export function resolveAllOf(draft, data, schema = draft.rootSchema) {
+export function resolveAllOf(node, data) {
+    const { schema, draft } = node;
     let mergedSchema = shallowCloneSchemaNode(schema);
     for (let i = 0; i < schema.allOf.length; i += 1) {
-        const allOfNode = draft.resolveRef(createNode(draft, schema.allOf[i]));
+        const allOfNode = draft.resolveRef(node.next(schema.allOf[i]));
         // @todo introduce draft.resolveSchema to iteratively resolve
         const allOfSchema = resolveSchema(allOfNode, data).schema;
         mergedSchema = mergeSchema(mergedSchema, allOfSchema);
     }
     delete mergedSchema.allOf;
-    return mergedSchema;
+    return node.next(mergedSchema);
 }
 /**
  * @attention: subschemas have to be resolved upfront (e.g. if-else that do not apply)
@@ -55,14 +56,14 @@ export function mergeAllOfSchema(draft, schema) {
  * validate allOf definition for given input data
  */
 const validateAllOf = (node, value) => {
-    const { draft, schema, pointer } = node;
+    const { draft, schema } = node;
     const { allOf } = schema;
     if (!Array.isArray(allOf) || allOf.length === 0) {
         return;
     }
     const errors = [];
     schema.allOf.forEach((subSchema) => {
-        errors.push(...draft.validate(value, subSchema, pointer));
+        errors.push(...draft.validate(node.next(subSchema), value));
     });
     return errors;
 };

dist/module/lib/features/anyOf.js

@@ -2,27 +2,28 @@
  * @draft-04
  */
 import { mergeSchema } from "../mergeSchema";
-import { createNode } from "../types";
 import { omit } from "../utils/omit";
 /**
  * returns merged schema of all valid anyOf subschemas for the given input data.
  * Does not merge with rest input schema.
  *
  * @returns merged anyOf subschemas which are valid to the given input data.
  */
-export function mergeValidAnyOfSchema(draft, schema, data) {
+export function mergeValidAnyOfSchema(node, data) {
+    const { draft, schema } = node;
     if (!Array.isArray(schema.anyOf) || schema.anyOf.length === 0) {
         return;
     }
     let resolvedSchema;
     schema.anyOf.forEach((anySchema) => {
-        const node = createNode(draft, anySchema);
-        anySchema = draft.resolveRef(node).schema;
-        if (draft.isValid(data, anySchema)) {
-            resolvedSchema = resolvedSchema ? mergeSchema(resolvedSchema, anySchema) : anySchema;
+        const anyNode = draft.resolveRef(node.next(anySchema));
+        if (draft.validate(anyNode, data).length === 0) {
+            resolvedSchema = resolvedSchema ? mergeSchema(resolvedSchema, anyNode.schema) : anyNode.schema;
         }
     });
-    return resolvedSchema;
+    if (resolvedSchema) {
+        return node.next(resolvedSchema);
+    }
 }
 /**
  * @unused this function is only exposed via draft and not used otherwise
@@ -34,12 +35,13 @@ export function resolveAnyOf(node, data) {
     if (!Array.isArray(anyOf) || anyOf.length === 0) {
         return node;
     }
-    const resolvedSchema = mergeValidAnyOfSchema(node.draft, node.schema, data);
-    if (resolvedSchema == null) {
+    const resolvedNode = mergeValidAnyOfSchema(node, data);
+    if (resolvedNode) {
         const { pointer, schema } = node;
         return node.draft.errors.anyOfError({ pointer, schema, value: data, anyOf: JSON.stringify(anyOf) });
     }
-    const mergedSchema = mergeSchema(node.schema, resolvedSchema);
+    // node.merge(resolvedNode.schema, "anyOf")
+    const mergedSchema = mergeSchema(node.schema, resolvedNode.schema);
     return node.next(omit(mergedSchema, "anyOf"));
 }
 /**

dist/module/lib/features/if.js

@@ -29,10 +29,10 @@ export function resolveIfSchema(node, data) {
  * @returns validation result of it-then-else schema
  */
 const validateIf = (node, value) => {
-    const resolvedSchema = resolveIfSchema(node, value);
-    if (resolvedSchema) {
+    const resolvedNode = resolveIfSchema(node, value);
+    if (resolvedNode) {
         // @recursiveRef ok, we not just add per pointer, but any evlauation to dynamic scope / validation path
-        return node.draft.validate(resolvedSchema, value);
+        return node.draft.validate(resolvedNode, value);
     }
 };
 export { validateIf };