z-schema 12.2.0 → 12.4.0

package/dist/{schema-cache.d.mts → schema-cache.d.ts}

@@ -1,13 +1,13 @@
-import { Report } from "./report.mjs";
-import { ZSchemaBase } from "./z-schema-base.mjs";
-import { JsonSchema, JsonSchemaInternal } from "./json-schema-versions.mjs";
+import { Report } from "./report.js";
+import { ZSchemaBase } from "./z-schema-base.js";
+import { JsonSchema, JsonSchemaInternal } from "./json-schema-versions.js";
 
 //#region src/schema-cache.d.ts
 type SchemaCacheStorage = Record<string, JsonSchemaInternal>;
 declare class SchemaCache {
-  private validator;
   static global_cache: SchemaCacheStorage;
   cache: SchemaCacheStorage;
+  private readonly validator;
   constructor(validator: ZSchemaBase);
   static cacheSchemaByUri(uri: string, schema: JsonSchemaInternal): void;
   cacheSchemaByUri(uri: string, schema: JsonSchemaInternal): void;
@@ -20,4 +20,4 @@ declare class SchemaCache {
   getSchemaByUri(report: Report, uri: string, root?: JsonSchemaInternal): JsonSchemaInternal | undefined;
 }
 //#endregion
-export { SchemaCache };
+export { SchemaCache, SchemaCacheStorage };

package/dist/{schema-cache.mjs → schema-cache.js}

@@ -1,9 +1,9 @@
-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";
+import { getQueryPath, getRemotePath, isAbsoluteUri } from "./utils/uri.js";
+import { findId, getId } from "./json-schema.js";
+import { deepClone } from "./utils/clone.js";
+import { decodeJSONPointer } from "./utils/json.js";
+import { Report } from "./report.js";
+import { normalizeOptions } from "./z-schema-options.js";
 //#region src/schema-cache.ts
 function getSafeRemotePath(uri) {
 	const remotePath = getRemotePath(uri);
@@ -13,7 +13,7 @@ function getSafeRemotePath(uri) {
 }
 const getEffectiveId = (schema) => {
 	let id = getId(schema);
-	if ((!id || !isAbsoluteUri(id)) && typeof schema.id === "string" && isAbsoluteUri(schema.id)) id = schema.id;
+	if ((!id || !isAbsoluteUri(id)) && typeof schema.id === "string" && isAbsoluteUri(schema.id)) ({id} = schema);
 	return id;
 };
 /**
@@ -22,9 +22,7 @@ const getEffectiveId = (schema) => {
 * 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);
+	const _schema = typeof schema === "string" ? JSON.parse(schema) : deepClone(schema, maxCloneDepth);
 	if (!_schema.id) _schema.id = uri;
 	if (validationOptions) _schema.__$validationOptions = normalizeOptions(validationOptions);
 	return _schema;
@@ -32,6 +30,7 @@ function prepareRemoteSchema(schema, uri, validationOptions, maxCloneDepth) {
 var SchemaCache = class SchemaCache {
 	static global_cache = Object.create(null);
 	cache = Object.create(null);
+	validator;
 	constructor(validator) {
 		this.validator = validator;
 	}
@@ -108,7 +107,7 @@ var SchemaCache = class SchemaCache {
 					usesAncestorReport = true;
 				} else {
 					remoteReport = new Report(report);
-					const noCache = result.id && isAbsoluteUri(result.id) ? false : true;
+					const noCache = !(result.id && isAbsoluteUri(result.id));
 					if (this.validator.sc.compileSchema(remoteReport, result, { noCache })) {
 						const savedOptions = this.validator.options;
 						try {

package/dist/{schema-compiler.d.mts → schema-compiler.d.ts}

@@ -1,6 +1,6 @@
-import { Report } from "./report.mjs";
-import { ZSchemaBase } from "./z-schema-base.mjs";
-import { JsonSchemaInternal } from "./json-schema-versions.mjs";
+import { Report } from "./report.js";
+import { ZSchemaBase } from "./z-schema-base.js";
+import { JsonSchemaInternal } from "./json-schema-versions.js";
 
 //#region src/schema-compiler.d.ts
 interface Reference {
@@ -10,7 +10,7 @@ interface Reference {
   path: Array<string | number>;
 }
 declare class SchemaCompiler {
-  private validator;
+  private readonly validator;
   constructor(validator: ZSchemaBase);
   collectAndCacheIds(schema: JsonSchemaInternal): void;
   compileSchema(report: Report, schema: JsonSchemaInternal | JsonSchemaInternal[], options?: {

package/dist/{schema-compiler.mjs → schema-compiler.js}

@@ -1,16 +1,16 @@
-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";
+import { getRemotePath, isAbsoluteUri } from "./utils/uri.js";
+import { NON_SCHEMA_KEYWORDS_SET, getId, isInternalKey } from "./json-schema.js";
+import { Report } from "./report.js";
+import { getSchemaReader } from "./z-schema-reader.js";
 //#region src/schema-compiler.ts
-const UNSAFE_TARGETS = [
+const UNSAFE_TARGETS = /* @__PURE__ */ new Set([
 	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);
+	return UNSAFE_TARGETS.has(obj);
 }
 /** Safely assign a property on `obj`, refusing prototype-polluting keys. */
 function safeSetProperty(obj, key, value) {
@@ -23,35 +23,81 @@ function safeDeleteProperty(obj, key) {
 	if (isUnsafeTarget(obj)) return;
 	if (key !== "__proto__" && key !== "constructor" && key !== "prototype") delete obj[key];
 }
+const resolveReference = (base, ref) => {
+	if (isAbsoluteUri(ref)) return ref;
+	const baseStr = base ?? "";
+	if (ref.startsWith("#")) {
+		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.startsWith("#") && !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);
+};
 const collectIds = (obj, maxDepth = 100) => {
 	const ids = [];
 	function walk(node, scope, _depth = 0) {
 		if (typeof node !== "object" || node == null) return;
+		const schemaNode = node;
 		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);
+		const nodeId = getId(schemaNode);
 		if (typeof nodeId === "string") {
 			let type = isAbsoluteUri(nodeId) ? "absolute" : "relative";
 			if (scope.length === 0) type = "root";
 			const id = {
 				id: nodeId,
 				type,
-				obj: node
+				obj: schemaNode
 			};
 			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 === "root" && typeof schemaNode.id === "string" && isAbsoluteUri(schemaNode.id) && schemaNode.id !== nodeId) id.absoluteUri = resolveSchemaScopeId(schemaNode.id, schemaNode, 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);
+				let absoluteParent;
+				for (let i = scope.length - 1; i >= 0; i--) {
+					const sc = scope[i];
+					if (sc.type === "absolute" || sc.type === "root" && sc.absoluteUri) {
+						absoluteParent = sc;
+						break;
+					}
+				}
+				id.absoluteParent = absoluteParent;
+				if (id.absoluteParent) {
+					const parentUri = id.absoluteParent.absoluteUri || id.absoluteParent.id;
+					id.absoluteUri = resolveSchemaScopeId(parentUri, schemaNode, 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);
+		else for (const key of Object.keys(schemaNode)) {
+			if (isInternalKey(key) || NON_SCHEMA_KEYWORDS_SET.has(key)) continue;
+			walk(schemaNode[key], scope, _depth + 1);
 		}
 		if (addedScope) scope.pop();
 	}
@@ -59,42 +105,42 @@ const collectIds = (obj, maxDepth = 100) => {
 	return ids;
 };
 const collectReferences = (obj, results, scope, path, options, maxDepth = 100, _depth = 0) => {
-	results = results || [];
-	scope = scope || [];
-	path = path || [];
-	options = options || {};
+	results ||= [];
+	scope ||= [];
+	path ||= [];
+	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";
+	const hasRef = typeof obj.$ref === "string" && obj.__$refResolved === void 0;
 	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;
+		const base = scope.length > 0 ? scope.at(-1) : void 0;
 		scope.push(resolveSchemaScopeId(base, obj, scopeId));
 		addedScope = true;
 	}
 	if (hasRef) results.push({
-		ref: resolveReference(scope[scope.length - 1], obj.$ref),
+		ref: resolveReference(scope.at(-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),
+	if (typeof obj.$recursiveRef === "string" && obj.__$recursiveRefResolved === void 0) results.push({
+		ref: resolveReference(scope.at(-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),
+	if (typeof obj.$dynamicRef === "string" && obj.__$dynamicRefResolved === void 0) results.push({
+		ref: resolveReference(scope.at(-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),
+	if (typeof obj.$schema === "string" && obj.__$schemaResolved === void 0) results.push({
+		ref: resolveReference(scope.at(-1), obj.$schema),
 		key: "$schema",
 		obj,
 		path: path.slice(0)
@@ -107,7 +153,7 @@ const collectReferences = (obj, results, scope, path, options, maxDepth = 100, _
 	else {
 		const keys = Object.keys(obj);
 		for (const key of keys) {
-			if (isInternalKey(key) || NON_SCHEMA_KEYWORDS.includes(key)) continue;
+			if (isInternalKey(key) || NON_SCHEMA_KEYWORDS_SET.has(key)) continue;
 			path.push(key);
 			collectReferences(obj[key], results, scope, path, options, maxDepth, _depth + 1);
 			path.pop();
@@ -116,41 +162,8 @@ const collectReferences = (obj, results, scope, path, options, maxDepth = 100, _
 	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 {
+	validator;
 	constructor(validator) {
 		this.validator = validator;
 	}
@@ -159,7 +172,8 @@ var SchemaCompiler = class {
 		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);
+				const parentUri = item.absoluteParent.absoluteUri || item.absoluteParent.id;
+				const altAbsoluteUri = resolveReference(parentUri, item.id);
 				this.validator.scache.cacheSchemaByUri(altAbsoluteUri, item.obj);
 			}
 		} else if (item.type === "root") this.validator.scache.cacheSchemaByUri(item.id, item.obj);
@@ -168,19 +182,19 @@ var SchemaCompiler = class {
 		report.commonErrorMessage = "SCHEMA_COMPILATION_FAILED";
 		if (typeof schema === "string") {
 			const loadedSchema = this.validator.scache.getSchemaByUri(report, schema);
-			if (typeof loadedSchema === "undefined") {
+			if (loadedSchema === void 0) {
 				report.addError("SCHEMA_NOT_REACHABLE", [schema]);
 				return false;
 			}
 			schema = loadedSchema;
 		}
 		if (Array.isArray(schema)) {
-			if (!options?.noCache) schema.forEach((s) => this.collectAndCacheIds(s));
+			if (!options?.noCache) for (let i = 0; i < schema.length; i++) this.collectAndCacheIds(schema[i]);
 			return this.compileArrayOfSchemas(report, schema);
 		} else if (typeof schema === "boolean") return true;
-		else if (!options?.noCache) this.collectAndCacheIds(schema);
+		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 (canMutateSchemaObject && schema.__$compiled && schema.id && !this.validator.scache.checkCacheForUri(schema.id)) 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);
@@ -195,7 +209,7 @@ var SchemaCompiler = class {
 		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") {
+			if (response === void 0) {
 				const schemaReader = getSchemaReader();
 				if (schemaReader) {
 					const remotePath = getRemotePath(refObj.ref);
@@ -203,23 +217,24 @@ var SchemaCompiler = class {
 					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 (this.compileSchema(subreport, s)) response = this.validator.scache.getSchemaByUri(report, refObj.ref, schema);
+						else for (let i = 0; i < subreport.errors.length; i++) report.errors.push(subreport.errors[i]);
 					}
 				}
 			}
-			if (typeof response === "undefined") {
+			if (response === void 0) {
 				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);
+					const pathLen = refObj.path.length;
+					for (let i = 0; i < pathLen; i++) report.path.push(refObj.path[i]);
 					report.addError("UNRESOLVABLE_REFERENCE", [refObj.ref]);
-					report.path = report.path.slice(0, -refObj.path.length);
+					report.path.length -= pathLen;
 					if (isValidExceptReferences && canMutateSchemaObject && !isUnsafeTarget(schema)) {
-						schema.__$missingReferences = schema.__$missingReferences || [];
+						schema.__$missingReferences ||= [];
 						schema.__$missingReferences.push(refObj);
 					}
 				}
@@ -234,13 +249,20 @@ var SchemaCompiler = class {
 	compileArrayOfSchemas(report, arr) {
 		let compiled = 0, lastLoopCompiled;
 		do {
-			report.errors = report.errors.filter((e) => e.code !== "UNRESOLVABLE_REFERENCE");
+			let wi = 0;
+			for (let ri = 0; ri < report.errors.length; ri++) if (report.errors[ri].code !== "UNRESOLVABLE_REFERENCE") report.errors[wi++] = report.errors[ri];
+			report.errors.length = wi;
 			lastLoopCompiled = compiled;
 			compiled = this.compileArrayOfSchemasLoop(report, arr);
+			const idMap = /* @__PURE__ */ new Map();
+			for (let i = 0; i < arr.length; i++) {
+				const schemaId = arr[i].id;
+				if (schemaId && !idMap.has(schemaId)) idMap.set(schemaId, arr[i]);
+			}
 			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);
+					const response = idMap.get(refObj.ref);
 					if (response) {
 						safeSetProperty(refObj.obj, `__${refObj.key}Resolved`, response);
 						sch.__$missingReferences.splice(idx2, 1);
@@ -256,10 +278,10 @@ var SchemaCompiler = class {
 		for (const schema of arr) {
 			const report = new Report(mainReport);
 			if (this.compileSchema(report, schema)) compiledCount++;
-			mainReport.errors = mainReport.errors.concat(report.errors);
+			for (let i = 0; i < report.errors.length; i++) mainReport.errors.push(report.errors[i]);
 		}
 		return compiledCount;
 	}
 };
 //#endregion
-export { SchemaCompiler };
+export { SchemaCompiler, collectIds, collectReferences };

package/dist/{schema-validator.d.mts → schema-validator.d.ts}

@@ -1,11 +1,11 @@
-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";
+import { ZSchemaOptions } from "./z-schema-options.js";
+import { Report } from "./report.js";
+import { ZSchemaBase } from "./z-schema-base.js";
+import { JsonSchemaInternal } from "./json-schema-versions.js";
 
 //#region src/schema-validator.d.ts
 declare class SchemaValidator {
-  private validator;
+  private readonly validator;
   constructor(validator: ZSchemaBase);
   get options(): ZSchemaOptions;
   validateArrayOfSchemas(report: Report, arr: Array<JsonSchemaInternal | boolean>): boolean;