z-schema 9.0.1 → 10.0.0

package/dist/types/json-schema.d.ts

@@ -1,11 +1,10 @@
+import type { JsonSchema, JsonSchemaInternal } from './json-schema-versions.js';
 import type { Reference } from './schema-compiler.js';
 import type { ZSchemaOptions } from './z-schema-options.js';
-export type JsonSchemaVersion = 'draft-04';
-export declare const VERSION_SCHEMA_URL_MAPPING: Record<JsonSchemaVersion, string>;
-export interface JsonSchema {
+export interface JsonSchemaCommon {
     $ref?: string;
-    id?: string;
     $schema?: string;
+    id?: string;
     title?: string;
     description?: string;
     default?: unknown;
@@ -13,12 +12,9 @@ export interface JsonSchema {
     type?: string | string[];
     properties?: Record<string, JsonSchema>;
     patternProperties?: Record<string, JsonSchema>;
-    dependencies?: Record<string, string[]>;
     multipleOf?: number;
     minimum?: number;
-    exclusiveMinimum?: boolean;
     maximum?: number;
-    exclusiveMaximum?: boolean;
     minLength?: number;
     maxLength?: number;
     pattern?: string;
@@ -31,6 +27,7 @@ export interface JsonSchema {
     maxProperties?: number;
     required?: string[];
     additionalProperties?: boolean | JsonSchema;
+    dependencies?: Record<string, string[] | JsonSchema>;
     enum?: Array<unknown>;
     format?: string;
     allOf?: JsonSchema[];
@@ -48,6 +45,5 @@ export interface ZSchemaInternalProperties {
     __$validationOptions?: ZSchemaOptions;
     __$visited?: boolean;
 }
-export interface JsonSchemaInternal extends JsonSchema, ZSchemaInternalProperties {
-}
+export declare const getId: (schema: JsonSchemaInternal) => string | undefined;
 export declare const findId: (schema: JsonSchemaInternal, id: string) => JsonSchemaInternal | undefined;

package/dist/types/json-validation.d.ts

@@ -1,7 +1,7 @@
-import type { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+import type { JsonSchema, JsonSchemaAll, JsonSchemaInternal } from './json-schema-versions.js';
 import type { ZSchemaBase } from './z-schema-base.js';
 import { Report } from './report.js';
 type JsonValidatorFn = (this: ZSchemaBase, report: Report, schema: JsonSchema, json: unknown) => void;
-export declare const JsonValidators: Record<keyof JsonSchema, JsonValidatorFn>;
-export declare function validate(this: ZSchemaBase, report: Report, schema: JsonSchemaInternal, json: unknown): boolean;
+export declare const JsonValidators: Record<keyof JsonSchemaAll, JsonValidatorFn>;
+export declare function validate(this: ZSchemaBase, report: Report, schema: boolean | JsonSchemaInternal, json: unknown): boolean;
 export {};

package/dist/types/report.d.ts

@@ -1,5 +1,5 @@
 import type { ErrorCode, ErrorParam } from './errors.js';
-import type { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+import type { JsonSchema, JsonSchemaInternal } from './json-schema-versions.js';
 import type { ValidateCallback, ValidateOptions } from './z-schema-base.js';
 import type { ZSchemaOptions } from './z-schema-options.js';
 export interface SchemaErrorDetail {
@@ -77,8 +77,8 @@ export declare class Report {
     getSchemaPath(): Array<string | number>;
     getSchemaId(): string | undefined;
     hasError(errCode: string, errParams: Array<any>): boolean;
-    addError(errCode: ErrorCode, errParams?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema, keyword?: keyof JsonSchema): void;
+    addError(errCode: ErrorCode, errParams?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema | boolean, keyword?: keyof JsonSchema): void;
     getJson(): unknown;
-    addCustomError(errorCode: ErrorCode, errorMessage: string, params?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema, keyword?: keyof JsonSchema): void;
+    addCustomError(errorCode: ErrorCode, errorMessage: string, params?: ErrorParam[], subReports?: Report | Report[], schema?: JsonSchema | boolean, keyword?: keyof JsonSchema): void;
 }
 export {};

package/dist/types/schema-cache.d.ts

@@ -1,4 +1,4 @@
-import type { JsonSchema, JsonSchemaInternal } from './json-schema.js';
+import type { JsonSchema, JsonSchemaInternal } from './json-schema-versions.js';
 import type { ZSchemaBase } from './z-schema-base.js';
 import { Report } from './report.js';
 export type SchemaCacheStorage = Record<string, JsonSchemaInternal>;

package/dist/types/schema-compiler.d.ts

@@ -1,4 +1,4 @@
-import type { JsonSchemaInternal } from './json-schema.js';
+import type { JsonSchemaInternal } from './json-schema-versions.js';
 import type { ZSchemaBase } from './z-schema-base.js';
 import { Report } from './report.js';
 interface Id {

package/dist/types/schema-validator.d.ts

@@ -1,4 +1,4 @@
-import type { JsonSchemaInternal } from './json-schema.js';
+import type { JsonSchemaInternal } from './json-schema-versions.js';
 import type { ZSchemaBase } from './z-schema-base.js';
 import { Report } from './report.js';
 export declare class SchemaValidator {

package/dist/types/utils/what-is.d.ts

@@ -1,3 +1,4 @@
 export type WHAT_IS = 'undefined' | 'null' | 'object' | 'array' | 'integer' | 'number' | 'string' | 'not-a-number' | 'unknown-number' | 'bigint' | 'boolean' | 'symbol' | 'function';
 export declare const whatIs: (what: unknown) => WHAT_IS;
 export declare function isObject(value: unknown): value is Record<any, any>;
+export declare function isInteger(value: unknown): value is number;

package/dist/types/z-schema-base.d.ts

@@ -1,8 +1,8 @@
 import type { ValidateError } from './errors.js';
 import type { FormatValidatorFn } from './format-validators.js';
+import type { JsonSchema } from './json-schema-versions.js';
 import type { ZSchemaOptions } from './z-schema-options.js';
 import { type Errors } from './errors.js';
-import { type JsonSchema } from './json-schema.js';
 import { SchemaCache } from './schema-cache.js';
 import { SchemaCompiler } from './schema-compiler.js';
 import { SchemaValidator } from './schema-validator.js';

package/dist/types/z-schema-options.d.ts

@@ -1,6 +1,6 @@
 import type { FormatValidatorFn } from './format-validators.js';
-import type { JsonSchemaVersion } from './json-schema.js';
 import type { Report } from './report.js';
+import { type JsonSchemaVersion } from './json-schema-versions.js';
 export interface ZSchemaOptions {
     version?: JsonSchemaVersion | 'none';
     asyncTimeout?: number;

package/dist/types/z-schema-reader.d.ts

@@ -1,4 +1,4 @@
-import type { JsonSchema } from './json-schema.js';
+import type { JsonSchema } from './json-schema-versions.js';
 export type SchemaReader = (uri: string) => JsonSchema;
 export declare function getSchemaReader(): SchemaReader | undefined;
 export declare function setSchemaReader(schemaReader: SchemaReader | undefined): void;

package/dist/types/z-schema-versions.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/z-schema.d.ts

@@ -1,10 +1,13 @@
 import type { FormatValidatorFn } from './format-validators.js';
-import type { JsonSchema } from './json-schema.js';
+import type { JsonSchema } from './json-schema-versions.js';
 import type { ValidateOptions, ValidateResponse } from './z-schema-base.js';
 import type { ZSchemaOptions } from './z-schema-options.js';
 import type { SchemaReader } from './z-schema-reader.js';
+import './z-schema-versions.js';
 import { ZSchemaBase } from './z-schema-base.js';
 export declare class ZSchema extends ZSchemaBase {
+    /** @deprecated Use ZSchema.create() instead. */
+    private constructor();
     static registerFormat(name: string, validatorFunction: FormatValidatorFn): void;
     static unregisterFormat(name: string): void;
     static getRegisteredFormats(): string[];
@@ -33,14 +36,20 @@ export declare class ZSchema extends ZSchemaBase {
     validateSchemaSafe(schemaOrArr: JsonSchema | JsonSchema[]): ValidateResponse;
 }
 export declare class ZSchemaSafe extends ZSchemaBase {
+    /** @deprecated Use ZSchema.create() instead. */
+    private constructor();
     validate(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): ValidateResponse;
     validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): ValidateResponse;
 }
 export declare class ZSchemaAsync extends ZSchemaBase {
+    /** @deprecated Use ZSchema.create() instead. */
+    private constructor();
     validate(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): Promise<true>;
     validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): true;
 }
 export declare class ZSchemaAsyncSafe extends ZSchemaBase {
+    /** @deprecated Use ZSchema.create() instead. */
+    private constructor();
     validate(json: unknown, schema: JsonSchema | string, options?: ValidateOptions): Promise<ValidateResponse>;
     validateSchema(schemaOrArr: JsonSchema | JsonSchema[]): ValidateResponse;
 }

package/dist/utils/schema-regex.js

@@ -1,9 +1,10 @@
 // Shared regex compilation helper for JSON Schema patterns
 // Returns { ok: true, value: RegExp } or { ok: false, error: { pattern, message } }
 export function compileSchemaRegex(pattern) {
-    // Detect Unicode property escapes
-    const unicodeEscape = /\\[pP]{/;
-    const needsUnicode = unicodeEscape.test(pattern);
+    const unicodePropertyEscape = /\\[pP]{/;
+    const nonBmpCharacter = /[\u{10000}-\u{10FFFF}]/u;
+    const surrogatePairEscape = /\\uD[89AB][0-9A-Fa-f]{2}\\uD[CDEF][0-9A-Fa-f]{2}/;
+    const needsUnicode = unicodePropertyEscape.test(pattern) || nonBmpCharacter.test(pattern) || surrogatePairEscape.test(pattern);
     // Try compiling without 'u' flag if not needed
     if (needsUnicode) {
         // Try compiling with 'u' flag only

package/dist/utils/what-is.js

@@ -25,5 +25,8 @@ export const whatIs = (what) => {
     return typeof what; // undefined, boolean, string, function
 };
 export function isObject(value) {
-    return whatIs(value) === 'object';
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function isInteger(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value % 1 === 0;
 }

package/dist/z-schema-base.js

@@ -1,6 +1,6 @@
 import { getValidateError } from './errors.js';
 import { getSupportedFormats } from './format-validators.js';
-import { VERSION_SCHEMA_URL_MAPPING } from './json-schema.js';
+import { VERSION_SCHEMA_URL_MAPPING } from './json-schema-versions.js';
 import { validate as validateJson } from './json-validation.js';
 import { Report } from './report.js';
 import { SchemaCache } from './schema-cache.js';
@@ -10,7 +10,7 @@ import { deepClone } from './utils/clone.js';
 import { get, sortedKeys } from './utils/json.js';
 import { copyProp } from './utils/properties.js';
 import { getRemotePath } from './utils/uri.js';
-import { whatIs } from './utils/what-is.js';
+import { isObject, whatIs } from './utils/what-is.js';
 import { defaultOptions, normalizeOptions } from './z-schema-options.js';
 export class ZSchemaBase {
     scache;
@@ -42,9 +42,8 @@ export class ZSchemaBase {
             options = {};
         }
         this.validateOptions = options;
-        const schemaType = whatIs(schema);
-        if (schemaType !== 'string' && schemaType !== 'object') {
-            const e = new Error('Invalid .validate call - schema must be a string or object but ' + schemaType + ' was passed!');
+        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!');
             if (callback) {
                 setTimeout(function () {
                     callback(e, false);

package/dist/z-schema-options.js

@@ -1,6 +1,8 @@
+import { CURRENT_DEFAULT_SCHEMA_VERSION } from './json-schema-versions.js';
 import { shallowClone } from './utils/clone.js';
 export const defaultOptions = {
-    version: 'draft-04',
+    // default version to validate against
+    version: CURRENT_DEFAULT_SCHEMA_VERSION,
     // default timeout for all async tasks
     asyncTimeout: 2000,
     // force additionalProperties and additionalItems to be defined on "object" and "array" types

package/dist/z-schema-versions.js

@@ -0,0 +1,27 @@
+import { SchemaCache } from './schema-cache.js';
+import { normalizeOptions } from './z-schema-options.js';
+import _Draft4HyperSchema from './schemas/draft-04-hyper-schema.json' with { type: 'json' };
+import _Draft4Schema from './schemas/draft-04-schema.json' with { type: 'json' };
+import _Draft6HyperSchema from './schemas/draft-06-hyper-schema.json' with { type: 'json' };
+import _Draft6Links from './schemas/draft-06-links.json' with { type: 'json' };
+import _Draft6Schema from './schemas/draft-06-schema.json' with { type: 'json' };
+const Draft4Schema = _Draft4Schema;
+const Draft4HyperSchema = _Draft4HyperSchema;
+const Draft6Schema = _Draft6Schema;
+const Draft6HyperSchema = _Draft6HyperSchema;
+const Draft6Links = _Draft6Links;
+const registerRemoteReference = (uri, schema, validationOptions) => {
+    const preparedSchema = schema;
+    if (!preparedSchema.id) {
+        preparedSchema.id = uri;
+    }
+    if (validationOptions) {
+        preparedSchema.__$validationOptions = normalizeOptions(validationOptions);
+    }
+    SchemaCache.cacheSchemaByUri(uri, preparedSchema);
+};
+registerRemoteReference('http://json-schema.org/draft-04/schema', Draft4Schema, { version: 'none' });
+registerRemoteReference('http://json-schema.org/draft-04/hyper-schema', Draft4HyperSchema, { version: 'none' });
+registerRemoteReference('http://json-schema.org/draft-06/schema', Draft6Schema, { version: 'none' });
+registerRemoteReference('http://json-schema.org/draft-06/hyper-schema', Draft6HyperSchema, { version: 'none' });
+registerRemoteReference('http://json-schema.org/draft-06/links', Draft6Links, { version: 'none' });

package/dist/z-schema.js

@@ -1,3 +1,4 @@
+import './z-schema-versions.js';
 import { getRegisteredFormats, registerFormat, unregisterFormat } from './format-validators.js';
 import { SchemaCache } from './schema-cache.js';
 import { deepClone } from './utils/clone.js';
@@ -5,10 +6,11 @@ import { jsonSymbol, schemaSymbol } from './utils/symbols.js';
 import { ZSchemaBase } from './z-schema-base.js';
 import { defaultOptions, normalizeOptions } from './z-schema-options.js';
 import { getSchemaReader, setSchemaReader } from './z-schema-reader.js';
-// import schemas so they don't have to be downloaded for validation purposes
-import _Draft4HyperSchema from './schemas/draft-04-hyper-schema.json' with { type: 'json' };
-import _Draft4Schema from './schemas/draft-04-schema.json' with { type: 'json' };
 export class ZSchema extends ZSchemaBase {
+    /** @deprecated Use ZSchema.create() instead. */
+    constructor(options) {
+        super(options);
+    }
     // ----- static methods start -----
     // class scoped format functions
     static registerFormat(name, validatorFunction) {
@@ -55,14 +57,18 @@ export class ZSchema extends ZSchemaBase {
         delete options.safe;
         options.__called_from_factory__ = true;
         if (isAsync && isSafe) {
+            // @ts-expect-error Factory can use private/deprecated constructor
             return new ZSchemaAsyncSafe(options);
         }
         if (isAsync) {
+            // @ts-expect-error Factory can use private/deprecated constructor
             return new ZSchemaAsync(options);
         }
         if (isSafe) {
+            // @ts-expect-error Factory can use private/deprecated constructor
             return new ZSchemaSafe(options);
         }
+        // Factory can use private/deprecated constructor
         return new ZSchema(options);
     }
     validate(json, schema, options = {}) {
@@ -113,6 +119,10 @@ export class ZSchema extends ZSchemaBase {
     }
 }
 export class ZSchemaSafe extends ZSchemaBase {
+    /** @deprecated Use ZSchema.create() instead. */
+    constructor(options) {
+        super(options);
+    }
     validate(json, schema, options = {}) {
         try {
             this._validate(json, schema, options);
@@ -133,6 +143,10 @@ export class ZSchemaSafe extends ZSchemaBase {
     }
 }
 export class ZSchemaAsync extends ZSchemaBase {
+    /** @deprecated Use ZSchema.create() instead. */
+    constructor(options) {
+        super(options);
+    }
     validate(json, schema, options = {}) {
         return new Promise((resolve, reject) => {
             try {
@@ -148,6 +162,10 @@ export class ZSchemaAsync extends ZSchemaBase {
     }
 }
 export class ZSchemaAsyncSafe extends ZSchemaBase {
+    /** @deprecated Use ZSchema.create() instead. */
+    constructor(options) {
+        super(options);
+    }
     validate(json, schema, options = {}) {
         return new Promise((resolve) => {
             try {
@@ -170,7 +188,3 @@ export class ZSchemaAsyncSafe extends ZSchemaBase {
         }
     }
 }
-const Draft4Schema = _Draft4Schema;
-const Draft4HyperSchema = _Draft4HyperSchema;
-ZSchema.setRemoteReference('http://json-schema.org/draft-04/schema', Draft4Schema, { version: 'none' });
-ZSchema.setRemoteReference('http://json-schema.org/draft-04/hyper-schema', Draft4HyperSchema, { version: 'none' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "z-schema",
-  "version": "9.0.1",
+  "version": "10.0.0",
   "engines": {
     "node": ">=22.0.0"
   },
@@ -67,7 +67,7 @@
     "test:coverage": "vitest run --coverage",
     "test:node": "vitest run --project node --silent=false",
     "test:browser": "vitest run --project browser --silent=false",
-    "test:sample": "npx vitest run --silent=false --hideSkippedTests --project node -t \"invalid definition\""
+    "test:sample": "npx vitest run --silent=false --hideSkippedTests --project node -t \"draft6/exclusiveMinimum.json\""
   },
   "dependencies": {
     "validator": "^13.15.26"

package/src/errors.ts

@@ -59,6 +59,12 @@ export const Errors = {
   ASYNC_TIMEOUT: '{0} asynchronous task(s) have timed out after {1} ms',
   PARENT_SCHEMA_VALIDATION_FAILED: 'Schema failed to validate against its parent schema, see inner errors for details.',
   REMOTE_NOT_VALID: "Remote reference didn't compile successfully: {0}",
+
+  // Draft-06 errors
+  SCHEMA_IS_FALSE: 'Boolean schema "false" is always invalid.',
+  CONST: 'Value does not match const: {0}',
+  CONTAINS: 'Array does not contain an item matching the schema',
+  PROPERTY_NAMES: 'Property name {0} does not match the propertyNames schema',
 };
 
 export class ValidateError extends Error {

package/src/format-validators.ts

@@ -200,6 +200,65 @@ const uriValidator: FormatValidatorFn = function (uri: unknown) {
   return /^[a-zA-Z][a-zA-Z0-9+.-]*:[^"\\<>^{}^`| ]*$/.test(uri);
 };
 
+const uriReferenceValidator: FormatValidatorFn = (uri: unknown) => {
+  if (typeof uri !== 'string') return true;
+  // eslint-disable-next-line no-control-regex
+  if (/[^\x00-\x7F]/.test(uri)) return false;
+  // URI-reference allows relative URIs
+  return /^([a-zA-Z][a-zA-Z0-9+.-]*:)?[^"\\<>^{}^`| ]*$/.test(uri);
+};
+
+const uriTemplateValidator: FormatValidatorFn = (uri: unknown) => {
+  if (typeof uri !== 'string') return true;
+  // URI template allows braces for expressions.
+  if (!/^([a-zA-Z][a-zA-Z0-9+.-]*:)?[^"\\<>^`| ]*$/.test(uri)) {
+    return false;
+  }
+
+  let inExpression = false;
+  for (let idx = 0; idx < uri.length; idx++) {
+    const ch = uri[idx];
+    if (ch === '{') {
+      if (inExpression) {
+        return false;
+      }
+      inExpression = true;
+    } else if (ch === '}') {
+      if (!inExpression) {
+        return false;
+      }
+      inExpression = false;
+    }
+  }
+
+  return !inExpression;
+};
+
+const jsonPointerValidator: FormatValidatorFn = (pointer: unknown) => {
+  if (typeof pointer !== 'string') return true;
+  // JSON Pointer: empty, or a sequence of '/'-prefixed reference tokens.
+  // In each token, '~' must be escaped as '~0' or '~1'.
+  return pointer === '' || /^(?:\/(?:[^~]|~0|~1)*)+$/.test(pointer);
+};
+
+const relativeJsonPointerValidator: FormatValidatorFn = (pointer: unknown) => {
+  if (typeof pointer !== 'string') return true;
+  // Relative JSON Pointer: number#path or empty
+  return /^\d+(#.*)?$/.test(pointer) || pointer === '';
+};
+
+const timeValidator: FormatValidatorFn = (time: unknown) => {
+  if (typeof time !== 'string') return true;
+  // time: hh:mm:ss[.fraction]
+  return /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)(\.\d+)?$/.test(time);
+};
+
+const idnEmailValidator: FormatValidatorFn = (email: unknown) => {
+  if (typeof email !== 'string') return true;
+  // Simple email check, allowing international chars
+  return /^[^\s@]+@[^\s@]+$/.test(email);
+};
+
 export interface FormatValidatorsOptions {
   strictUris?: boolean;
   customFormats?: Record<string, FormatValidatorFn | null>;
@@ -216,6 +275,12 @@ const inbuiltValidators: Record<string, FormatValidatorFn> = {
   regex: regexValidator,
   uri: uriValidator,
   'strict-uri': strictUriValidator,
+  'uri-reference': uriReferenceValidator,
+  'uri-template': uriTemplateValidator,
+  'json-pointer': jsonPointerValidator,
+  'relative-json-pointer': relativeJsonPointerValidator,
+  time: timeValidator,
+  'idn-email': idnEmailValidator,
 } as const;
 
 const customValidators: Record<string, FormatValidatorFn> = {};

package/src/index.ts

@@ -13,7 +13,8 @@ export {
   registerFormat,
   unregisterFormat,
 } from './format-validators.js';
-export type { JsonSchema, JsonSchemaType } from './json-schema.js';
+export type { JsonSchemaType } from './json-schema.js';
+export type { JsonSchema } from './json-schema-versions.js';
 export type { Report, SchemaErrorDetail } from './report.js';
 export type { ZSchema, ZSchemaAsync, ZSchemaAsyncSafe, ZSchemaSafe } from './z-schema.js';
 export { ValidateOptions, ValidateResponse } from './z-schema-base.js';

package/src/json-schema-versions.ts

@@ -0,0 +1,34 @@
+import type { JsonSchemaCommon, ZSchemaInternalProperties } from './json-schema.js';
+
+// TODO: currently unsupported 'draft-07', '2019-09', '2020-12'
+export type JsonSchemaVersion = 'draft-04' | 'draft-06';
+
+export const CURRENT_DEFAULT_SCHEMA_VERSION: JsonSchemaVersion = 'draft-06';
+
+export const VERSION_SCHEMA_URL_MAPPING: Record<JsonSchemaVersion, string> = {
+  'draft-04': 'http://json-schema.org/draft-04/schema#',
+  'draft-06': 'http://json-schema.org/draft-06/schema#',
+};
+
+export type JsonSchema = JsonSchemaDraft4 | JsonSchemaDraft6;
+export type JsonSchemaAll = JsonSchemaDraft4 & JsonSchemaDraft6;
+
+export type JsonSchemaInternal = JsonSchema & ZSchemaInternalProperties;
+export type JsonSchemaInternalAll = JsonSchemaAll & ZSchemaInternalProperties;
+export type JsonSchemaInternalD4 = JsonSchemaDraft4 & ZSchemaInternalProperties;
+export type JsonSchemaInternalD6 = JsonSchemaDraft6 & ZSchemaInternalProperties;
+
+export interface JsonSchemaDraft4 extends JsonSchemaCommon {
+  exclusiveMaximum?: boolean;
+  exclusiveMinimum?: boolean;
+}
+
+export interface JsonSchemaDraft6 extends JsonSchemaCommon {
+  $id?: string;
+  examples?: unknown[];
+  const?: unknown;
+  contains?: JsonSchema;
+  propertyNames?: JsonSchema;
+  exclusiveMaximum?: number;
+  exclusiveMinimum?: number;
+}

package/src/json-schema.ts

@@ -1,19 +1,19 @@
+import type {
+  JsonSchema,
+  JsonSchemaInternal,
+  JsonSchemaInternalD4,
+  JsonSchemaInternalD6,
+} from './json-schema-versions.js';
 import type { Reference } from './schema-compiler.js';
 import type { ZSchemaOptions } from './z-schema-options.js';
 
 import { isObject } from './utils/what-is.js';
 
-// TODO: currently unsupported 'draft-06', 'draft-07', '2019-09', '2020-12'
-export type JsonSchemaVersion = 'draft-04';
-
-export const VERSION_SCHEMA_URL_MAPPING: Record<JsonSchemaVersion, string> = {
-  'draft-04': 'http://json-schema.org/draft-04/schema#',
-};
-
-export interface JsonSchema {
+// common properties of all JSON Schema versions
+export interface JsonSchemaCommon {
   $ref?: string;
-  id?: string;
   $schema?: string;
+  id?: string;
   title?: string;
   description?: string;
   default?: unknown;
@@ -21,13 +21,9 @@ export interface JsonSchema {
   type?: string | string[];
   properties?: Record<string, JsonSchema>;
   patternProperties?: Record<string, JsonSchema>;
-  dependencies?: Record<string, string[]>;
-  // properties
   multipleOf?: number;
   minimum?: number;
-  exclusiveMinimum?: boolean;
   maximum?: number;
-  exclusiveMaximum?: boolean;
   minLength?: number;
   maxLength?: number;
   pattern?: string;
@@ -40,6 +36,7 @@ export interface JsonSchema {
   maxProperties?: number;
   required?: string[];
   additionalProperties?: boolean | JsonSchema;
+  dependencies?: Record<string, string[] | JsonSchema>;
   enum?: Array<unknown>;
   format?: string;
   allOf?: JsonSchema[];
@@ -60,7 +57,15 @@ export interface ZSchemaInternalProperties {
   __$visited?: boolean;
 }
 
-export interface JsonSchemaInternal extends JsonSchema, ZSchemaInternalProperties {}
+export const getId = (schema: JsonSchemaInternal) => {
+  if ((schema as JsonSchemaInternalD6).$id) {
+    return (schema as JsonSchemaInternalD6).$id;
+  }
+  if ((schema as JsonSchemaInternalD4).id) {
+    return (schema as JsonSchemaInternalD4).id;
+  }
+  return undefined;
+};
 
 export const findId = (schema: JsonSchemaInternal, id: string): JsonSchemaInternal | undefined => {
   // process only arrays and objects
@@ -73,8 +78,9 @@ export const findId = (schema: JsonSchemaInternal, id: string): JsonSchemaIntern
     return schema;
   }
 
-  if (schema.id) {
-    if (schema.id === id || (schema.id[0] === '#' && schema.id.substring(1) === id)) {
+  const schemaId = getId(schema);
+  if (schemaId) {
+    if (schemaId === id || (schemaId[0] === '#' && schemaId.substring(1) === id)) {
       return schema;
     }
   }