schema-components 1.12.11 → 1.13.0

package/dist/html/renderToHtmlStream.mjs

@@ -1,10 +1,8 @@
-import { isObject } from "../core/guards.mjs";
 import { normaliseSchema } from "../core/adapter.mjs";
-import { getHtmlRenderFn, mergeHtmlResolvers } from "../core/renderer.mjs";
+import { mergeHtmlResolvers } from "../core/renderer.mjs";
 import { walk } from "../core/walker.mjs";
-import { VOID_ELEMENTS, h, raw, serialize, serializeAttributes } from "./html.mjs";
-import { ariaLabelAttrs, buildHintElement, buildInputId, requiredIndicator } from "./a11y.mjs";
-import { defaultHtmlResolver } from "./renderToHtml.mjs";
+import { defaultHtmlResolver } from "./renderers.mjs";
+import { streamField } from "./streamRenderers.mjs";
 //#region src/html/renderToHtmlStream.ts
 /**
 * Streaming HTML renderer — yields HTML chunks incrementally.
@@ -19,91 +17,41 @@ import { defaultHtmlResolver } from "./renderToHtml.mjs";
 * - `renderToHtmlChunks(schema, options)` → sync `Iterable<string>`
 * - `renderToHtmlStream(schema, options)` → async `AsyncIterable<string>`
 * - `renderToHtmlReadable(schema, options)` → web `ReadableStream<string>`
-*
-* Chunk boundaries:
-* - Object: opening tag, one chunk per field, closing tag
-* - Array: opening tag, one chunk per item, closing tag
-* - Record: opening tag, one chunk per entry, closing tag
-* - Leaf types (string, number, boolean, enum, literal, unknown):
-*   rendered entirely as one chunk
-*
-* All HTML construction uses `h()` from `html.ts` — the streaming module
-* manually yields the opening tag, then children, then the closing tag.
-*/
-/**
-* Yield the opening tag of an element (e.g. `<fieldset class="sc-object">`).
-* For void elements, yields the complete self-closing tag.
 */
-function yieldOpen(el) {
-	const attrs = serializeAttributes(el.attributes);
-	return `<${el.tag}${attrs}>`;
-}
 /**
-* Yield the closing tag of an element (e.g. `</fieldset>`).
-* Returns empty string for void elements.
+* Render a schema as an iterable of HTML string chunks.
+* Each chunk is a self-contained HTML fragment.
 */
-function yieldClose(el) {
-	if (VOID_ELEMENTS.has(el.tag)) return "";
-	return `</${el.tag}>`;
-}
-/**
-* Render a schema to HTML string chunks, yielded incrementally.
-*
-* Each yielded chunk is a self-contained HTML fragment. Concatenating
-* all chunks produces the same output as `renderToHtml`.
-*
-* @returns Sync iterable of HTML string chunks
-*/
-function* renderToHtmlChunks(schema, options = {}) {
-	const tree = prepareTree(schema, options);
-	const resolver = options.resolver ?? defaultHtmlResolver;
-	const mergedResolver = mergeHtmlResolvers(resolver, defaultHtmlResolver);
-	yield* streamField(tree, options.value ?? tree.defaultValue, mergedResolver, "", resolver);
+function renderToHtmlChunks(schema, options = {}) {
+	const { tree, resolver } = prepareTree(schema, options);
+	return streamField(tree, options.value ?? tree.defaultValue, mergeHtmlResolvers(resolver, defaultHtmlResolver), "", resolver);
 }
 /**
-* Render a schema to HTML string chunks asynchronously.
-*
-* Identical chunk boundaries to `renderToHtmlChunks` but yields via
-* an async generator. Use with `for await...of` or pipe to a response.
-*
-* @returns Async iterable of HTML string chunks
+* Render a schema as an async iterable of HTML string chunks.
+* Yields `undefined` between chunks to allow the event loop to process
+* other tasks (cooperative scheduling).
 */
 async function* renderToHtmlStream(schema, options = {}) {
-	const tree = prepareTree(schema, options);
-	const resolver = options.resolver ?? defaultHtmlResolver;
+	const { tree, resolver } = prepareTree(schema, options);
+	const effectiveValue = options.value ?? tree.defaultValue;
 	const mergedResolver = mergeHtmlResolvers(resolver, defaultHtmlResolver);
-	for (const chunk of streamField(tree, options.value, mergedResolver, "", resolver)) {
+	for (const chunk of streamField(tree, effectiveValue, mergedResolver, "", resolver)) {
 		yield chunk;
 		await schedulerYield();
 	}
 }
 /**
-* No-op await that yields control to the event loop.
-*/
-function schedulerYield() {
-	return Promise.resolve(void 0);
-}
-/**
-* Render a schema to a web `ReadableStream<string>`.
-*
-* ```ts
-* return new Response(renderToHtmlReadable(schema, { value }), {
-*     headers: { "Content-Type": "text/html" },
-* });
-* ```
+* Render a schema as a web `ReadableStream<string>`.
+* Uses the async rendering pipeline internally.
 */
 function renderToHtmlReadable(schema, options = {}) {
-	const iterator = renderToHtmlChunks(schema, options)[Symbol.iterator]();
-	return new ReadableStream({
-		pull(controller) {
-			const result = iterator.next();
-			if (result.done) controller.close();
-			else controller.enqueue(result.value);
-		},
-		cancel() {
-			if (iterator.return !== void 0) iterator.return();
-		}
-	});
+	const { tree, resolver } = prepareTree(schema, options);
+	const iterator = streamField(tree, options.value ?? tree.defaultValue, mergeHtmlResolvers(resolver, defaultHtmlResolver), "", resolver)[Symbol.iterator]();
+	return new ReadableStream({ pull(controller) {
+		const { value, done } = iterator.next();
+		if (done) controller.close();
+		else controller.enqueue(value);
+	} });
 }
 function prepareTree(schema, options) {
 	const mergedMeta = { ...options.meta };
@@ -111,238 +59,18 @@ function prepareTree(schema, options) {
 	if (options.writeOnly === true) mergedMeta.writeOnly = true;
 	if (options.description !== void 0) mergedMeta.description = options.description;
 	const { jsonSchema, rootMeta, rootDocument } = normaliseSchema(schema, options.ref);
-	return walk(jsonSchema, {
-		componentMeta: mergedMeta,
-		rootMeta,
-		fieldOverrides: options.fields,
-		rootDocument
-	});
-}
-function* streamField(tree, value, mergedResolver, path, rawResolver) {
-	const effectiveValue = value ?? tree.defaultValue;
-	const type = tree.type;
-	if (type === "string" || type === "number" || type === "boolean" || type === "enum" || type === "literal" || type === "file" || type === "unknown") {
-		yield renderLeaf(tree, effectiveValue, mergedResolver, path);
-		return;
-	}
-	if (type === "union") {
-		yield* streamUnion(tree, effectiveValue, mergedResolver, path, rawResolver);
-		return;
-	}
-	if (type === "discriminatedUnion") {
-		yield* streamDiscriminatedUnion(tree, value, mergedResolver, path, rawResolver);
-		return;
-	}
-	if (type === "object") {
-		yield* streamObject(tree, value, mergedResolver, path, rawResolver);
-		return;
-	}
-	if (type === "array") {
-		yield* streamArray(tree, value, mergedResolver, path, rawResolver);
-		return;
-	}
-	if (type === "record") {
-		yield* streamRecord(tree, value, mergedResolver, path, rawResolver);
-		return;
-	}
-	yield renderLeaf(tree, value, mergedResolver, path);
-}
-function* streamObject(tree, value, mergedResolver, path, rawResolver) {
-	const fields = tree.fields;
-	if (fields === void 0) 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" };
-		Object.assign(dlAttrs, labelAttrs);
-		const dl = h("dl", dlAttrs);
-		const legend = descriptionText !== void 0 ? serialize(h("legend", {}, descriptionText)) : "";
-		yield `${yieldOpen(dl)}${legend}`;
-		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)))}`;
-		}
-		yield yieldClose(dl);
-	} else {
-		const fieldsetAttrs = { class: "sc-object" };
-		Object.assign(fieldsetAttrs, labelAttrs);
-		const fieldset = h("fieldset", fieldsetAttrs);
-		const legend = descriptionText !== void 0 ? serialize(h("legend", {}, descriptionText)) : "";
-		yield `${yieldOpen(fieldset)}${legend}`;
-		for (const [key, field] of Object.entries(fields)) {
-			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 required = requiredIndicator(field);
-			const labelContent = [label];
-			if (required !== void 0) labelContent.push(required);
-			const fieldChildren = [h("label", {
-				class: "sc-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 yieldClose(fieldset);
-	}
-}
-function* streamArray(tree, value, mergedResolver, path, rawResolver) {
-	const arr = Array.isArray(value) ? value : [];
-	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" });
-		yield yieldOpen(ul);
-		for (const item of arr) yield serialize(h("li", { class: "sc-item" }, raw(renderFieldSync(element, item, mergedResolver, elementPath, rawResolver))));
-		yield yieldClose(ul);
-	} else {
-		const div = h("div", { class: "sc-array" });
-		yield yieldOpen(div);
-		for (const item of arr) yield serialize(h("div", {}, raw(renderFieldSync(element, item, mergedResolver, elementPath, rawResolver))));
-		yield yieldClose(div);
-	}
-}
-function* streamRecord(tree, value, mergedResolver, path, rawResolver) {
-	const obj = isObject(value) ? value : {};
-	const valueType = tree.valueType;
-	if (valueType === void 0) return;
-	const readOnly = tree.editability === "presentation";
-	const attrs = {
-		class: "sc-record",
-		role: "group"
+	return {
+		tree: walk(jsonSchema, {
+			componentMeta: mergedMeta,
+			rootMeta,
+			fieldOverrides: options.fields,
+			rootDocument
+		}),
+		resolver: options.resolver ?? defaultHtmlResolver
 	};
-	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)))}`;
-		}
-		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)));
-		}
-		yield yieldClose(container);
-	}
-}
-function* streamUnion(tree, value, mergedResolver, path, rawResolver) {
-	const options = tree.options;
-	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)));
-		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" }, "—"));
 }
-function* streamDiscriminatedUnion(tree, value, mergedResolver, path, rawResolver) {
-	const options = tree.options;
-	const discriminator = tree.discriminator;
-	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)));
-		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) => {
-		const discriminatorField = opt.fields?.[discKey];
-		if (discriminatorField !== void 0) {
-			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];
-	if (tree.editability === "presentation") {
-		if (activeOption !== void 0) yield* streamField(activeOption, value, mergedResolver, typeof activeOption.meta.description === "string" ? activeOption.meta.description : "", rawResolver);
-		return;
-	}
-	const panelId = `sc-${path}-panel`;
-	const wrapper = h("div", { class: "sc-discriminated-union" });
-	yield yieldOpen(wrapper);
-	yield serialize(h("div", {
-		role: "tablist",
-		class: "sc-tabs",
-		"aria-label": "Select variant"
-	}, ...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)}`,
-			"aria-selected": i === activeIndex ? "true" : void 0,
-			"aria-controls": panelId,
-			tabindex: i === activeIndex ? "0" : "-1"
-		}, optionLabels[i]);
-	})));
-	const panelOpen = h("div", {
-		role: "tabpanel",
-		id: panelId,
-		"aria-labelledby": `sc-${path}-tab-${String(activeIndex)}`
-	});
-	yield yieldOpen(panelOpen);
-	if (activeOption !== void 0) yield* streamField(activeOption, value, mergedResolver, typeof activeOption.meta.description === "string" ? activeOption.meta.description : "", rawResolver);
-	yield yieldClose(panelOpen);
-	yield yieldClose(wrapper);
-}
-function renderLeaf(tree, value, mergedResolver, path) {
-	const renderFn = getHtmlRenderFn(tree.type, mergedResolver);
-	if (renderFn !== void 0) {
-		const props = {
-			value,
-			readOnly: tree.editability === "presentation",
-			writeOnly: tree.editability === "input",
-			meta: tree.meta,
-			constraints: tree.constraints,
-			path,
-			tree,
-			renderChild: () => ""
-		};
-		if (tree.enumValues !== void 0) props.enumValues = tree.enumValues;
-		if (tree.element !== void 0) props.element = tree.element;
-		if (tree.fields !== void 0) props.fields = tree.fields;
-		if (tree.options !== void 0) props.options = tree.options;
-		if (tree.discriminator !== void 0) props.discriminator = tree.discriminator;
-		if (tree.keyType !== void 0) props.keyType = tree.keyType;
-		if (tree.valueType !== void 0) props.valueType = tree.valueType;
-		return renderFn(props);
-	}
-	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)));
-}
-/**
-* Render a field synchronously to a string, recursively streaming children.
-*/
-function renderFieldSync(tree, value, mergedResolver, path, rawResolver) {
-	return [...streamField(tree, value, mergedResolver, path, rawResolver)].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");
+function schedulerYield() {
+	return new Promise((resolve) => setTimeout(resolve, 0));
 }
 //#endregion
 export { renderToHtmlChunks, renderToHtmlReadable, renderToHtmlStream };

package/dist/html/renderers.d.mts

@@ -0,0 +1,14 @@
+import { j as WalkedField } from "../types-ag2jYLqQ.mjs";
+import { o as HtmlResolver } from "../renderer-DseHeliw.mjs";
+
+//#region src/html/renderers.d.ts
+declare function dateInputType(format: string | undefined): string | undefined;
+/**
+ * Normalise a dot-separated path into a valid, `sc-` prefixed HTML ID.
+ * Dots in paths (from nested objects) become hyphens.
+ */
+declare function fieldId(path: string): string;
+declare function matchUnionOption(options: WalkedField[], value: unknown): WalkedField | undefined;
+declare const defaultHtmlResolver: HtmlResolver;
+//#endregion
+export { dateInputType, defaultHtmlResolver, fieldId, matchUnionOption };