z-schema 12.1.1 → 12.3.1

package/src/schema-validator.ts

@@ -10,21 +10,25 @@ import { shallowClone } from './utils/clone.js';
 import { compileSchemaRegex } from './utils/schema-regex.js';
 import { isInteger, isObject } from './utils/what-is.js';
 
+const PRIMITIVE_TYPES = ['array', 'boolean', 'integer', 'number', 'null', 'object', 'string'] as const;
+const PRIMITIVE_TYPE_STR = PRIMITIVE_TYPES.join(',');
+const PRIMITIVE_TYPES_SET = new Set<string>(PRIMITIVE_TYPES);
+
 const SchemaValidators = {
-  $ref: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  $ref(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
     // http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03
     if (typeof schema.$ref !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['$ref', 'string'], undefined, schema, '$ref');
     }
   },
-  $schema: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  $schema(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-core.html#rfc.section.6
     if (typeof schema.$schema !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['$schema', 'string'], undefined, schema, '$schema');
     }
   },
-  multipleOf: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  multipleOf(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.1.1
     if (typeof schema.multipleOf !== 'number') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['multipleOf', 'number'], undefined, schema, 'multipleOf');
@@ -32,13 +36,13 @@ const SchemaValidators = {
       report.addError('KEYWORD_MUST_BE', ['multipleOf', 'strictly greater than 0'], undefined, schema, 'multipleOf');
     }
   },
-  maximum: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  maximum(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.1
     if (typeof schema.maximum !== 'number') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['maximum', 'number'], undefined, schema, 'maximum');
     }
   },
-  exclusiveMaximum: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  exclusiveMaximum(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.2.1
     if (report.options.version === 'draft-04') {
       if (typeof schema.exclusiveMaximum !== 'boolean') {
@@ -52,25 +56,23 @@ const SchemaValidators = {
       } else if (schema.maximum === undefined) {
         report.addError('KEYWORD_DEPENDENCY', ['exclusiveMaximum', 'maximum'], undefined, schema, 'exclusiveMaximum');
       }
-    } else {
-      if (typeof schema.exclusiveMaximum !== 'boolean' && typeof schema.exclusiveMaximum !== 'number') {
-        report.addError(
-          'KEYWORD_TYPE_EXPECTED',
-          ['exclusiveMaximum', ['boolean', 'number']],
-          undefined,
-          schema,
-          'exclusiveMaximum'
-        );
-      }
+    } else if (typeof schema.exclusiveMaximum !== 'boolean' && typeof schema.exclusiveMaximum !== 'number') {
+      report.addError(
+        'KEYWORD_TYPE_EXPECTED',
+        ['exclusiveMaximum', ['boolean', 'number']],
+        undefined,
+        schema,
+        'exclusiveMaximum'
+      );
     }
   },
-  minimum: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  minimum(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.1
     if (typeof schema.minimum !== 'number') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['minimum', 'number'], undefined, schema, 'minimum');
     }
   },
-  exclusiveMinimum: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  exclusiveMinimum(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     if (report.options.version === 'draft-04') {
       // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.1.3.1
       if (typeof schema.exclusiveMinimum !== 'boolean') {
@@ -84,19 +86,17 @@ const SchemaValidators = {
       } else if (schema.minimum === undefined) {
         report.addError('KEYWORD_DEPENDENCY', ['exclusiveMinimum', 'minimum'], undefined, schema, 'exclusiveMinimum');
       }
-    } else {
-      if (typeof schema.exclusiveMinimum !== 'boolean' && typeof schema.exclusiveMinimum !== 'number') {
-        report.addError(
-          'KEYWORD_TYPE_EXPECTED',
-          ['exclusiveMinimum', ['boolean', 'number']],
-          undefined,
-          schema,
-          'exclusiveMinimum'
-        );
-      }
+    } else if (typeof schema.exclusiveMinimum !== 'boolean' && typeof schema.exclusiveMinimum !== 'number') {
+      report.addError(
+        'KEYWORD_TYPE_EXPECTED',
+        ['exclusiveMinimum', ['boolean', 'number']],
+        undefined,
+        schema,
+        'exclusiveMinimum'
+      );
     }
   },
-  maxLength: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  maxLength(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1.1
     if (!isInteger(schema.maxLength)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['maxLength', 'integer'], undefined, schema, 'maxLength');
@@ -104,7 +104,7 @@ const SchemaValidators = {
       report.addError('KEYWORD_MUST_BE', ['maxLength', 'greater than, or equal to 0'], undefined, schema, 'maxLength');
     }
   },
-  minLength: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  minLength(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.2.1
     if (!isInteger(schema.minLength)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['minLength', 'integer'], undefined, schema, 'minLength');
@@ -112,26 +112,26 @@ const SchemaValidators = {
       report.addError('KEYWORD_MUST_BE', ['minLength', 'greater than, or equal to 0'], undefined, schema, 'minLength');
     }
   },
-  pattern: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  pattern(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.3.1
     if (typeof schema.pattern !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['pattern', 'string'], undefined, schema, 'pattern');
-    } else {
-      // Use shared regex compilation helper
-      // Import at top of file
-      const result = compileSchemaRegex(schema.pattern);
-      if (!result.ok) {
-        report.addError(
-          'KEYWORD_PATTERN',
-          ['pattern', schema.pattern, result.error.message],
-          undefined,
-          schema,
-          'pattern'
-        );
-      }
+      return;
+    }
+    // Use shared regex compilation helper
+    // Import at top of file
+    const result = compileSchemaRegex(schema.pattern);
+    if (!result.ok) {
+      report.addError(
+        'KEYWORD_PATTERN',
+        ['pattern', schema.pattern, result.error.message],
+        undefined,
+        schema,
+        'pattern'
+      );
     }
   },
-  additionalItems: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  additionalItems(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.1
     if (typeof schema.additionalItems !== 'boolean' && !isObject(schema.additionalItems)) {
       report.addError(
@@ -147,7 +147,7 @@ const SchemaValidators = {
       report.path.pop();
     }
   },
-  items: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  items(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.1.1
     if (Array.isArray(schema.items)) {
       for (let idx = 0; idx < schema.items.length; idx++) {
@@ -159,7 +159,7 @@ const SchemaValidators = {
       }
     } else if (isObject(schema.items) || (report.options.version !== 'draft-04' && typeof schema.items === 'boolean')) {
       report.path.push('items');
-      this.validateSchema(report, schema.items as JsonSchemaInternal);
+      this.validateSchema(report, schema.items);
       report.path.pop();
     } else {
       report.addError(
@@ -180,7 +180,7 @@ const SchemaValidators = {
       schema.additionalItems = false;
     }
   },
-  maxItems: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  maxItems(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.2.1
     if (typeof schema.maxItems !== 'number') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['maxItems', 'integer'], undefined, schema, 'maxItems');
@@ -188,7 +188,7 @@ const SchemaValidators = {
       report.addError('KEYWORD_MUST_BE', ['maxItems', 'greater than, or equal to 0'], undefined, schema, 'maxItems');
     }
   },
-  minItems: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  minItems(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.3.1
     if (!isInteger(schema.minItems)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['minItems', 'integer'], undefined, schema, 'minItems');
@@ -196,13 +196,13 @@ const SchemaValidators = {
       report.addError('KEYWORD_MUST_BE', ['minItems', 'greater than, or equal to 0'], undefined, schema, 'minItems');
     }
   },
-  uniqueItems: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  uniqueItems(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.3.4.1
     if (typeof schema.uniqueItems !== 'boolean') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['uniqueItems', 'boolean'], undefined, schema, 'uniqueItems');
     }
   },
-  maxProperties: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  maxProperties(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.1.1
     if (!isInteger(schema.maxProperties)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['maxProperties', 'integer'], undefined, schema, 'maxProperties');
@@ -216,7 +216,7 @@ const SchemaValidators = {
       );
     }
   },
-  minProperties: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  minProperties(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.2.1
     if (!isInteger(schema.minProperties)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['minProperties', 'integer'], undefined, schema, 'minProperties');
@@ -230,7 +230,7 @@ const SchemaValidators = {
       );
     }
   },
-  required: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  required(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.3.1
     if (!Array.isArray(schema.required)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['required', 'array'], undefined, schema, 'required');
@@ -248,12 +248,12 @@ const SchemaValidators = {
           report.addError('KEYWORD_VALUE_TYPE', ['required', 'string'], undefined, schema, 'required');
         }
       }
-      if (isUniqueArray(schema.required) === false) {
+      if (!isUniqueArray(schema.required)) {
         report.addError('KEYWORD_MUST_BE', ['required', 'an array with unique items'], undefined, schema, 'required');
       }
     }
   },
-  additionalProperties: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  additionalProperties(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
     if (typeof schema.additionalProperties !== 'boolean' && !isObject(schema.additionalProperties)) {
       report.addError(
@@ -269,7 +269,7 @@ const SchemaValidators = {
       report.path.pop();
     }
   },
-  properties: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  properties(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
     if (!isObject(schema.properties)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['properties', 'object'], undefined, schema, 'properties');
@@ -299,7 +299,7 @@ const SchemaValidators = {
       report.addError('CUSTOM_MODE_FORCE_PROPERTIES', ['properties'], undefined, schema, 'properties');
     }
   },
-  patternProperties: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  patternProperties(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.4.1
     if (!isObject(schema.patternProperties)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['patternProperties', 'object'], undefined, schema, 'patternProperties');
@@ -332,158 +332,154 @@ const SchemaValidators = {
       report.addError('CUSTOM_MODE_FORCE_PROPERTIES', ['patternProperties'], undefined, schema, 'patternProperties');
     }
   },
-  dependencies: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  dependencies(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.4.5.1
     if (!isObject(schema.dependencies)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['dependencies', 'object'], undefined, schema, 'dependencies');
-    } else {
-      const keys = Object.keys(schema.dependencies);
-      for (const schemaKey of keys) {
-        const schemaDependency = (schema.dependencies as Record<string, unknown>)[schemaKey];
-        const isSchemaDependency =
-          isObject(schemaDependency) ||
-          (report.options.version !== 'draft-04' && typeof schemaDependency === 'boolean');
-
-        if (isSchemaDependency) {
-          report.path.push('dependencies');
-          report.path.push(schemaKey);
-          this.validateSchema(report, schemaDependency as JsonSchemaInternal);
-          report.path.pop();
-          report.path.pop();
-        } else if (Array.isArray(schemaDependency)) {
-          const depArray = schemaDependency as string[];
-          if (report.options.version === 'draft-04' && depArray.length === 0) {
-            report.addError('KEYWORD_MUST_BE', ['dependencies', 'not empty array'], undefined, schema, 'dependencies');
-          }
-          for (const dep of depArray) {
-            if (typeof dep !== 'string') {
-              report.addError('KEYWORD_VALUE_TYPE', ['dependencies', 'string'], undefined, schema, 'dependencies');
-            }
-          }
-          if (isUniqueArray(depArray) === false) {
-            report.addError(
-              'KEYWORD_MUST_BE',
-              ['dependencies', 'an array with unique items'],
-              undefined,
-              schema,
-              'dependencies'
-            );
+      return;
+    }
+    const keys = Object.keys(schema.dependencies);
+    for (const schemaKey of keys) {
+      const schemaDependency = (schema.dependencies as Record<string, unknown>)[schemaKey];
+      const isSchemaDependency =
+        isObject(schemaDependency) || (report.options.version !== 'draft-04' && typeof schemaDependency === 'boolean');
+
+      if (isSchemaDependency) {
+        report.path.push('dependencies');
+        report.path.push(schemaKey);
+        this.validateSchema(report, schemaDependency as JsonSchemaInternal);
+        report.path.pop();
+        report.path.pop();
+      } else if (Array.isArray(schemaDependency)) {
+        const depArray = schemaDependency as string[];
+        if (report.options.version === 'draft-04' && depArray.length === 0) {
+          report.addError('KEYWORD_MUST_BE', ['dependencies', 'not empty array'], undefined, schema, 'dependencies');
+        }
+        for (const dep of depArray) {
+          if (typeof dep !== 'string') {
+            report.addError('KEYWORD_VALUE_TYPE', ['dependencies', 'string'], undefined, schema, 'dependencies');
           }
-        } else {
+        }
+        if (!isUniqueArray(depArray)) {
           report.addError(
-            'KEYWORD_VALUE_TYPE',
-            ['dependencies', report.options.version === 'draft-04' ? 'object or array' : 'boolean, object or array'],
+            'KEYWORD_MUST_BE',
+            ['dependencies', 'an array with unique items'],
             undefined,
             schema,
             'dependencies'
           );
         }
+      } else {
+        report.addError(
+          'KEYWORD_VALUE_TYPE',
+          ['dependencies', report.options.version === 'draft-04' ? 'object or array' : 'boolean, object or array'],
+          undefined,
+          schema,
+          'dependencies'
+        );
       }
     }
   },
-  enum: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  enum(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.1.1
-    if (Array.isArray(schema.enum) === false) {
+    if (!Array.isArray(schema.enum)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['enum', 'array'], undefined, schema, 'enum');
     } else if (schema.enum.length === 0) {
       report.addError('KEYWORD_MUST_BE', ['enum', 'an array with at least one element'], undefined, schema, 'enum');
-    } else if (isUniqueArray(schema.enum) === false) {
+    } else if (!isUniqueArray(schema.enum)) {
       report.addError('KEYWORD_MUST_BE', ['enum', 'an array with unique elements'], undefined, schema, 'enum');
     }
   },
-  type: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  type(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.2.1
-    const primitiveTypes = ['array', 'boolean', 'integer', 'number', 'null', 'object', 'string'];
-    const primitiveTypeStr = primitiveTypes.join(',');
     const isArray = Array.isArray(schema.type);
 
     if (Array.isArray(schema.type)) {
       for (const typeItem of schema.type) {
-        if (!primitiveTypes.includes(typeItem)) {
-          report.addError('KEYWORD_TYPE_EXPECTED', ['type', primitiveTypeStr], undefined, schema, 'type');
+        if (!PRIMITIVE_TYPES_SET.has(typeItem)) {
+          report.addError('KEYWORD_TYPE_EXPECTED', ['type', PRIMITIVE_TYPE_STR], undefined, schema, 'type');
         }
       }
-      if (isUniqueArray(schema.type) === false) {
+      if (!isUniqueArray(schema.type)) {
         report.addError('KEYWORD_MUST_BE', ['type', 'an object with unique properties'], undefined, schema, 'type');
       }
     } else if (typeof schema.type === 'string') {
-      if (!primitiveTypes.includes(schema.type)) {
-        report.addError('KEYWORD_TYPE_EXPECTED', ['type', primitiveTypeStr], undefined, schema, 'type');
+      if (!PRIMITIVE_TYPES_SET.has(schema.type)) {
+        report.addError('KEYWORD_TYPE_EXPECTED', ['type', PRIMITIVE_TYPE_STR], undefined, schema, 'type');
       }
     } else {
       report.addError('KEYWORD_TYPE_EXPECTED', ['type', ['string', 'array']], undefined, schema, 'type');
     }
 
-    if (this.options.noEmptyStrings === true) {
-      if (schema.type === 'string' || (isArray && schema.type!.includes('string'))) {
-        if (schema.minLength === undefined && schema.enum === undefined && schema.format === undefined) {
-          schema.minLength = 1;
-        }
-      }
-    }
-    if (this.options.noEmptyArrays === true) {
-      if (schema.type === 'array' || (isArray && schema.type!.includes('array'))) {
-        if (schema.minItems === undefined) {
-          schema.minItems = 1;
-        }
-      }
-    }
-    if (this.options.forceProperties === true) {
-      if (schema.type === 'object' || (isArray && schema.type!.includes('object'))) {
-        if (schema.properties === undefined && schema.patternProperties === undefined) {
-          report.addError('KEYWORD_UNDEFINED_STRICT', ['properties'], undefined, schema, 'properties');
-        }
-      }
-    }
-    if (this.options.forceItems === true) {
-      if (schema.type === 'array' || (isArray && schema.type!.includes('array'))) {
-        if (schema.items === undefined) {
-          report.addError('KEYWORD_UNDEFINED_STRICT', ['items'], undefined, schema, 'items');
-        }
-      }
-    }
-    if (this.options.forceMinItems === true) {
-      if (schema.type === 'array' || (isArray && schema.type!.includes('array'))) {
-        if (schema.minItems === undefined) {
-          report.addError('KEYWORD_UNDEFINED_STRICT', ['minItems'], undefined, schema, 'minItems');
-        }
-      }
-    }
-    if (this.options.forceMaxItems === true) {
-      if (schema.type === 'array' || (isArray && schema.type!.includes('array'))) {
-        if (schema.maxItems === undefined) {
-          report.addError('KEYWORD_UNDEFINED_STRICT', ['maxItems'], undefined, schema, 'maxItems');
-        }
-      }
-    }
-    if (this.options.forceMinLength === true) {
-      if (schema.type === 'string' || (isArray && schema.type!.includes('string'))) {
-        if (
-          schema.minLength === undefined &&
-          schema.format === undefined &&
-          schema.enum === undefined &&
-          schema.pattern === undefined
-        ) {
-          report.addError('KEYWORD_UNDEFINED_STRICT', ['minLength'], undefined, schema, 'minLength');
-        }
-      }
-    }
-    if (this.options.forceMaxLength === true) {
-      if (schema.type === 'string' || (isArray && schema.type!.includes('string'))) {
-        if (
-          schema.maxLength === undefined &&
-          schema.format === undefined &&
-          schema.enum === undefined &&
-          schema.pattern === undefined
-        ) {
-          report.addError('KEYWORD_UNDEFINED_STRICT', ['maxLength'], undefined, schema, 'maxLength');
-        }
-      }
-    }
-  },
-  allOf: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+    if (
+      this.options.noEmptyStrings === true &&
+      (schema.type === 'string' || (isArray && schema.type!.includes('string'))) &&
+      schema.minLength === undefined &&
+      schema.enum === undefined &&
+      schema.format === undefined
+    ) {
+      schema.minLength = 1;
+    }
+    if (
+      this.options.noEmptyArrays === true &&
+      (schema.type === 'array' || (isArray && schema.type!.includes('array'))) &&
+      schema.minItems === undefined
+    ) {
+      schema.minItems = 1;
+    }
+    if (
+      this.options.forceProperties === true &&
+      (schema.type === 'object' || (isArray && schema.type!.includes('object'))) &&
+      schema.properties === undefined &&
+      schema.patternProperties === undefined
+    ) {
+      report.addError('KEYWORD_UNDEFINED_STRICT', ['properties'], undefined, schema, 'properties');
+    }
+    if (
+      this.options.forceItems === true &&
+      (schema.type === 'array' || (isArray && schema.type!.includes('array'))) &&
+      schema.items === undefined
+    ) {
+      report.addError('KEYWORD_UNDEFINED_STRICT', ['items'], undefined, schema, 'items');
+    }
+    if (
+      this.options.forceMinItems === true &&
+      (schema.type === 'array' || (isArray && schema.type!.includes('array'))) &&
+      schema.minItems === undefined
+    ) {
+      report.addError('KEYWORD_UNDEFINED_STRICT', ['minItems'], undefined, schema, 'minItems');
+    }
+    if (
+      this.options.forceMaxItems === true &&
+      (schema.type === 'array' || (isArray && schema.type!.includes('array'))) &&
+      schema.maxItems === undefined
+    ) {
+      report.addError('KEYWORD_UNDEFINED_STRICT', ['maxItems'], undefined, schema, 'maxItems');
+    }
+    if (
+      this.options.forceMinLength === true &&
+      (schema.type === 'string' || (isArray && schema.type!.includes('string'))) &&
+      schema.minLength === undefined &&
+      schema.format === undefined &&
+      schema.enum === undefined &&
+      schema.pattern === undefined
+    ) {
+      report.addError('KEYWORD_UNDEFINED_STRICT', ['minLength'], undefined, schema, 'minLength');
+    }
+    if (
+      this.options.forceMaxLength === true &&
+      (schema.type === 'string' || (isArray && schema.type!.includes('string'))) &&
+      schema.maxLength === undefined &&
+      schema.format === undefined &&
+      schema.enum === undefined &&
+      schema.pattern === undefined
+    ) {
+      report.addError('KEYWORD_UNDEFINED_STRICT', ['maxLength'], undefined, schema, 'maxLength');
+    }
+  },
+  allOf(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.3.1
-    if (Array.isArray(schema.allOf) === false) {
+    if (!Array.isArray(schema.allOf)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['allOf', 'array'], undefined, schema, 'allOf');
     } else if (schema.allOf.length === 0) {
       report.addError('KEYWORD_MUST_BE', ['allOf', 'an array with at least one element'], undefined, schema, 'allOf');
@@ -497,9 +493,9 @@ const SchemaValidators = {
       }
     }
   },
-  anyOf: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  anyOf(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.4.1
-    if (Array.isArray(schema.anyOf) === false) {
+    if (!Array.isArray(schema.anyOf)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['anyOf', 'array'], undefined, schema, 'anyOf');
     } else if (schema.anyOf.length === 0) {
       report.addError('KEYWORD_MUST_BE', ['anyOf', 'an array with at least one element'], undefined, schema, 'anyOf');
@@ -513,9 +509,9 @@ const SchemaValidators = {
       }
     }
   },
-  oneOf: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  oneOf(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.5.1
-    if (Array.isArray(schema.oneOf) === false) {
+    if (!Array.isArray(schema.oneOf)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['oneOf', 'array'], undefined, schema, 'oneOf');
     } else if (schema.oneOf.length === 0) {
       report.addError('KEYWORD_MUST_BE', ['oneOf', 'an array with at least one element'], undefined, schema, 'oneOf');
@@ -529,7 +525,7 @@ const SchemaValidators = {
       }
     }
   },
-  not: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  not(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.6.1
     const notSchema = schema.not;
     const isValidNotSchema =
@@ -545,13 +541,13 @@ const SchemaValidators = {
         schema,
         'not'
       );
-    } else {
-      report.path.push('not');
-      this.validateSchema(report, notSchema as JsonSchemaInternal);
-      report.path.pop();
+      return;
     }
+    report.path.push('not');
+    this.validateSchema(report, notSchema!);
+    report.path.pop();
   },
-  if: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  if(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     if (report.options.version !== 'draft-07') {
       return;
     }
@@ -564,10 +560,10 @@ const SchemaValidators = {
     }
 
     report.path.push('if');
-    this.validateSchema(report, ifSchema as JsonSchemaInternal);
+    this.validateSchema(report, ifSchema);
     report.path.pop();
   },
-  then: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  then(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     if (report.options.version !== 'draft-07') {
       return;
     }
@@ -580,10 +576,10 @@ const SchemaValidators = {
     }
 
     report.path.push('then');
-    this.validateSchema(report, thenSchema as JsonSchemaInternal);
+    this.validateSchema(report, thenSchema);
     report.path.pop();
   },
-  else: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  else(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     if (report.options.version !== 'draft-07') {
       return;
     }
@@ -596,26 +592,26 @@ const SchemaValidators = {
     }
 
     report.path.push('else');
-    this.validateSchema(report, elseSchema as JsonSchemaInternal);
+    this.validateSchema(report, elseSchema);
     report.path.pop();
   },
-  definitions: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  definitions(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.7.1
     if (!isObject(schema.definitions)) {
       report.addError('KEYWORD_TYPE_EXPECTED', ['definitions', 'object'], undefined, schema, 'definitions');
-    } else {
-      const keys = Object.keys(schema.definitions);
-      for (const key of keys) {
-        const val = schema.definitions[key];
-        report.path.push('definitions');
-        report.path.push(key);
-        this.validateSchema(report, val);
-        report.path.pop();
-        report.path.pop();
-      }
+      return;
+    }
+    const keys = Object.keys(schema.definitions);
+    for (const key of keys) {
+      const val = schema.definitions[key];
+      report.path.push('definitions');
+      report.path.push(key);
+      this.validateSchema(report, val);
+      report.path.pop();
+      report.path.pop();
     }
   },
-  $defs: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  $defs(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     if (report.options.version !== 'draft2019-09' && report.options.version !== 'draft2020-12') {
       return;
     }
@@ -630,30 +626,30 @@ const SchemaValidators = {
       const val = schema.$defs[key];
       report.path.push('$defs');
       report.path.push(key);
-      this.validateSchema(report, val as JsonSchemaInternal);
+      this.validateSchema(report, val);
       report.path.pop();
       report.path.pop();
     }
   },
-  format: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  format(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     if (this.options.formatAssertions === false) {
       return;
     }
 
     if (typeof schema.format !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['format', 'string'], undefined, schema, 'format');
-    } else {
-      const isModernDraft = this.options.version === 'draft2019-09' || this.options.version === 'draft2020-12';
-      if (
-        !isFormatSupported(schema.format, this.options.customFormats) &&
-        this.options.ignoreUnknownFormats !== true &&
-        !isModernDraft
-      ) {
-        report.addError('UNKNOWN_FORMAT', [schema.format], undefined, schema, 'format');
-      }
+      return;
+    }
+    const isModernDraft = this.options.version === 'draft2019-09' || this.options.version === 'draft2020-12';
+    if (
+      !isFormatSupported(schema.format, this.options.customFormats) &&
+      this.options.ignoreUnknownFormats !== true &&
+      !isModernDraft
+    ) {
+      report.addError('UNKNOWN_FORMAT', [schema.format], undefined, schema, 'format');
     }
   },
-  contentEncoding: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  contentEncoding(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     if (report.options.version !== 'draft-07') {
       return;
     }
@@ -662,7 +658,7 @@ const SchemaValidators = {
       report.addError('KEYWORD_TYPE_EXPECTED', ['contentEncoding', 'string'], undefined, schema, 'contentEncoding');
     }
   },
-  contentMediaType: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  contentMediaType(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     if (report.options.version !== 'draft-07') {
       return;
     }
@@ -671,32 +667,36 @@ const SchemaValidators = {
       report.addError('KEYWORD_TYPE_EXPECTED', ['contentMediaType', 'string'], undefined, schema, 'contentMediaType');
     }
   },
-  id: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  id(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-core.html#rfc.section.7.2
     if (typeof schema.id !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['id', 'string'], undefined, schema, 'id');
     }
   },
-  title: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  title(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.1
     if (typeof schema.title !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['title', 'string'], undefined, schema, 'title');
     }
   },
-  description: function (this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
+  description(this: SchemaValidator, report: Report, schema: JsonSchemaInternal) {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.1
     if (typeof schema.description !== 'string') {
       report.addError('KEYWORD_TYPE_EXPECTED', ['description', 'string'], undefined, schema, 'description');
     }
   },
-  default: function (this: SchemaValidator) /* report, schema */ {
+  default(this: SchemaValidator) /* report, schema */ {
     // http://json-schema.org/latest/json-schema-validation.html#rfc.section.6.2
     // There are no restrictions placed on the value of this keyword.
   },
 } as const;
 
 export class SchemaValidator {
-  constructor(private validator: ZSchemaBase) {}
+  private readonly validator: ZSchemaBase;
+
+  constructor(validator: ZSchemaBase) {
+    this.validator = validator;
+  }
 
   get options() {
     return this.validator.options;
@@ -731,35 +731,38 @@ export class SchemaValidator {
     if (hasParentSchema) {
       if (schema.__$schemaResolved && schema.__$schemaResolved !== schema) {
         const subReport = new Report(report);
-        const valid = validate.call(this.validator, subReport, schema.__$schemaResolved, schema);
-        if (valid === false) {
+        const valid = validate(this.validator, subReport, schema.__$schemaResolved, schema);
+        if (!valid) {
           report.addError('PARENT_SCHEMA_VALIDATION_FAILED', undefined, subReport, schema, '$schema');
         }
-      } else {
-        if (this.validator.options.ignoreUnresolvableReferences !== true) {
-          report.addError('REF_UNRESOLVED', [schema.$schema!], undefined, schema, '$schema');
-        }
+      } else if (this.validator.options.ignoreUnresolvableReferences !== true) {
+        report.addError('REF_UNRESOLVED', [schema.$schema!], undefined, schema, '$schema');
       }
     }
 
     if (this.validator.options.noTypeless === true) {
       // issue #36 - inherit type to anyOf, oneOf, allOf if noTypeless is defined
       if (schema.type !== undefined) {
-        let schemas: JsonSchema[] = [];
+        const inheritType = (sch: JsonSchema) => {
+          if (!sch.type) {
+            sch.type = schema.type;
+          }
+        };
         if (Array.isArray(schema.anyOf)) {
-          schemas = schemas.concat(schema.anyOf);
+          for (let i = 0; i < schema.anyOf.length; i++) {
+            inheritType(schema.anyOf[i]);
+          }
         }
         if (Array.isArray(schema.oneOf)) {
-          schemas = schemas.concat(schema.oneOf);
+          for (let i = 0; i < schema.oneOf.length; i++) {
+            inheritType(schema.oneOf[i]);
+          }
         }
         if (Array.isArray(schema.allOf)) {
-          schemas = schemas.concat(schema.allOf);
-        }
-        schemas.forEach(function (sch) {
-          if (!sch.type) {
-            sch.type = schema.type;
+          for (let i = 0; i < schema.allOf.length; i++) {
+            inheritType(schema.allOf[i]);
           }
-        });
+        }
       }
       // end issue #36
       if (
@@ -781,10 +784,8 @@ export class SchemaValidator {
       }
       if (Object.hasOwn(SchemaValidators, key)) {
         SchemaValidators[key as keyof typeof SchemaValidators].call(this, report, schema);
-      } else if (!hasParentSchema) {
-        if (this.validator.options.noExtraKeywords === true) {
-          report.addError('KEYWORD_UNEXPECTED', [key], undefined, schema, undefined);
-        }
+      } else if (!hasParentSchema && this.validator.options.noExtraKeywords === true) {
+        report.addError('KEYWORD_UNEXPECTED', [key], undefined, schema);
       }
     }
 
@@ -798,7 +799,7 @@ export class SchemaValidator {
         report.path.push('enum');
         for (let idx = 0; idx < schema.enum.length; idx++) {
           report.path.push(idx);
-          validate.call(this.validator, report, tmpSchema, schema.enum[idx]);
+          validate(this.validator, report, tmpSchema, schema.enum[idx]);
           report.path.pop();
         }
         report.path.pop();
@@ -806,7 +807,7 @@ export class SchemaValidator {
 
       if (schema.default) {
         report.path.push('default');
-        validate.call(this.validator, report, schema, schema.default);
+        validate(this.validator, report, schema, schema.default);
         report.path.pop();
       }
     }