z-schema 12.0.4 → 12.1.0

package/dist/report.mjs

@@ -0,0 +1,194 @@
+import { isAbsoluteUri } from "./utils/uri.mjs";
+import { MAX_ASYNC_TIMEOUT } from "./utils/constants.mjs";
+import { isObject } from "./utils/what-is.mjs";
+import { Errors, getValidateError } from "./errors.mjs";
+import { shallowClone } from "./utils/clone.mjs";
+import { get } from "./utils/json.mjs";
+import { jsonSymbol, schemaSymbol } from "./utils/symbols.mjs";
+//#region src/report.ts
+const ASYNC_TIMEOUT_POLL_MS = 10;
+var Report = class Report {
+	asyncTasks = [];
+	commonErrorMessage;
+	__$recursiveAnchorStack = [];
+	__$dynamicScopeStack = [];
+	__validationResultCache = /* @__PURE__ */ new Map();
+	errors = [];
+	json;
+	path = [];
+	schemaPath = [];
+	rootSchema;
+	parentReport;
+	options;
+	reportOptions;
+	validateOptions = {};
+	constructor(parentOrOptions, reportOptionsOrValidate, validateOptions) {
+		this.parentReport = parentOrOptions instanceof Report ? parentOrOptions : void 0;
+		this.options = parentOrOptions instanceof Report ? parentOrOptions.options : parentOrOptions || {};
+		if (parentOrOptions instanceof Report) {
+			this.reportOptions = reportOptionsOrValidate || {};
+			this.validateOptions = validateOptions || parentOrOptions.validateOptions;
+			this.__$recursiveAnchorStack = [...parentOrOptions.__$recursiveAnchorStack];
+			this.__$dynamicScopeStack = [...parentOrOptions.__$dynamicScopeStack];
+			this.__validationResultCache = parentOrOptions.__validationResultCache;
+		} else {
+			this.reportOptions = {};
+			this.validateOptions = reportOptionsOrValidate || {};
+			this.__$recursiveAnchorStack = [];
+			this.__$dynamicScopeStack = [];
+			this.__validationResultCache = /* @__PURE__ */ new Map();
+		}
+	}
+	isValid() {
+		if (this.asyncTasks.length > 0) throw new Error("Async tasks pending, can't answer isValid");
+		return this.errors.length === 0;
+	}
+	addAsyncTask(fn, args, asyncTaskResultProcessFn) {
+		this.asyncTasks.push([
+			fn,
+			args,
+			asyncTaskResultProcessFn
+		]);
+	}
+	/**
+	* Like {@link addAsyncTask}, but automatically saves the current `path` and
+	* restores it around `processFn`.  This eliminates the manual
+	* path-save/restore boilerplate that every async-aware validator would
+	* otherwise need.
+	*/
+	addAsyncTaskWithPath(fn, args, processFn) {
+		const pathBefore = shallowClone(this.path);
+		this.asyncTasks.push([
+			fn,
+			args,
+			(result) => {
+				const backup = this.path;
+				this.path = pathBefore;
+				processFn(result);
+				this.path = backup;
+			}
+		]);
+	}
+	getAncestor(id) {
+		if (!this.parentReport) return;
+		if (this.parentReport.getSchemaId() === id) return this.parentReport;
+		return this.parentReport.getAncestor(id);
+	}
+	processAsyncTasks(timeout, callback) {
+		const validationTimeout = Math.min(Math.max(timeout || 2e3, 0), MAX_ASYNC_TIMEOUT);
+		const timeoutAt = Date.now() + validationTimeout;
+		let tasksCount = this.asyncTasks.length;
+		let timedOut = false;
+		const finish = () => {
+			setTimeout(() => {
+				const valid = this.errors.length === 0;
+				callback(valid ? void 0 : getValidateError({ details: this.errors }), valid);
+			}, 0);
+		};
+		const respond = (asyncTaskResultProcessFn) => (asyncTaskResult) => {
+			if (timedOut) return;
+			asyncTaskResultProcessFn(asyncTaskResult);
+			if (--tasksCount === 0) finish();
+		};
+		if (tasksCount === 0 || this.errors.length > 0 && this.options.breakOnFirstError) {
+			finish();
+			return;
+		}
+		for (let i = 0; i < this.asyncTasks.length; i++) {
+			const [fn, fnArgs, processFn] = this.asyncTasks[i];
+			const respondCallback = respond(processFn);
+			fn(...fnArgs, respondCallback);
+		}
+		const checkTimeout = () => {
+			if (timedOut || tasksCount <= 0) return;
+			if (Date.now() >= timeoutAt) {
+				timedOut = true;
+				this.addError("ASYNC_TIMEOUT", [tasksCount, validationTimeout]);
+				callback(getValidateError({ details: this.errors }), false);
+				return;
+			}
+			setTimeout(checkTimeout, ASYNC_TIMEOUT_POLL_MS);
+		};
+		setTimeout(checkTimeout, ASYNC_TIMEOUT_POLL_MS);
+	}
+	getPath(returnPathAsString) {
+		let path = [];
+		if (this.parentReport) path = path.concat(this.parentReport.path);
+		path = path.concat(this.path);
+		if (returnPathAsString !== true) return "#/" + path.map(function(segment) {
+			segment = segment.toString();
+			if (isAbsoluteUri(segment)) return "uri(" + segment + ")";
+			return segment.replace(/~/g, "~0").replace(/\//g, "~1");
+		}).join("/");
+		return path;
+	}
+	getSchemaPath() {
+		let schemaPath = [];
+		if (this.parentReport) schemaPath = schemaPath.concat(this.parentReport.schemaPath);
+		schemaPath = schemaPath.concat(this.schemaPath);
+		return schemaPath;
+	}
+	getSchemaId() {
+		if (!this.rootSchema) return;
+		let path = [];
+		if (this.parentReport) path = path.concat(this.parentReport.path);
+		path = path.concat(this.path);
+		while (path.length > 0) {
+			const obj = get(this.rootSchema, path);
+			if (obj && obj.id) return obj.id;
+			path.pop();
+		}
+		return this.rootSchema.id;
+	}
+	hasError(errCode, errParams) {
+		for (let idx = 0; idx < this.errors.length; idx++) if (this.errors[idx].code === errCode) {
+			let match = true;
+			for (let idx2 = 0; idx2 < this.errors[idx].params.length; idx2++) if (this.errors[idx].params[idx2] !== errParams[idx2]) match = false;
+			if (match) return match;
+		}
+		return false;
+	}
+	addError(errCode, errParams, subReports, schema, keyword) {
+		if (!errCode) throw new Error("No errorCode passed into addError()");
+		this.addCustomError(errCode, Errors[errCode], errParams, subReports, schema, keyword);
+	}
+	getJson() {
+		if (this.json) return this.json;
+		if (this.parentReport) return this.parentReport.getJson();
+	}
+	addCustomError(errorCode, errorMessage, params, subReports, schema, keyword) {
+		if (typeof this.reportOptions.maxErrors === "number" && this.errors.length >= this.reportOptions.maxErrors) return;
+		if (!errorMessage) throw new Error("No errorMessage known for code " + errorCode);
+		params = params || [];
+		for (let idx = 0; idx < params.length; idx++) {
+			const param = params[idx] === null || isObject(params[idx]) ? JSON.stringify(params[idx]) : params[idx];
+			errorMessage = errorMessage.replace("{" + idx + "}", param.toString());
+		}
+		const err = {
+			code: errorCode,
+			params,
+			message: errorMessage,
+			path: this.getPath(this.options.reportPathAsArray),
+			schemaPath: this.getSchemaPath(),
+			schemaId: this.getSchemaId(),
+			keyword
+		};
+		err[schemaSymbol] = schema;
+		err[jsonSymbol] = this.getJson();
+		if (schema && typeof schema === "string") err.description = schema;
+		else if (schema && typeof schema === "object") {
+			if (schema.title) err.title = schema.title;
+			if (schema.description) err.description = schema.description;
+		}
+		if (subReports != null) {
+			if (!Array.isArray(subReports)) subReports = [subReports];
+			err.inner = [];
+			for (const subReport of subReports) for (const error of subReport.errors) err.inner.push(error);
+			if (err.inner.length === 0) err.inner = void 0;
+		}
+		if (Array.isArray(this.validateOptions.excludeErrors) && this.validateOptions.excludeErrors.includes(errorCode)) return;
+		this.errors.push(err);
+	}
+};
+//#endregion
+export { Report };

package/dist/schema-cache.d.mts

@@ -0,0 +1,23 @@
+import { Report } from "./report.mjs";
+import { ZSchemaBase } from "./z-schema-base.mjs";
+import { JsonSchema, JsonSchemaInternal } from "./json-schema-versions.mjs";
+
+//#region src/schema-cache.d.ts
+type SchemaCacheStorage = Record<string, JsonSchemaInternal>;
+declare class SchemaCache {
+  private validator;
+  static global_cache: SchemaCacheStorage;
+  cache: SchemaCacheStorage;
+  constructor(validator: ZSchemaBase);
+  static cacheSchemaByUri(uri: string, schema: JsonSchemaInternal): void;
+  cacheSchemaByUri(uri: string, schema: JsonSchemaInternal): void;
+  removeFromCacheByUri(uri: string): void;
+  checkCacheForUri(uri: string): boolean;
+  getSchema(report: Report, refOrSchema: string): JsonSchemaInternal | undefined;
+  getSchema(report: Report, refOrSchema: JsonSchema): JsonSchemaInternal;
+  getSchema(report: Report, refOrSchema: JsonSchema[]): JsonSchemaInternal[];
+  fromCache(path: string): JsonSchemaInternal | undefined;
+  getSchemaByUri(report: Report, uri: string, root?: JsonSchemaInternal): JsonSchemaInternal | undefined;
+}
+//#endregion
+export { SchemaCache };

package/dist/schema-cache.mjs

@@ -0,0 +1,144 @@
+import { getQueryPath, getRemotePath, isAbsoluteUri } from "./utils/uri.mjs";
+import { findId, getId } from "./json-schema.mjs";
+import { deepClone } from "./utils/clone.mjs";
+import { decodeJSONPointer } from "./utils/json.mjs";
+import { Report } from "./report.mjs";
+import { normalizeOptions } from "./z-schema-options.mjs";
+//#region src/schema-cache.ts
+function getSafeRemotePath(uri) {
+	const remotePath = getRemotePath(uri);
+	if (!remotePath) return;
+	if (remotePath === "__proto__" || remotePath === "constructor" || remotePath === "prototype") return;
+	return remotePath;
+}
+const getEffectiveId = (schema) => {
+	let id = getId(schema);
+	if ((!id || !isAbsoluteUri(id)) && typeof schema.id === "string" && isAbsoluteUri(schema.id)) id = schema.id;
+	return id;
+};
+/**
+* Shared logic for registering a remote reference schema.
+* Used by both the static `ZSchema.setRemoteReference()` (global cache) and
+* the instance `validator.setRemoteReference()` (instance cache).
+*/
+function prepareRemoteSchema(schema, uri, validationOptions, maxCloneDepth) {
+	let _schema;
+	if (typeof schema === "string") _schema = JSON.parse(schema);
+	else _schema = deepClone(schema, maxCloneDepth);
+	if (!_schema.id) _schema.id = uri;
+	if (validationOptions) _schema.__$validationOptions = normalizeOptions(validationOptions);
+	return _schema;
+}
+var SchemaCache = class SchemaCache {
+	static global_cache = Object.create(null);
+	cache = Object.create(null);
+	constructor(validator) {
+		this.validator = validator;
+	}
+	static cacheSchemaByUri(uri, schema) {
+		const remotePath = getSafeRemotePath(uri);
+		if (remotePath) this.global_cache[remotePath] = schema;
+	}
+	cacheSchemaByUri(uri, schema) {
+		const remotePath = getSafeRemotePath(uri);
+		if (remotePath) this.cache[remotePath] = schema;
+	}
+	removeFromCacheByUri(uri) {
+		const remotePath = getSafeRemotePath(uri);
+		if (remotePath) delete this.cache[remotePath];
+	}
+	checkCacheForUri(uri) {
+		const remotePath = getSafeRemotePath(uri);
+		return remotePath ? this.cache[remotePath] != null : false;
+	}
+	getSchema(report, refOrSchema) {
+		if (Array.isArray(refOrSchema)) return refOrSchema.map((i) => this.getSchema(report, i));
+		if (typeof refOrSchema === "string") return this.getSchemaByUri(report, refOrSchema);
+		return deepClone(refOrSchema, this.validator.options.maxRecursionDepth);
+	}
+	fromCache(path) {
+		if (path === "__proto__" || path === "constructor" || path === "prototype") return;
+		let found = this.cache[path];
+		if (found) return found;
+		found = SchemaCache.global_cache[path];
+		if (found) {
+			const clone = deepClone(found, this.validator.options.maxRecursionDepth);
+			if (!clone.id || !isAbsoluteUri(clone.id) && isAbsoluteUri(path)) clone.id = path;
+			this.cache[path] = clone;
+			return clone;
+		}
+	}
+	getSchemaByUri(report, uri, root) {
+		if (root && !isAbsoluteUri(uri)) {
+			const rootId = getEffectiveId(root);
+			if (rootId && isAbsoluteUri(rootId)) {
+				const hashIndex = rootId.indexOf("#");
+				const rootBase = hashIndex === -1 ? rootId : rootId.slice(0, hashIndex);
+				try {
+					uri = new URL(uri, rootBase).toString();
+				} catch {}
+			}
+		}
+		const remotePath = getSafeRemotePath(uri);
+		const queryPath = getQueryPath(uri);
+		let result;
+		let resolvedFromAncestor = false;
+		if (remotePath) {
+			const ancestorReport = report.getAncestor(remotePath);
+			if (ancestorReport?.rootSchema) {
+				result = ancestorReport.rootSchema;
+				resolvedFromAncestor = true;
+			}
+		}
+		if (!result && root && remotePath) {
+			const rootId = getEffectiveId(root);
+			const rootRemotePath = rootId ? getRemotePath(rootId) : void 0;
+			if (rootRemotePath && rootRemotePath === remotePath) result = root;
+		}
+		if (!result) result = remotePath ? this.fromCache(remotePath) : root;
+		if (result && remotePath && isAbsoluteUri(remotePath) && (!result.id || !isAbsoluteUri(result.id))) result.id = remotePath;
+		if (result && remotePath) {
+			if (result !== root && !resolvedFromAncestor) {
+				report.path.push(remotePath);
+				let remoteReport;
+				let usesAncestorReport = false;
+				const anscestorReport = result.id ? report.getAncestor(result.id) : void 0;
+				if (anscestorReport) {
+					remoteReport = anscestorReport;
+					usesAncestorReport = true;
+				} else {
+					remoteReport = new Report(report);
+					const noCache = result.id && isAbsoluteUri(result.id) ? false : true;
+					if (this.validator.sc.compileSchema(remoteReport, result, { noCache })) {
+						const savedOptions = this.validator.options;
+						try {
+							this.validator.options = result.__$validationOptions || this.validator.options;
+							const parentSchemaUri = typeof result.$schema === "string" ? getRemotePath(result.$schema) : void 0;
+							const currentSchemaUri = report.getSchemaId();
+							if (!(!!parentSchemaUri && parentSchemaUri.length > 0 && (currentSchemaUri === parentSchemaUri || !!report.getAncestor(parentSchemaUri)))) this.validator.sv.validateSchema(remoteReport, result);
+						} finally {
+							this.validator.options = savedOptions;
+						}
+					}
+				}
+				const remoteReportIsValid = usesAncestorReport ? true : remoteReport.isValid();
+				if (!remoteReportIsValid) report.addError("REMOTE_NOT_VALID", [uri], remoteReport);
+				report.path.pop();
+				if (!remoteReportIsValid) return;
+			}
+		}
+		const resourceRoot = result;
+		if (result && queryPath) {
+			const parts = queryPath.split("/");
+			for (let idx = 0, lim = parts.length; result && idx < lim; idx++) {
+				const key = decodeJSONPointer(parts[idx]);
+				if (idx === 0) result = findId(result, key, remotePath, remotePath, this.validator.options.maxRecursionDepth);
+				else result = result[key];
+			}
+		}
+		if (result && typeof result === "object" && resourceRoot && typeof resourceRoot === "object") result.__$resourceRoot = resourceRoot;
+		return result;
+	}
+};
+//#endregion
+export { SchemaCache, prepareRemoteSchema };

package/dist/schema-compiler.d.mts

@@ -0,0 +1,23 @@
+import { Report } from "./report.mjs";
+import { ZSchemaBase } from "./z-schema-base.mjs";
+import { JsonSchemaInternal } from "./json-schema-versions.mjs";
+
+//#region src/schema-compiler.d.ts
+interface Reference {
+  ref: string;
+  key: '$ref' | '$schema' | '$recursiveRef' | '$dynamicRef';
+  obj: JsonSchemaInternal;
+  path: Array<string | number>;
+}
+declare class SchemaCompiler {
+  private validator;
+  constructor(validator: ZSchemaBase);
+  collectAndCacheIds(schema: JsonSchemaInternal): void;
+  compileSchema(report: Report, schema: JsonSchemaInternal | JsonSchemaInternal[], options?: {
+    noCache?: boolean;
+  }): boolean;
+  compileArrayOfSchemas(report: Report, arr: JsonSchemaInternal[]): boolean;
+  compileArrayOfSchemasLoop(mainReport: Report, arr: JsonSchemaInternal[]): number;
+}
+//#endregion
+export { Reference, SchemaCompiler };

package/dist/schema-compiler.mjs

@@ -0,0 +1,265 @@
+import { getRemotePath, isAbsoluteUri } from "./utils/uri.mjs";
+import { NON_SCHEMA_KEYWORDS, getId, isInternalKey } from "./json-schema.mjs";
+import { Report } from "./report.mjs";
+import { getSchemaReader } from "./z-schema-reader.mjs";
+//#region src/schema-compiler.ts
+const UNSAFE_TARGETS = [
+	Object.prototype,
+	Function.prototype,
+	Array.prototype
+];
+/** Returns true if `obj` is a built-in prototype that must not be mutated. */
+function isUnsafeTarget(obj) {
+	return UNSAFE_TARGETS.includes(obj);
+}
+/** Safely assign a property on `obj`, refusing prototype-polluting keys. */
+function safeSetProperty(obj, key, value) {
+	if (isUnsafeTarget(obj)) return;
+	/** Reject property names that could pollute Object.prototype (CWE-1321). */
+	if (key !== "__proto__" && key !== "constructor" && key !== "prototype") obj[key] = value;
+}
+/** Safely delete a property from `obj`, refusing to mutate built-in prototypes (CWE-1321). */
+function safeDeleteProperty(obj, key) {
+	if (isUnsafeTarget(obj)) return;
+	if (key !== "__proto__" && key !== "constructor" && key !== "prototype") delete obj[key];
+}
+const collectIds = (obj, maxDepth = 100) => {
+	const ids = [];
+	function walk(node, scope, _depth = 0) {
+		if (typeof node !== "object" || node == null) return;
+		if (_depth >= maxDepth) throw new Error(`Maximum recursion depth (${maxDepth}) exceeded in collectIds. If your schema is deeply nested and valid, increase the maxRecursionDepth option.`);
+		let addedScope = false;
+		const nodeId = getId(node);
+		if (typeof nodeId === "string") {
+			let type = isAbsoluteUri(nodeId) ? "absolute" : "relative";
+			if (scope.length === 0) type = "root";
+			const id = {
+				id: nodeId,
+				type,
+				obj: node
+			};
+			if (type === "absolute" || type === "root" && isAbsoluteUri(nodeId)) id.absoluteUri = nodeId;
+			else if (type === "root" && typeof node.id === "string" && isAbsoluteUri(node.id) && node.id !== nodeId) id.absoluteUri = resolveSchemaScopeId(node.id, node, nodeId);
+			else if (type === "relative") {
+				id.absoluteParent = scope.filter((x) => x.type === "absolute" || x.type === "root" && x.absoluteUri).slice(-1)[0];
+				if (id.absoluteParent) id.absoluteUri = resolveSchemaScopeId(id.absoluteParent.absoluteUri || id.absoluteParent.id, node, id.id);
+			}
+			ids.push(id);
+			scope.push(id);
+			addedScope = true;
+		}
+		if (Array.isArray(node)) for (const item of node) walk(item, scope, _depth + 1);
+		else for (const key of Object.keys(node)) {
+			if (isInternalKey(key) || NON_SCHEMA_KEYWORDS.includes(key)) continue;
+			walk(node[key], scope, _depth + 1);
+		}
+		if (addedScope) scope.pop();
+	}
+	walk(obj, []);
+	return ids;
+};
+const collectReferences = (obj, results, scope, path, options, maxDepth = 100, _depth = 0) => {
+	results = results || [];
+	scope = scope || [];
+	path = path || [];
+	options = options || {};
+	if (typeof obj !== "object" || obj === null) return results;
+	if (_depth >= maxDepth) throw new Error(`Maximum recursion depth (${maxDepth}) exceeded in collectReferences. If your schema is deeply nested and valid, increase the maxRecursionDepth option.`);
+	const hasRef = typeof obj.$ref === "string" && typeof obj.__$refResolved === "undefined";
+	let addedScope = false;
+	const isRootScope = scope.length === 0;
+	let scopeId = getId(obj);
+	if (typeof obj.id === "string" && isAbsoluteUri(obj.id) && (!scopeId || !isAbsoluteUri(scopeId))) scopeId = obj.id;
+	if (typeof scopeId === "string" && (isRootScope || !hasRef || options.useRefObjectScope === true)) {
+		const base = scope.length > 0 ? scope[scope.length - 1] : void 0;
+		scope.push(resolveSchemaScopeId(base, obj, scopeId));
+		addedScope = true;
+	}
+	if (hasRef) results.push({
+		ref: resolveReference(scope[scope.length - 1], obj.$ref),
+		key: "$ref",
+		obj,
+		path: path.slice(0)
+	});
+	if (typeof obj.$recursiveRef === "string" && typeof obj.__$recursiveRefResolved === "undefined") results.push({
+		ref: resolveReference(scope[scope.length - 1], obj.$recursiveRef),
+		key: "$recursiveRef",
+		obj,
+		path: path.slice(0)
+	});
+	if (typeof obj.$dynamicRef === "string" && typeof obj.__$dynamicRefResolved === "undefined") results.push({
+		ref: resolveReference(scope[scope.length - 1], obj.$dynamicRef),
+		key: "$dynamicRef",
+		obj,
+		path: path.slice(0)
+	});
+	if (typeof obj.$schema === "string" && typeof obj.__$schemaResolved === "undefined") results.push({
+		ref: resolveReference(scope[scope.length - 1], obj.$schema),
+		key: "$schema",
+		obj,
+		path: path.slice(0)
+	});
+	if (Array.isArray(obj)) for (let i = 0; i < obj.length; i++) {
+		path.push(i);
+		collectReferences(obj[i], results, scope, path, options, maxDepth, _depth + 1);
+		path.pop();
+	}
+	else {
+		const keys = Object.keys(obj);
+		for (const key of keys) {
+			if (isInternalKey(key) || NON_SCHEMA_KEYWORDS.includes(key)) continue;
+			path.push(key);
+			collectReferences(obj[key], results, scope, path, options, maxDepth, _depth + 1);
+			path.pop();
+		}
+	}
+	if (addedScope) scope.pop();
+	return results;
+};
+const resolveReference = (base, ref) => {
+	if (isAbsoluteUri(ref)) return ref;
+	const baseStr = base ?? "";
+	if (ref[0] === "#") {
+		const hashIndex = baseStr.indexOf("#");
+		return (hashIndex === -1 ? baseStr : baseStr.slice(0, hashIndex)) + ref;
+	}
+	if (!baseStr) return ref;
+	const hashIndex = baseStr.indexOf("#");
+	const baseNoFrag = hashIndex === -1 ? baseStr : baseStr.slice(0, hashIndex);
+	if (isAbsoluteUri(baseNoFrag)) try {
+		return new URL(ref, baseNoFrag).toString();
+	} catch {}
+	let baseDir = baseNoFrag;
+	if (!baseDir.endsWith("/")) {
+		const lastSlash = baseDir.lastIndexOf("/");
+		baseDir = lastSlash === -1 ? "" : baseDir.slice(0, lastSlash + 1);
+	}
+	return baseDir + ref;
+};
+const isSimpleIdentifier = (id) => id[0] !== "#" && !id.includes("/") && !id.includes(".") && !id.includes("#");
+const resolveIdScope = (base, id) => {
+	if (isAbsoluteUri(id)) return id;
+	const baseStr = base ?? "";
+	if (isSimpleIdentifier(id)) {
+		const hashIndex = baseStr.indexOf("#");
+		return (hashIndex === -1 ? baseStr : baseStr.slice(0, hashIndex)) + "#" + id;
+	}
+	return resolveReference(base, id);
+};
+const resolveSchemaScopeId = (base, schema, id) => {
+	if (typeof schema.$id === "string") return resolveReference(base, id);
+	return resolveIdScope(base, id);
+};
+var SchemaCompiler = class {
+	constructor(validator) {
+		this.validator = validator;
+	}
+	collectAndCacheIds(schema) {
+		const ids = collectIds(schema, this.validator.options.maxRecursionDepth);
+		for (const item of ids) if (item.absoluteUri) {
+			this.validator.scache.cacheSchemaByUri(item.absoluteUri, item.obj);
+			if (item.type === "relative" && item.absoluteParent && isSimpleIdentifier(item.id)) {
+				const altAbsoluteUri = resolveReference(item.absoluteParent.absoluteUri || item.absoluteParent.id, item.id);
+				this.validator.scache.cacheSchemaByUri(altAbsoluteUri, item.obj);
+			}
+		} else if (item.type === "root") this.validator.scache.cacheSchemaByUri(item.id, item.obj);
+	}
+	compileSchema(report, schema, options) {
+		report.commonErrorMessage = "SCHEMA_COMPILATION_FAILED";
+		if (typeof schema === "string") {
+			const loadedSchema = this.validator.scache.getSchemaByUri(report, schema);
+			if (typeof loadedSchema === "undefined") {
+				report.addError("SCHEMA_NOT_REACHABLE", [schema]);
+				return false;
+			}
+			schema = loadedSchema;
+		}
+		if (Array.isArray(schema)) {
+			if (!options?.noCache) schema.forEach((s) => this.collectAndCacheIds(s));
+			return this.compileArrayOfSchemas(report, schema);
+		} else if (typeof schema === "boolean") return true;
+		else if (!options?.noCache) this.collectAndCacheIds(schema);
+		const canMutateSchemaObject = schema !== Object.prototype && schema !== Function.prototype && schema !== Array.prototype;
+		if (canMutateSchemaObject && schema.__$compiled && schema.id && this.validator.scache.checkCacheForUri(schema.id) === false) schema.__$compiled = void 0;
+		if (schema.__$compiled) return true;
+		if (canMutateSchemaObject && !schema.$schema && this.validator.options.version !== "none") schema.$schema = this.validator.getDefaultSchemaId();
+		if (schema.id && typeof schema.id === "string" && !options?.noCache) this.validator.scache.cacheSchemaByUri(schema.id, schema);
+		let isRoot = false;
+		if (!report.rootSchema) {
+			report.rootSchema = schema;
+			isRoot = true;
+		}
+		const isValidExceptReferences = report.isValid();
+		if (canMutateSchemaObject) safeDeleteProperty(schema, "__$missingReferences");
+		const useRefObjectScope = this.validator.options.version === "draft2019-09" || this.validator.options.version === "draft2020-12";
+		const refs = collectReferences(schema, void 0, void 0, void 0, { useRefObjectScope }, this.validator.options.maxRecursionDepth);
+		for (const refObj of refs) {
+			let response = this.validator.scache.getSchemaByUri(report, refObj.ref, schema);
+			if (typeof response === "undefined") {
+				const schemaReader = getSchemaReader();
+				if (schemaReader) {
+					const remotePath = getRemotePath(refObj.ref);
+					const s = schemaReader(remotePath);
+					if (s) {
+						s.id = remotePath;
+						const subreport = new Report(report);
+						if (!this.compileSchema(subreport, s)) report.errors = report.errors.concat(subreport.errors);
+						else response = this.validator.scache.getSchemaByUri(report, refObj.ref, schema);
+					}
+				}
+			}
+			if (typeof response === "undefined") {
+				const hasNotValid = report.hasError("REMOTE_NOT_VALID", [refObj.ref]);
+				const isAbsolute = isAbsoluteUri(refObj.ref);
+				let isDownloaded = false;
+				const ignoreUnresolvableRemotes = this.validator.options.ignoreUnresolvableReferences === true;
+				if (isAbsolute) isDownloaded = this.validator.scache.checkCacheForUri(refObj.ref);
+				if (hasNotValid) {} else if (ignoreUnresolvableRemotes && isAbsolute) {} else if (isDownloaded) {} else {
+					report.path.push(...refObj.path);
+					report.addError("UNRESOLVABLE_REFERENCE", [refObj.ref]);
+					report.path = report.path.slice(0, -refObj.path.length);
+					if (isValidExceptReferences && canMutateSchemaObject && !isUnsafeTarget(schema)) {
+						schema.__$missingReferences = schema.__$missingReferences || [];
+						schema.__$missingReferences.push(refObj);
+					}
+				}
+			}
+			safeSetProperty(refObj.obj, `__${refObj.key}Resolved`, response);
+		}
+		const isValid = report.isValid();
+		if (isValid && canMutateSchemaObject) schema.__$compiled = true;
+		if (isRoot) report.rootSchema = void 0;
+		return isValid;
+	}
+	compileArrayOfSchemas(report, arr) {
+		let compiled = 0, lastLoopCompiled;
+		do {
+			report.errors = report.errors.filter((e) => e.code !== "UNRESOLVABLE_REFERENCE");
+			lastLoopCompiled = compiled;
+			compiled = this.compileArrayOfSchemasLoop(report, arr);
+			for (const sch of arr) if (sch.__$missingReferences) {
+				for (let idx2 = sch.__$missingReferences.length - 1; idx2 >= 0; idx2--) {
+					const refObj = sch.__$missingReferences[idx2];
+					const response = arr.find((x) => x.id === refObj.ref);
+					if (response) {
+						safeSetProperty(refObj.obj, `__${refObj.key}Resolved`, response);
+						sch.__$missingReferences.splice(idx2, 1);
+					}
+				}
+				if (sch.__$missingReferences.length === 0) safeDeleteProperty(sch, "__$missingReferences");
+			}
+		} while (compiled !== arr.length && compiled !== lastLoopCompiled);
+		return report.isValid();
+	}
+	compileArrayOfSchemasLoop(mainReport, arr) {
+		let compiledCount = 0;
+		for (const schema of arr) {
+			const report = new Report(mainReport);
+			if (this.compileSchema(report, schema)) compiledCount++;
+			mainReport.errors = mainReport.errors.concat(report.errors);
+		}
+		return compiledCount;
+	}
+};
+//#endregion
+export { SchemaCompiler };

package/dist/schema-validator.d.mts

@@ -0,0 +1,15 @@
+import { ZSchemaOptions } from "./z-schema-options.mjs";
+import { Report } from "./report.mjs";
+import { ZSchemaBase } from "./z-schema-base.mjs";
+import { JsonSchemaInternal } from "./json-schema-versions.mjs";
+
+//#region src/schema-validator.d.ts
+declare class SchemaValidator {
+  private validator;
+  constructor(validator: ZSchemaBase);
+  get options(): ZSchemaOptions;
+  validateArrayOfSchemas(report: Report, arr: Array<JsonSchemaInternal | boolean>): boolean;
+  validateSchema(report: Report, schema: JsonSchemaInternal | boolean | Array<JsonSchemaInternal | boolean>): boolean;
+}
+//#endregion
+export { SchemaValidator };