schema-components 1.21.0 → 1.23.0

package/dist/html/streamRenderers.mjs

@@ -1,11 +1,17 @@
 import { isObject } from "../core/guards.mjs";
+import "../core/limits.mjs";
+import { emitDiagnostic } from "../core/diagnostics.mjs";
+import { SC_CLASSES } from "../core/cssClasses.mjs";
 import { getHtmlRenderFn } from "../core/renderer.mjs";
+import { matchUnionOption, resolveDiscriminatedActive } from "../core/unionMatch.mjs";
 import { VOID_ELEMENTS, h, raw, serialize, serializeAttributes } from "./html.mjs";
-import { ariaLabelAttrs, buildHintElement, buildInputId, requiredIndicator } from "./a11y.mjs";
+import { ariaLabelAttrs, buildHintElement, buildInputId, joinPath, requiredIndicator } from "./a11y.mjs";
+import { panelId, tabId } from "./renderers.mjs";
+import { recursionSentinelHtml } from "./renderToHtml.mjs";
 //#region src/html/streamRenderers.ts
 function yieldOpen(el) {
 	const attrStr = serializeAttributes(el.attributes);
-	if (el.children.length === 0 && VOID_ELEMENTS.has(el.tag)) return `<${el.tag}${attrStr}>`;
+	if (VOID_ELEMENTS.has(el.tag)) return `<${el.tag}${attrStr} />`;
 	return `<${el.tag}${attrStr}>`;
 }
 function yieldClose(el) {
@@ -24,20 +30,32 @@ function renderLeaf(tree, value, mergedResolver, path) {
 		tree,
 		renderChild: () => ""
 	});
-	if (value === void 0 || value === null) return serialize(h("span", { class: "sc-value sc-value--empty" }, "—"));
-	return serialize(h("span", { class: "sc-value" }, typeof value === "string" ? value : JSON.stringify(value)));
+	if (value === void 0 || value === null) return serialize(h("span", { class: SC_CLASSES.valueEmpty }, "—"));
+	return serialize(h("span", { class: SC_CLASSES.value }, typeof value === "string" ? value : JSON.stringify(value)));
 }
-function renderFieldSync(tree, value, mergedResolver, path, rawResolver) {
-	return [...streamField(tree, value, mergedResolver, path, rawResolver)].join("");
+function renderFieldSync(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics) {
+	return [...streamField(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics)].join("");
 }
-function matchUnionOption(options, value) {
-	if (typeof value === "string") return options.find((o) => o.type === "string" || o.type === "enum");
-	if (typeof value === "number") return options.find((o) => o.type === "number");
-	if (typeof value === "boolean") return options.find((o) => o.type === "boolean");
-	if (Array.isArray(value)) return options.find((o) => o.type === "array");
-	if (typeof value === "object" && value !== null) return options.find((o) => o.type === "object");
+/**
+* Build a visible placeholder element used when a value does not match
+* the shape implied by its field type. The expected-shape label is
+* passed verbatim into `h()` so the serialiser escapes it.
+*
+* Streaming must keep producing output, so we never throw here — the
+* diagnostic surfaces the problem to the caller (when a sink is wired)
+* while the rendered output remains structurally valid.
+*/
+function typeMismatchPlaceholder(expectedShape) {
+	return serialize(h("span", {
+		class: "sc-value sc-value--invalid",
+		role: "alert"
+	}, `invalid value (expected ${expectedShape})`));
 }
-function* streamField(tree, value, mergedResolver, path, rawResolver) {
+function* streamField(tree, value, mergedResolver, path, rawResolver, currentDepth = 0, diagnostics) {
+	if (currentDepth >= 10) {
+		yield recursionSentinelHtml(typeof tree.meta.description === "string" ? tree.meta.description : "schema");
+		return;
+	}
 	const effectiveValue = value ?? tree.defaultValue;
 	const type = tree.type;
 	if (type === "string" || type === "number" || type === "boolean" || type === "enum" || type === "literal" || type === "file" || type === "unknown") {
@@ -45,36 +63,50 @@ function* streamField(tree, value, mergedResolver, path, rawResolver) {
 		return;
 	}
 	if (type === "union") {
-		yield* streamUnion(tree, effectiveValue, mergedResolver, path, rawResolver);
+		yield* streamUnion(tree, effectiveValue, mergedResolver, path, rawResolver, currentDepth, diagnostics);
 		return;
 	}
 	if (type === "discriminatedUnion") {
-		yield* streamDiscriminatedUnion(tree, value, mergedResolver, path, rawResolver);
+		yield* streamDiscriminatedUnion(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics);
 		return;
 	}
 	if (type === "object") {
-		yield* streamObject(tree, value, mergedResolver, path, rawResolver);
+		yield* streamObject(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics);
 		return;
 	}
 	if (type === "array") {
-		yield* streamArray(tree, value, mergedResolver, path, rawResolver);
+		yield* streamArray(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics);
 		return;
 	}
 	if (type === "record") {
-		yield* streamRecord(tree, value, mergedResolver, path, rawResolver);
+		yield* streamRecord(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics);
 		return;
 	}
 	yield renderLeaf(tree, value, mergedResolver, path);
 }
-function* streamObject(tree, value, mergedResolver, path, rawResolver) {
+function* streamObject(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics) {
 	if (tree.type !== "object") return;
 	const fields = tree.fields;
+	if (value !== void 0 && value !== null && !isObject(value)) {
+		emitDiagnostic(diagnostics, {
+			code: "type-mismatch",
+			message: "Object schema received non-object value during streaming render",
+			pointer: path === "" ? "/" : `/${path}`,
+			detail: {
+				expected: "object",
+				actualType: typeof value,
+				path
+			}
+		});
+		yield typeMismatchPlaceholder("object");
+		return;
+	}
 	const obj = isObject(value) ? value : {};
 	const readOnly = tree.editability === "presentation";
 	const descriptionText = typeof tree.meta.description === "string" ? tree.meta.description : void 0;
 	const labelAttrs = ariaLabelAttrs(descriptionText);
 	if (readOnly) {
-		const dlAttrs = { class: "sc-object" };
+		const dlAttrs = { class: SC_CLASSES.object };
 		Object.assign(dlAttrs, labelAttrs);
 		const dl = h("dl", dlAttrs);
 		const legend = descriptionText !== void 0 ? serialize(h("legend", {}, descriptionText)) : "";
@@ -82,12 +114,12 @@ function* streamObject(tree, value, mergedResolver, path, rawResolver) {
 		for (const [key, field] of Object.entries(fields)) {
 			const label = typeof field.meta.description === "string" ? field.meta.description : key;
 			const childValue = obj[key];
-			const childHtml = renderFieldSync(field, childValue, mergedResolver, key, rawResolver);
-			yield `${serialize(h("dt", { class: "sc-label" }, label))}${serialize(h("dd", { class: "sc-value" }, raw(childHtml)))}`;
+			const childHtml = renderFieldSync(field, childValue, mergedResolver, joinPath(path, key), rawResolver, currentDepth + 1, diagnostics);
+			yield `${serialize(h("dt", { class: SC_CLASSES.label }, label))}${serialize(h("dd", { class: SC_CLASSES.value }, raw(childHtml)))}`;
 		}
 		yield yieldClose(dl);
 	} else {
-		const fieldsetAttrs = { class: "sc-object" };
+		const fieldsetAttrs = { class: SC_CLASSES.object };
 		Object.assign(fieldsetAttrs, labelAttrs);
 		const fieldset = h("fieldset", fieldsetAttrs);
 		const legend = descriptionText !== void 0 ? serialize(h("legend", {}, descriptionText)) : "";
@@ -96,137 +128,145 @@ function* streamObject(tree, value, mergedResolver, path, rawResolver) {
 			const label = typeof field.meta.description === "string" ? field.meta.description : key;
 			const fieldId = buildInputId(path, key);
 			const childValue = obj[key];
-			const childChunks = [...streamField(field, childValue, mergedResolver, key, rawResolver)].join("");
+			const childChunks = [...streamField(field, childValue, mergedResolver, joinPath(path, key), rawResolver, currentDepth + 1, diagnostics)].join("");
 			const required = requiredIndicator(field);
 			const labelContent = [label];
 			if (required !== void 0) labelContent.push(required);
 			const fieldChildren = [h("label", {
-				class: "sc-label",
+				class: SC_CLASSES.label,
 				for: fieldId
 			}, ...labelContent), raw(childChunks)];
 			const hint = buildHintElement(key, field.constraints);
 			if (hint !== void 0) fieldChildren.push(hint);
-			yield serialize(h("div", { class: "sc-field" }, ...fieldChildren));
+			yield serialize(h("div", { class: SC_CLASSES.field }, ...fieldChildren));
 		}
 		yield yieldClose(fieldset);
 	}
 }
-function* streamArray(tree, value, mergedResolver, path, rawResolver) {
-	const arr = Array.isArray(value) ? value : [];
+function* streamArray(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics) {
 	if (tree.type !== "array") return;
 	const element = tree.element;
 	if (element === void 0) return;
-	const readOnly = tree.editability === "presentation";
-	const elementPath = typeof element.meta.description === "string" ? element.meta.description : "";
-	if (readOnly) {
-		const ul = h("ul", { class: "sc-array" });
+	if (value !== void 0 && value !== null && !Array.isArray(value)) {
+		emitDiagnostic(diagnostics, {
+			code: "type-mismatch",
+			message: "Array schema received non-array value during streaming render",
+			pointer: path === "" ? "/" : `/${path}`,
+			detail: {
+				expected: "array",
+				actualType: typeof value,
+				path
+			}
+		});
+		yield typeMismatchPlaceholder("array");
+		return;
+	}
+	const arr = Array.isArray(value) ? value : [];
+	if (tree.editability === "presentation") {
+		const ul = h("ul", { class: SC_CLASSES.array });
 		yield yieldOpen(ul);
-		for (const item of arr) yield serialize(h("li", { class: "sc-item" }, raw(renderFieldSync(element, item, mergedResolver, elementPath, rawResolver))));
+		for (const [i, item] of arr.entries()) yield serialize(h("li", { class: "sc-item" }, raw(renderFieldSync(element, item, mergedResolver, joinPath(path, `[${String(i)}]`), rawResolver, currentDepth + 1, diagnostics))));
 		yield yieldClose(ul);
 	} else {
-		const div = h("div", { class: "sc-array" });
+		const div = h("div", { class: SC_CLASSES.array });
 		yield yieldOpen(div);
-		for (const item of arr) yield serialize(h("div", {}, raw(renderFieldSync(element, item, mergedResolver, elementPath, rawResolver))));
+		for (const [i, item] of arr.entries()) yield serialize(h("div", {}, raw(renderFieldSync(element, item, mergedResolver, joinPath(path, `[${String(i)}]`), rawResolver, currentDepth + 1, diagnostics))));
 		yield yieldClose(div);
 	}
 }
-function* streamRecord(tree, value, mergedResolver, path, rawResolver) {
-	const obj = isObject(value) ? value : {};
+function* streamRecord(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics) {
 	if (tree.type !== "record") return;
 	const valueType = tree.valueType;
+	if (value !== void 0 && value !== null && !isObject(value)) {
+		emitDiagnostic(diagnostics, {
+			code: "type-mismatch",
+			message: "Record schema received non-object value during streaming render",
+			pointer: path === "" ? "/" : `/${path}`,
+			detail: {
+				expected: "object",
+				actualType: typeof value,
+				path
+			}
+		});
+		yield typeMismatchPlaceholder("object");
+		return;
+	}
+	const obj = isObject(value) ? value : {};
 	const readOnly = tree.editability === "presentation";
 	const attrs = {
-		class: "sc-record",
+		class: SC_CLASSES.record,
 		role: "group"
 	};
 	if (readOnly) {
 		const dl = h("dl", attrs);
 		yield yieldOpen(dl);
 		for (const [key, val] of Object.entries(obj)) {
-			const childHtml = renderFieldSync(valueType, val, mergedResolver, key, rawResolver);
-			yield `${serialize(h("dt", { class: "sc-label" }, key))}${serialize(h("dd", { class: "sc-value" }, raw(childHtml)))}`;
+			const childHtml = renderFieldSync(valueType, val, mergedResolver, joinPath(path, key), rawResolver, currentDepth + 1, diagnostics);
+			yield `${serialize(h("dt", { class: SC_CLASSES.label }, key))}${serialize(h("dd", { class: SC_CLASSES.value }, raw(childHtml)))}`;
 		}
 		yield yieldClose(dl);
 	} else {
 		const container = h("div", attrs);
 		yield yieldOpen(container);
 		for (const [key, val] of Object.entries(obj)) {
-			const childHtml = renderFieldSync(valueType, val, mergedResolver, key, rawResolver);
-			yield serialize(h("div", { class: "sc-field" }, h("label", { class: "sc-label" }, key), raw(childHtml)));
+			const childHtml = renderFieldSync(valueType, val, mergedResolver, joinPath(path, key), rawResolver, currentDepth + 1, diagnostics);
+			yield serialize(h("div", { class: SC_CLASSES.field }, h("label", { class: SC_CLASSES.label }, key), raw(childHtml)));
 		}
 		yield yieldClose(container);
 	}
 }
-function* streamUnion(tree, value, mergedResolver, path, rawResolver) {
+function* streamUnion(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics) {
 	const options = tree.type === "union" ? tree.options : void 0;
 	if (options === void 0 || options.length === 0) {
-		if (value === void 0 || value === null) yield serialize(h("span", { class: "sc-value sc-value--empty" }, "—"));
-		else yield serialize(h("span", { class: "sc-value" }, JSON.stringify(value)));
+		if (value === void 0 || value === null) yield serialize(h("span", { class: SC_CLASSES.valueEmpty }, "—"));
+		else yield serialize(h("span", { class: SC_CLASSES.value }, JSON.stringify(value)));
 		return;
 	}
 	const target = matchUnionOption(options, value) ?? options[0];
-	if (target !== void 0) yield* streamField(target, value, mergedResolver, typeof target.meta.description === "string" ? target.meta.description : "", rawResolver);
-	else yield serialize(h("span", { class: "sc-value sc-value--empty" }, "—"));
+	if (target !== void 0) yield* streamField(target, value, mergedResolver, path, rawResolver, currentDepth + 1, diagnostics);
+	else yield serialize(h("span", { class: SC_CLASSES.valueEmpty }, "—"));
 }
-function* streamDiscriminatedUnion(tree, value, mergedResolver, path, rawResolver) {
-	const options = tree.type === "discriminatedUnion" ? tree.options : void 0;
-	const discriminator = tree.type === "discriminatedUnion" ? tree.discriminator : void 0;
-	if (options === void 0 || options.length === 0) {
-		if (value === void 0 || value === null) yield serialize(h("span", { class: "sc-value sc-value--empty" }, "—"));
-		else yield serialize(h("span", { class: "sc-value" }, JSON.stringify(value)));
+function* streamDiscriminatedUnion(tree, value, mergedResolver, path, rawResolver, currentDepth, diagnostics) {
+	if (tree.type !== "discriminatedUnion") return;
+	const { options, discriminator } = tree;
+	if (options.length === 0) {
+		if (value === void 0 || value === null) yield serialize(h("span", { class: SC_CLASSES.valueEmpty }, "—"));
+		else yield serialize(h("span", { class: SC_CLASSES.value }, JSON.stringify(value)));
 		return;
 	}
-	const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-	const obj = isRecord(value) ? value : {};
-	const discKey = discriminator ?? "";
-	const currentDiscriminatorValue = typeof obj[discKey] === "string" ? obj[discKey] : void 0;
-	const optionLabels = options.map((opt) => {
-		if (opt.type === "object") {
-			const discriminatorField = opt.fields[discKey];
-			if (discriminatorField?.type === "literal") {
-				const constVal = discriminatorField.literalValues[0];
-				if (typeof constVal === "string") return constVal;
-			}
-		}
-		return typeof opt.meta.title === "string" ? opt.meta.title : opt.type;
-	});
-	let activeIndex = 0;
-	if (currentDiscriminatorValue !== void 0) {
-		const found = optionLabels.indexOf(currentDiscriminatorValue);
-		if (found !== -1) activeIndex = found;
-	}
-	const activeOption = options[activeIndex];
+	const { optionLabels, activeIndex, activeOption } = resolveDiscriminatedActive(options, discriminator, isObject(value) ? value : void 0);
 	if (tree.editability === "presentation") {
-		if (activeOption !== void 0) yield* streamField(activeOption, value, mergedResolver, typeof activeOption.meta.description === "string" ? activeOption.meta.description : "", rawResolver);
+		if (activeOption !== void 0) yield* streamField(activeOption, value, mergedResolver, path, rawResolver, currentDepth + 1, diagnostics);
 		return;
 	}
-	const panelId = `sc-${path}-panel`;
-	const wrapper = h("div", { class: "sc-discriminated-union" });
+	const tabPanelId = panelId(path);
+	const wrapper = h("div", { class: SC_CLASSES.discriminatedUnion });
 	yield yieldOpen(wrapper);
-	yield serialize(h("div", {
-		role: "tablist",
-		class: "sc-tabs",
-		"aria-label": "Select variant"
-	}, ...options.map((_opt, i) => {
+	const tabButtons = options.map((_opt, i) => {
 		return h("button", {
 			type: "button",
 			role: "tab",
-			class: i === activeIndex ? "sc-tab sc-tab--active" : "sc-tab",
-			id: `sc-${path}-tab-${String(i)}`,
+			class: i === activeIndex ? SC_CLASSES.tabActive : SC_CLASSES.tab,
+			id: tabId(path, i),
 			"aria-selected": i === activeIndex ? "true" : void 0,
-			"aria-controls": panelId,
+			"aria-controls": tabPanelId,
 			tabindex: i === activeIndex ? "0" : "-1"
 		}, optionLabels[i]);
-	})));
+	});
+	yield serialize(h("div", {
+		role: "tablist",
+		class: SC_CLASSES.tabs,
+		"aria-label": "Select variant"
+	}, ...tabButtons));
 	const panelOpen = h("div", {
 		role: "tabpanel",
-		id: panelId,
-		"aria-labelledby": `sc-${path}-tab-${String(activeIndex)}`
+		id: tabPanelId,
+		"aria-labelledby": tabId(path, activeIndex)
 	});
 	yield yieldOpen(panelOpen);
-	if (activeOption !== void 0) yield* streamField(activeOption, value, mergedResolver, typeof activeOption.meta.description === "string" ? activeOption.meta.description : "", rawResolver);
+	if (activeOption !== void 0) yield* streamField(activeOption, value, mergedResolver, path, rawResolver, currentDepth + 1, diagnostics);
 	yield yieldClose(panelOpen);
 	yield yieldClose(wrapper);
 }
 //#endregion
-export { matchUnionOption, renderFieldSync, renderLeaf, streamField, yieldClose, yieldOpen };
+export { renderFieldSync, renderLeaf, streamField, yieldClose, yieldOpen };

package/dist/limits-Cw5QZND8.d.mts

@@ -0,0 +1,29 @@
+//#region src/core/limits.d.ts
+/**
+ * Shared depth caps and hop counts used to bound recursion across
+ * schema-components. All numeric limits live here so the renderer, the
+ * ref resolver, the OpenAPI parser, and the type-level inference engine
+ * agree on the same constants.
+ */
+/**
+ * Maximum recursion depth for the schema walker, the React renderers,
+ * the streaming HTML renderer, and the server-side renderer. Beyond
+ * this depth a recursion sentinel is emitted instead of further descent
+ * — the only safe response to a cyclic walked-field graph.
+ */
+declare const MAX_RENDER_DEPTH = 10;
+/**
+ * Maximum depth for `$ref` resolution and Zod-tree walks. Mirrors the
+ * type-level `DEFAULT_MAX_DEPTH` ({@link MaxRefDepth}) so the runtime
+ * and compile-time bounds agree.
+ */
+type MaxRefDepth = 64;
+declare const MAX_REF_DEPTH: MaxRefDepth;
+/**
+ * Maximum number of `$ref` hops permitted when walking a chain of
+ * OpenAPI Path Item Object references. Beyond this a
+ * `path-item-ref-too-deep` diagnostic is emitted and resolution stops.
+ */
+declare const MAX_PATH_ITEM_REF_HOPS = 8;
+//#endregion
+export { MaxRefDepth as i, MAX_REF_DEPTH as n, MAX_RENDER_DEPTH as r, MAX_PATH_ITEM_REF_HOPS as t };