z-schema 12.2.0 → 12.4.0

package/src/validation/shared.ts

@@ -1,3 +1,4 @@
+import type { ErrorCode } from '../errors.js';
 import type { JsonSchema, JsonSchemaAll, JsonSchemaInternal, JsonSchemaVersion } from '../json-schema-versions.js';
 // JsonSchemaAll is retained for the VALIDATION_VOCAB_KEYWORDS Set key type.
 import type { Report } from '../report.js';
@@ -9,22 +10,17 @@ import { isObject } from '../utils/what-is.js';
 // Shared types
 // ---------------------------------------------------------------------------
 
-export type JsonValidatorFn = (this: ZSchemaBase, report: Report, schema: JsonSchema, json: unknown) => void;
+export type JsonValidatorFn = (ctx: ZSchemaBase, report: Report, schema: JsonSchema, json: unknown) => void;
 
 // ---------------------------------------------------------------------------
 // Draft / vocabulary helpers
 // ---------------------------------------------------------------------------
 
-export const shouldSkipValidate = function (options: ValidateOptions, errors: any) {
-  return (
-    options &&
-    Array.isArray(options.includeErrors) &&
-    options.includeErrors.length > 0 &&
-    !errors.some(function (err: any) {
-      return options.includeErrors!.includes(err);
-    })
-  );
-};
+export const shouldSkipValidate = (options: ValidateOptions, errors: readonly ErrorCode[]) =>
+  options &&
+  Array.isArray(options.includeErrors) &&
+  options.includeErrors.length > 0 &&
+  !errors.some((err) => options.includeErrors!.includes(err));
 
 export const supportsDependentKeywords = (
   schema: JsonSchemaInternal,
@@ -89,12 +85,12 @@ export const isValidationVocabularyEnabled = (
     return true;
   }
 
-  const vocabulary = metaSchema.$vocabulary as Record<string, boolean>;
+  const vocabulary = metaSchema.$vocabulary;
   const has2019 = Object.hasOwn(vocabulary, VOCAB_VALIDATION_2019_09);
   const has2020 = Object.hasOwn(vocabulary, VOCAB_VALIDATION_2020_12);
 
   if (has2019 || has2020) {
-    return vocabulary[VOCAB_VALIDATION_2019_09] === true || vocabulary[VOCAB_VALIDATION_2020_12] === true;
+    return vocabulary[VOCAB_VALIDATION_2019_09] || vocabulary[VOCAB_VALIDATION_2020_12];
   }
 
   return false;
@@ -124,16 +120,16 @@ export const isFormatAssertionVocabEnabled = (
     return false; // no vocabulary info, default to annotation-only for modern drafts
   }
 
-  const vocabulary = metaSchema.$vocabulary as Record<string, boolean>;
+  const vocabulary = metaSchema.$vocabulary;
 
   // For draft 2020-12, only the format-assertion vocabulary enables format as assertion
   if (Object.hasOwn(vocabulary, VOCAB_FORMAT_ASSERTION_2020_12)) {
-    return vocabulary[VOCAB_FORMAT_ASSERTION_2020_12] === true;
+    return vocabulary[VOCAB_FORMAT_ASSERTION_2020_12];
   }
 
   // For draft 2019-09, check if the format vocabulary is enabled (true)
   if (Object.hasOwn(vocabulary, VOCAB_FORMAT_2019_09)) {
-    return vocabulary[VOCAB_FORMAT_2019_09] === true;
+    return vocabulary[VOCAB_FORMAT_2019_09];
   }
 
   return false; // default to annotation-only for modern drafts
@@ -170,17 +166,22 @@ export function getCachedValidationResult(report: Report, schema: unknown, json:
  */
 export function deferOrRunSync(report: Report, subReports: Report[], decisionFn: () => void): void {
   const asyncTasksBefore = report.asyncTasks.length;
-  for (const subReport of subReports) {
-    report.asyncTasks.push(...subReport.asyncTasks);
+  for (let i = 0; i < subReports.length; i++) {
+    const tasks = subReports[i].asyncTasks;
+    for (let j = 0; j < tasks.length; j++) {
+      report.asyncTasks.push(tasks[j]);
+    }
   }
   const hasAsyncTasks = report.asyncTasks.length > asyncTasksBefore;
 
   if (hasAsyncTasks) {
     report.addAsyncTaskWithPath(
-      (callback) => {
-        setTimeout(() => callback(null), 0);
+      (callback: (result: unknown) => void) => {
+        setTimeout(() => {
+          callback(null);
+        }, 0);
       },
-      [] as any,
+      [],
       () => {
         decisionFn();
       }

package/src/validation/string.ts

@@ -2,7 +2,7 @@ import type { JsonSchemaInternal } from '../json-schema-versions.js';
 import type { Report } from '../report.js';
 import type { ZSchemaBase } from '../z-schema-base.js';
 
-import { getFormatValidators } from '../format-validators.js';
+import { resolveFormatValidator } from '../format-validators.js';
 import { decodeBase64, isValidBase64 } from '../utils/base64.js';
 import { compileSchemaRegex } from '../utils/schema-regex.js';
 import { unicodeLength } from '../utils/unicode.js';
@@ -13,9 +13,9 @@ import { isFormatAssertionVocabEnabled, shouldSkipValidate } from './shared.js';
 // minLength
 // ---------------------------------------------------------------------------
 
-export function minLengthValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function minLengthValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.2.2
-  if (shouldSkipValidate(this.validateOptions, ['MIN_LENGTH'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['MIN_LENGTH'])) {
     return;
   }
   if (typeof json !== 'string') {
@@ -30,9 +30,9 @@ export function minLengthValidator(this: ZSchemaBase, report: Report, schema: Js
 // maxLength
 // ---------------------------------------------------------------------------
 
-export function maxLengthValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function maxLengthValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.1.2
-  if (shouldSkipValidate(this.validateOptions, ['MAX_LENGTH'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['MAX_LENGTH'])) {
     return;
   }
   if (typeof json !== 'string') {
@@ -47,9 +47,9 @@ export function maxLengthValidator(this: ZSchemaBase, report: Report, schema: Js
 // pattern
 // ---------------------------------------------------------------------------
 
-export function patternValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function patternValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.2.3.2
-  if (shouldSkipValidate(this.validateOptions, ['PATTERN'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['PATTERN'])) {
     return;
   }
   if (typeof json !== 'string') {
@@ -70,27 +70,24 @@ export function patternValidator(this: ZSchemaBase, report: Report, schema: Json
 // format
 // ---------------------------------------------------------------------------
 
-export function formatValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function formatValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.7.2
-  if (this.options.formatAssertions === false) {
+  if (ctx.options.formatAssertions === false) {
     return;
   }
 
   // When formatAssertions is explicitly true, respect the meta-schema vocabulary:
   // for draft 2019-09/2020-12, format is annotation-only unless the format-assertion
   // vocabulary is enabled in the meta-schema.
-  if (this.options.formatAssertions === true) {
-    if (!isFormatAssertionVocabEnabled(schema, report, this.options.version)) {
-      return;
-    }
+  if (ctx.options.formatAssertions === true && !isFormatAssertionVocabEnabled(schema, report, ctx.options.version)) {
+    return;
   }
 
-  const isModernDraft = this.options.version === 'draft2019-09' || this.options.version === 'draft2020-12';
+  const isModernDraft = ctx.options.version === 'draft2019-09' || ctx.options.version === 'draft2020-12';
 
-  const formatValidators = getFormatValidators(this.options);
-  const formatValidatorFn = formatValidators[schema.format!];
+  const formatValidatorFn = resolveFormatValidator(schema.format!, ctx.options);
   if (typeof formatValidatorFn === 'function') {
-    if (shouldSkipValidate(this.validateOptions, ['INVALID_FORMAT'])) {
+    if (shouldSkipValidate(ctx.validateOptions, ['INVALID_FORMAT'])) {
       return;
     }
     if (report.hasError('INVALID_TYPE', [schema.type, whatIs(json)])) {
@@ -98,40 +95,42 @@ export function formatValidator(this: ZSchemaBase, report: Report, schema: JsonS
     }
     if (formatValidatorFn.length === 2) {
       // callback-based async
-      report.addAsyncTaskWithPath(formatValidatorFn, [json], function (result) {
+      report.addAsyncTaskWithPath(formatValidatorFn, [json], (result) => {
         if (result !== true) {
           report.addError('INVALID_FORMAT', [schema.format!, JSON.stringify(json)], undefined, schema, 'format');
         }
       });
     } else {
-      const result = formatValidatorFn.call(this, json);
+      const result = formatValidatorFn.call(ctx, json);
       if (result instanceof Promise) {
         // Promise-based async
         const promiseResult = result;
         report.addAsyncTaskWithPath(
-          async (callback) => {
+          async (callback: (result: unknown) => void) => {
+            let resolved: unknown = false;
             try {
-              const resolved = await promiseResult;
-              callback(resolved);
-            } catch (_error) {
-              callback(false);
+              resolved = await promiseResult;
+            } catch {
+              // A rejected validator promise is treated as an invalid result (false).
             }
+            // Terminal callback of the async task; `return callback(...)` would trip
+            // no-confusing-void-expression since the callback returns void.
+            // oxlint-disable-next-line node/callback-return
+            callback(resolved);
           },
-          [] as any,
-          function (resolvedResult) {
+          [],
+          (resolvedResult) => {
             if (resolvedResult !== true) {
               report.addError('INVALID_FORMAT', [schema.format!, JSON.stringify(json)], undefined, schema, 'format');
             }
           }
         );
-      } else {
+      } else if (!result) {
         // sync
-        if (result !== true) {
-          report.addError('INVALID_FORMAT', [schema.format!, JSON.stringify(json)], undefined, schema, 'format');
-        }
+        report.addError('INVALID_FORMAT', [schema.format!, JSON.stringify(json)], undefined, schema, 'format');
       }
     }
-  } else if (this.options.ignoreUnknownFormats !== true && !isModernDraft) {
+  } else if (ctx.options.ignoreUnknownFormats !== true && !isModernDraft) {
     report.addError('UNKNOWN_FORMAT', [schema.format!], undefined, schema, 'format');
   }
 }
@@ -140,15 +139,15 @@ export function formatValidator(this: ZSchemaBase, report: Report, schema: JsonS
 // contentEncoding
 // ---------------------------------------------------------------------------
 
-export function contentEncodingValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
-  if (this.options.version !== 'draft-07') {
+export function contentEncodingValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+  if (ctx.options.version !== 'draft-07') {
     return;
   }
   if (typeof json !== 'string') {
     return;
   }
 
-  const contentEncoding = schema.contentEncoding;
+  const { contentEncoding } = schema;
   if (contentEncoding !== 'base64') {
     return;
   }
@@ -168,20 +167,15 @@ export function contentEncodingValidator(this: ZSchemaBase, report: Report, sche
 // contentMediaType
 // ---------------------------------------------------------------------------
 
-export function contentMediaTypeValidator(
-  this: ZSchemaBase,
-  report: Report,
-  schema: JsonSchemaInternal,
-  json: unknown
-) {
-  if (this.options.version !== 'draft-07') {
+export function contentMediaTypeValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+  if (ctx.options.version !== 'draft-07') {
     return;
   }
   if (typeof json !== 'string') {
     return;
   }
 
-  const contentMediaType = schema.contentMediaType;
+  const { contentMediaType } = schema;
   if (contentMediaType !== 'application/json') {
     return;
   }

package/src/validation/type.ts

@@ -10,9 +10,9 @@ import { shouldSkipValidate } from './shared.js';
 // type
 // ---------------------------------------------------------------------------
 
-export function typeValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function typeValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.2.2
-  if (shouldSkipValidate(this.validateOptions, ['INVALID_TYPE'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['INVALID_TYPE'])) {
     return;
   }
   const jsonType = whatIs(json);
@@ -20,10 +20,8 @@ export function typeValidator(this: ZSchemaBase, report: Report, schema: JsonSch
     if (jsonType !== schema.type && (jsonType !== 'integer' || schema.type !== 'number')) {
       report.addError('INVALID_TYPE', [schema.type, jsonType], undefined, schema, 'type');
     }
-  } else {
-    if (!schema.type!.includes(jsonType) && (jsonType !== 'integer' || !schema.type!.includes('number'))) {
-      report.addError('INVALID_TYPE', [JSON.stringify(schema.type), jsonType], undefined, schema, 'type');
-    }
+  } else if (!schema.type!.includes(jsonType) && (jsonType !== 'integer' || !schema.type!.includes('number'))) {
+    report.addError('INVALID_TYPE', [JSON.stringify(schema.type), jsonType], undefined, schema, 'type');
   }
 }
 
@@ -31,25 +29,27 @@ export function typeValidator(this: ZSchemaBase, report: Report, schema: JsonSch
 // enum
 // ---------------------------------------------------------------------------
 
-export function enumValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function enumValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.1.2
-  if (shouldSkipValidate(this.validateOptions, ['ENUM_CASE_MISMATCH', 'ENUM_MISMATCH'])) {
+  if (shouldSkipValidate(ctx.validateOptions, ['ENUM_CASE_MISMATCH', 'ENUM_MISMATCH'])) {
     return;
   }
-  let match = false,
-    caseInsensitiveMatch = false;
+  const eqOpts = { maxDepth: ctx.options.maxRecursionDepth };
+  const eqOptsCI = { caseInsensitiveComparison: true, maxDepth: ctx.options.maxRecursionDepth };
+  let caseInsensitiveMatch = false,
+    match = false;
   for (const enumVal of schema.enum!) {
-    if (areEqual(json, enumVal, { maxDepth: this.options.maxRecursionDepth })) {
+    if (areEqual(json, enumVal, eqOpts)) {
       match = true;
       break;
-    } else if (areEqual(json, enumVal, { caseInsensitiveComparison: true, maxDepth: this.options.maxRecursionDepth })) {
+    } else if (areEqual(json, enumVal, eqOptsCI)) {
       caseInsensitiveMatch = true;
     }
   }
 
-  if (match === false) {
+  if (!match) {
     const error =
-      caseInsensitiveMatch && this.options.enumCaseInsensitiveComparison ? 'ENUM_CASE_MISMATCH' : 'ENUM_MISMATCH';
+      caseInsensitiveMatch && ctx.options.enumCaseInsensitiveComparison ? 'ENUM_CASE_MISMATCH' : 'ENUM_MISMATCH';
     report.addError(error, [JSON.stringify(json)], undefined, schema, 'enum');
   }
 }
@@ -58,9 +58,9 @@ export function enumValidator(this: ZSchemaBase, report: Report, schema: JsonSch
 // const
 // ---------------------------------------------------------------------------
 
-export function constValidator(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
+export function constValidator(ctx: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown) {
   const constValue = schema.const;
-  if (areEqual(json, constValue, { maxDepth: this.options.maxRecursionDepth }) === false) {
-    report.addError('CONST', [JSON.stringify(constValue)], undefined, schema, undefined);
+  if (!areEqual(json, constValue, { maxDepth: ctx.options.maxRecursionDepth })) {
+    report.addError('CONST', [JSON.stringify(constValue)], undefined, schema);
   }
 }

package/src/z-schema-base.ts

@@ -1,10 +1,10 @@
-import type { ValidateError } from './errors.js';
+import type { Errors, ValidateError } from './errors.js';
 import type { FormatValidatorFn } from './format-validators.js';
 import type { JsonSchema, JsonSchemaInternal, JsonSchemaVersion } from './json-schema-versions.js';
 import type { SchemaErrorDetail } from './report.js';
 import type { ZSchemaOptions } from './z-schema-options.js';
 
-import { type Errors, getValidateError } from './errors.js';
+import { getValidateError } from './errors.js';
 import { getSupportedFormats } from './format-validators.js';
 import { VERSION_SCHEMA_URL_MAPPING } from './json-schema-versions.js';
 import { isInternalKey } from './json-schema.js';
@@ -26,7 +26,10 @@ export interface ValidateOptions {
   excludeErrors?: Array<keyof typeof Errors>;
 }
 
-export type ValidateResponse = { valid: boolean; err?: ValidateError };
+export interface ValidateResponse {
+  valid: boolean;
+  err?: ValidateError;
+}
 
 export type ValidateCallback = (err: ValidateResponse['err'], valid: ValidateResponse['valid']) => void;
 
@@ -62,7 +65,7 @@ export class ZSchemaBase {
    * create a circular dependency).
    */
   _jsonValidate(report: Report, schema: boolean | JsonSchemaInternal, json: unknown): boolean {
-    return validateJson.call(this, report, schema, json);
+    return validateJson(this, report, schema, json);
   }
 
   getDefaultSchemaId(): string {
@@ -73,8 +76,7 @@ export class ZSchemaBase {
 
   _validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions, callback: ValidateCallback): void;
   _validate(json: unknown, schema: JsonSchema | string, callback: ValidateCallback): void;
-  _validate(json: unknown, schema: JsonSchema | string, options: ValidateOptions): true;
-  _validate(json: unknown, schema: JsonSchema | string): true;
+  _validate(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): true;
   _validate(
     json: unknown,
     schema: JsonSchema | string,
@@ -93,10 +95,10 @@ export class ZSchemaBase {
 
     if (typeof schema !== 'string' && typeof schema !== 'boolean' && !isObject(schema)) {
       const e = new Error(
-        'Invalid .validate call - schema must be a string or object but ' + whatIs(schema) + ' was passed!'
+        `Invalid .validate call - schema must be a string or object but ${whatIs(schema)} was passed!`
       );
       if (callback) {
-        setTimeout(function () {
+        setTimeout(() => {
           callback(e, false);
         }, 0);
         return;
@@ -113,9 +115,9 @@ export class ZSchemaBase {
       const schemaName = schema;
       _schema = this.scache.getSchema(report, schemaName)!;
       if (!_schema) {
-        const e = new Error("Schema with id '" + schemaName + "' wasn't found in the validator cache!");
+        const e = new Error(`Schema with id '${schemaName}' wasn't found in the validator cache!`);
         if (callback) {
-          setTimeout(function () {
+          setTimeout(() => {
             callback(e, false);
           }, 0);
           return;
@@ -144,11 +146,11 @@ export class ZSchemaBase {
 
     if (options.schemaPath) {
       report.rootSchema = _schema;
-      _schema = get(_schema, options.schemaPath);
+      _schema = get(_schema, options.schemaPath) as JsonSchemaInternal;
       if (!_schema) {
-        const e = new Error("Schema path '" + options.schemaPath + "' wasn't found in the schema!");
+        const e = new Error(`Schema path '${options.schemaPath}' wasn't found in the schema!`);
         if (callback) {
-          setTimeout(function () {
+          setTimeout(() => {
             callback(e, false);
           }, 0);
           return;
@@ -158,7 +160,7 @@ export class ZSchemaBase {
     }
 
     if (!foundError) {
-      validateJson.call(this, report, _schema, json);
+      validateJson(this, report, _schema, json);
     }
 
     if (callback) {
@@ -187,13 +189,13 @@ export class ZSchemaBase {
     const report = new Report(this.options);
 
     if (Array.isArray(schemaOrArr)) {
-      const arr = this.scache.getSchema(report, schemaOrArr)!;
+      const arr = this.scache.getSchema(report, schemaOrArr);
       const compiled = this.sc.compileSchema(report, arr);
       if (compiled) {
         this.sv.validateSchema(report, arr);
       }
     } else {
-      const schema = this.scache.getSchema(report, schemaOrArr)!;
+      const schema = this.scache.getSchema(report, schemaOrArr);
       const compiled = this.sc.compileSchema(report, schema);
       if (compiled) {
         this.sv.validateSchema(report, schema);
@@ -256,11 +258,13 @@ export class ZSchemaBase {
    * @returns An array of unresolvable reference URIs.
    */
   getMissingReferences(err: ValidateError): string[] {
-    if (!err) return [];
+    if (!err) {
+      return [];
+    }
     const details = err.details || [];
     const missingRefs: string[] = [];
-    function collect(details: SchemaErrorDetail[]) {
-      for (const detail of details) {
+    function collect(items: SchemaErrorDetail[]) {
+      for (const detail of items) {
         if (detail.code === 'UNRESOLVABLE_REFERENCE' || detail.code === 'SCHEMA_NOT_REACHABLE') {
           missingRefs.push(detail.params[0] as string);
         }
@@ -281,9 +285,11 @@ export class ZSchemaBase {
   getMissingRemoteReferences(err: ValidateError) {
     const missingReferences = this.getMissingReferences(err);
     const missingRemoteReferences: string[] = [];
+    const seen = new Set<string>();
     for (const ref of missingReferences) {
       const remoteReference = getRemotePath(ref);
-      if (remoteReference && !missingRemoteReferences.includes(remoteReference)) {
+      if (remoteReference && !seen.has(remoteReference)) {
+        seen.add(remoteReference);
         missingRemoteReferences.push(remoteReference);
       }
     }
@@ -299,41 +305,46 @@ export class ZSchemaBase {
   getResolvedSchema(schemaId: string): JsonSchema | undefined {
     const report = new Report(this.options);
     const schema = this.scache.getSchemaByUri(report, schemaId);
-    if (!schema) return undefined;
+    if (!schema) {
+      return undefined;
+    }
 
     const clonedSchema = deepClone(schema, this.options.maxRecursionDepth);
 
     const visited = new WeakSet<object>();
 
     // clean-up the schema and resolve references
-    const cleanup = function (schema: any) {
-      let key;
-      const typeOf = whatIs(schema);
+    const cleanup = (node: unknown) => {
+      const typeOf = whatIs(node);
       if (typeOf !== 'object' && typeOf !== 'array') {
         return;
       }
 
-      if (visited.has(schema)) {
+      if (visited.has(node as object)) {
         return;
       }
 
-      visited.add(schema);
-
-      if (schema.$ref && schema.__$refResolved) {
-        const from = schema.__$refResolved;
-        const to = schema;
-        delete schema.$ref;
-        delete schema.__$refResolved;
-        for (key in from) {
-          copyProp(from, to, key);
+      visited.add(node as object);
+
+      const schemaNode = node as JsonSchemaInternal;
+      if (schemaNode.$ref && schemaNode.__$refResolved) {
+        const from = schemaNode.__$refResolved;
+        const to = schemaNode;
+        delete schemaNode.$ref;
+        delete schemaNode.__$refResolved;
+        for (const key in from) {
+          if (Object.hasOwn(from, key)) {
+            copyProp(from, to, key);
+          }
         }
       }
-      for (key in schema) {
-        if (Object.hasOwn(schema, key)) {
+      const record = node as Record<string, unknown>;
+      for (const key in record) {
+        if (Object.hasOwn(record, key)) {
           if (isInternalKey(key)) {
-            delete (schema as any)[key];
+            delete record[key];
           } else {
-            cleanup((schema as any)[key]);
+            cleanup(record[key]);
           }
         }
       }

package/src/z-schema-options.ts

@@ -1,7 +1,8 @@
 import type { FormatValidatorFn } from './format-validators.js';
+import type { JsonSchemaVersion } from './json-schema-versions.js';
 import type { Report } from './report.js';
 
-import { CURRENT_DEFAULT_SCHEMA_VERSION, type JsonSchemaVersion } from './json-schema-versions.js';
+import { CURRENT_DEFAULT_SCHEMA_VERSION } from './json-schema-versions.js';
 import { shallowClone } from './utils/clone.js';
 import { DEFAULT_MAX_RECURSION_DEPTH, MAX_ASYNC_TIMEOUT } from './utils/constants.js';
 
@@ -103,7 +104,7 @@ export const normalizeOptions = (options?: ZSchemaOptions) => {
     // check that the options are correctly configured
     for (const key of keys) {
       if (defaultOptions[key] === undefined) {
-        throw new Error('Unexpected option passed to constructor: ' + key);
+        throw new Error(`Unexpected option passed to constructor: ${key}`);
       }
     }
 
@@ -111,7 +112,7 @@ export const normalizeOptions = (options?: ZSchemaOptions) => {
     keys = Object.keys(defaultOptions) as Array<keyof ZSchemaOptions>;
     for (const key of keys) {
       if (options[key] === undefined) {
-        (options as any)[key] = shallowClone(defaultOptions[key]);
+        (options as Record<string, unknown>)[key] = shallowClone(defaultOptions[key]);
       }
     }