@bluprynt/forms-core 3.0.0 → 4.0.1

package/dist/index.mjs

@@ -1516,6 +1516,119 @@ const validateFn = new Ajv2020({ allErrors: true }).compile({
 		"contentItem": { "oneOf": [{ "$ref": "#/$defs/fieldItem" }, { "$ref": "#/$defs/section" }] }
 	}
 });
+const itemRequiredProperties = new Map([
+	["string", new Set([
+		"id",
+		"type",
+		"label"
+	])],
+	["number", new Set([
+		"id",
+		"type",
+		"label"
+	])],
+	["boolean", new Set([
+		"id",
+		"type",
+		"label"
+	])],
+	["date", new Set([
+		"id",
+		"type",
+		"label"
+	])],
+	["select", new Set([
+		"id",
+		"type",
+		"label",
+		"options"
+	])],
+	["array", new Set([
+		"id",
+		"type",
+		"label",
+		"item"
+	])],
+	["file", new Set([
+		"id",
+		"type",
+		"label"
+	])],
+	["section", new Set([
+		"id",
+		"type",
+		"title",
+		"content"
+	])]
+]);
+const itemAllowedProperties = new Map([
+	["string", new Set([
+		"id",
+		"type",
+		"label",
+		"description",
+		"condition",
+		"validation"
+	])],
+	["number", new Set([
+		"id",
+		"type",
+		"label",
+		"description",
+		"condition",
+		"validation"
+	])],
+	["boolean", new Set([
+		"id",
+		"type",
+		"label",
+		"description",
+		"condition",
+		"validation"
+	])],
+	["date", new Set([
+		"id",
+		"type",
+		"label",
+		"description",
+		"condition",
+		"validation"
+	])],
+	["select", new Set([
+		"id",
+		"type",
+		"label",
+		"description",
+		"condition",
+		"options",
+		"validation"
+	])],
+	["array", new Set([
+		"id",
+		"type",
+		"label",
+		"description",
+		"condition",
+		"item",
+		"validation"
+	])],
+	["file", new Set([
+		"id",
+		"type",
+		"label",
+		"description",
+		"condition",
+		"validation"
+	])],
+	["section", new Set([
+		"id",
+		"type",
+		"title",
+		"description",
+		"condition",
+		"content"
+	])]
+]);
 /**
 * Validates form definitions at both the structural (JSON Schema) and
 * semantic levels.
@@ -1549,18 +1662,177 @@ var FormDefinitionValidator = class {
 	*/
 	validateSchema(input) {
 		if (validateFn(input)) return [];
-		return (validateFn.errors ?? []).map((err) => {
+		return this.formatSchemaErrors(validateFn.errors ?? [], input);
+	}
+	formatSchemaErrors(errors, input) {
+		const issues = this.collectSchemaIssues(errors, input);
+		const dedupedIssues = this.deduplicateSchemaIssues(issues);
+		const specificIssuePaths = dedupedIssues.filter((issue) => issue.keyword !== "oneOf").map((issue) => issue.path);
+		return dedupedIssues.filter((issue) => !this.isRedundantOneOfIssue(issue, specificIssuePaths)).map((issue) => ({
+			code: "SCHEMA_INVALID",
+			message: issue.message,
+			params: {
+				path: issue.path,
+				keyword: issue.keyword,
+				...issue.property ? { property: issue.property } : {}
+			}
+		}));
+	}
+	collectSchemaIssues(errors, input) {
+		const additionalByPath = /* @__PURE__ */ new Map();
+		const issues = [];
+		for (const err of errors) {
 			const path = err.instancePath || "/";
-			const message = err.message ?? "Unknown error";
-			if (err.keyword === "additionalProperties") return {
-				code: "SCHEMA_INVALID",
-				message: `${path}: ${message}: '${err.params.additionalProperty}'`
+			if (!this.shouldKeepSchemaError(err, input)) continue;
+			if (err.keyword === "additionalProperties") {
+				const property = err.params.additionalProperty;
+				if (!property) continue;
+				if (!this.shouldKeepAdditionalPropertyError(path, property, input)) continue;
+				const properties = additionalByPath.get(path) ?? /* @__PURE__ */ new Set();
+				properties.add(property);
+				additionalByPath.set(path, properties);
+				continue;
+			}
+			issues.push(this.formatSchemaIssue(err));
+		}
+		for (const [path, properties] of additionalByPath) issues.push(this.formatAdditionalPropertiesIssue(path, [...properties].sort()));
+		return issues;
+	}
+	shouldKeepSchemaError(err, input) {
+		if (err.keyword === "const" && this.getLastPathSegment(err.instancePath) === "type") {
+			const value = this.getValueAtPath(input, this.getParentPath(err.instancePath));
+			return !(this.isRecord(value) && typeof value.type === "string" && itemAllowedProperties.has(value.type));
+		}
+		if (err.keyword !== "required") return true;
+		const missingProperty = err.params.missingProperty;
+		if (!missingProperty) return true;
+		const value = this.getValueAtPath(input, err.instancePath);
+		if (this.isRecord(value) && value.type === void 0 && this.isContentItemPath(err.instancePath)) return missingProperty === "id" || missingProperty === "type";
+		if (!this.isRecord(value) || typeof value.type !== "string") return true;
+		const requiredProperties = itemRequiredProperties.get(value.type);
+		return requiredProperties ? requiredProperties.has(missingProperty) : true;
+	}
+	shouldKeepAdditionalPropertyError(path, property, input) {
+		const value = this.getValueAtPath(input, path);
+		if (!this.isRecord(value) || typeof value.type !== "string") return true;
+		const allowedProperties = itemAllowedProperties.get(value.type);
+		return allowedProperties ? !allowedProperties.has(property) : true;
+	}
+	formatSchemaIssue(err) {
+		const path = err.instancePath || "/";
+		switch (err.keyword) {
+			case "required": {
+				const property = err.params.missingProperty ?? "unknown";
+				return {
+					path,
+					keyword: err.keyword,
+					property,
+					message: `${this.formatPath(path)} is missing required property "${property}".`
+				};
+			}
+			case "const": {
+				const propertyPath = this.formatPath(path);
+				const parentPath = this.getParentPath(path);
+				const property = this.getLastPathSegment(path);
+				return {
+					path,
+					keyword: err.keyword,
+					property,
+					message: property === "type" ? `${this.formatPath(parentPath)} has an invalid type.` : `${propertyPath} has an invalid value.`
+				};
+			}
+			case "type": {
+				const params = err.params;
+				return {
+					path,
+					keyword: err.keyword,
+					property: this.getLastPathSegment(path),
+					message: `${this.formatPath(path)} must be ${this.formatArticle(params.type)} ${params.type ?? "valid value"}.`
+				};
+			}
+			case "oneOf": return {
+				path,
+				keyword: err.keyword,
+				message: `${this.formatPath(path)} is invalid.`
 			};
-			return {
-				code: "SCHEMA_INVALID",
-				message: `${path}: ${message}`
+			default: return {
+				path,
+				keyword: err.keyword,
+				property: this.getLastPathSegment(path),
+				message: `${this.formatPath(path)} ${err.message ?? "is invalid"}.`
 			};
-		});
+		}
+	}
+	formatAdditionalPropertiesIssue(path, properties) {
+		const propertyList = properties.map((property) => `"${property}"`).join(", ");
+		const noun = properties.length === 1 ? "property" : "properties";
+		return {
+			path,
+			keyword: "additionalProperties",
+			property: properties.join(","),
+			message: `${this.formatPath(path)} has unsupported ${noun}: ${propertyList}.`
+		};
+	}
+	deduplicateSchemaIssues(issues) {
+		const seen = /* @__PURE__ */ new Set();
+		const result = [];
+		for (const issue of issues) {
+			const key = `${issue.path}:${issue.keyword}:${issue.property ?? ""}:${issue.message}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			result.push(issue);
+		}
+		return result;
+	}
+	isRedundantOneOfIssue(issue, specificIssuePaths) {
+		if (issue.keyword !== "oneOf") return false;
+		return specificIssuePaths.some((path) => path === issue.path || path.startsWith(`${issue.path}/`));
+	}
+	formatPath(path) {
+		if (!path || path === "/") return "Form definition";
+		const segments = path.split("/").filter(Boolean);
+		const parts = [];
+		for (let index = 0; index < segments.length; index += 1) {
+			const segment = segments[index];
+			const nextSegment = segments[index + 1];
+			if (segment === void 0) continue;
+			if (segment === "content" && nextSegment !== void 0 && /^\d+$/.test(nextSegment)) {
+				parts.push(`${parts.length === 0 ? "Content" : "content"} item ${Number(nextSegment) + 1}`);
+				index += 1;
+				continue;
+			}
+			if (segment === "validation" && parts.length > 0) {
+				parts[parts.length - 1] = `${parts[parts.length - 1]} validation`;
+				continue;
+			}
+			parts.push(segment);
+		}
+		return parts.join(" > ");
+	}
+	getValueAtPath(input, path) {
+		if (!path) return input;
+		return path.split("/").filter(Boolean).reduce((value, segment) => {
+			if (Array.isArray(value)) return value[Number(segment)];
+			if (this.isRecord(value)) return value[segment];
+		}, input);
+	}
+	getParentPath(path) {
+		const segments = path.split("/").filter(Boolean);
+		return segments.length > 1 ? `/${segments.slice(0, -1).join("/")}` : "/";
+	}
+	getLastPathSegment(path) {
+		return path.split("/").filter(Boolean).at(-1);
+	}
+	isContentItemPath(path) {
+		const segments = path.split("/").filter(Boolean);
+		return segments.at(-2) === "content" && /^\d+$/.test(segments.at(-1) ?? "");
+	}
+	formatArticle(value) {
+		if (!value) return "a";
+		return /^[aeiou]/i.test(value) ? "an" : "a";
+	}
+	isRecord(value) {
+		return typeof value === "object" && value !== null && !Array.isArray(value);
 	}
 	/**
 	* Validates a form definition semantically.