schema-components 1.21.0 → 1.23.0

package/dist/html/a11y.mjs

@@ -1,3 +1,4 @@
+import { fieldDomId, hintIdFor } from "../core/idPath.mjs";
 import { h } from "./html.mjs";
 //#region src/html/a11y.ts
 /**
@@ -17,24 +18,21 @@ function joinPath(parent, suffix) {
 	return `${parent}.${suffix}`;
 }
 /**
-* Normalise a path into the id segment used after the `sc-` prefix.
-* Dots (object nesting) and brackets (array indices) become hyphens so
-* the id remains a valid CSS selector and matches test query semantics.
-*/
-function normaliseIdSegment(value) {
-	return value.replace(/[.[\]]+/g, "-").replace(/-+$/g, "");
-}
-/**
-* Build the input ID for a field at a given path.
+* Build the input ID for a field at a given path. Joins `path` and `key`
+* via `joinPath` then delegates to the canonical `fieldDomId` helper from
+* `core/idPath.ts` so every render pipeline emits identical ids for the
+* same structural position.
 */
 function buildInputId(path, key) {
-	return `sc-${normaliseIdSegment(joinPath(path, key))}`;
+	return fieldDomId(joinPath(path, key));
 }
 /**
-* Derive the hint element ID from the input ID.
+* Derive the hint element ID from the input ID. Thin re-export of the
+* canonical helper so this module remains the one-stop a11y surface for
+* the HTML renderers.
 */
 function buildHintId(inputId) {
-	return `${inputId}-hint`;
+	return hintIdFor(inputId);
 }
 /**
 * Build a human-readable constraint description string.

package/dist/html/renderToHtml.d.mts

@@ -1,7 +1,14 @@
-import { T as SchemaMeta } from "../types-BnxPEElk.mjs";
-import { o as HtmlResolver } from "../renderer-DI6ZYf7a.mjs";
+import { w as SchemaMeta } from "../types-BTB73MB8.mjs";
+import { o as HtmlResolver } from "../renderer-CXJ8y0qw.mjs";
 
 //#region src/html/renderToHtml.d.ts
+/**
+ * Build the recursion-cap sentinel element. The label is interpolated
+ * via `h()` + `serialize` so any HTML in `meta.description` (which is
+ * schema-author content but can equally be sourced from user-supplied
+ * JSON Schema input) is escaped — never interpolated into raw markup.
+ */
+declare function recursionSentinelHtml(label: string): string;
 interface RenderToHtmlOptions {
   /** The data value to render. */
   value?: unknown;
@@ -29,4 +36,4 @@ interface RenderToHtmlOptions {
  */
 declare function renderToHtml(schema: unknown, options?: RenderToHtmlOptions): string;
 //#endregion
-export { RenderToHtmlOptions, renderToHtml };
+export { RenderToHtmlOptions, recursionSentinelHtml, renderToHtml };

package/dist/html/renderToHtml.mjs

@@ -1,6 +1,8 @@
+import "../core/limits.mjs";
 import { normaliseSchema } from "../core/adapter.mjs";
 import { getHtmlRenderFn, mergeHtmlResolvers } from "../core/renderer.mjs";
 import { walk } from "../core/walker.mjs";
+import { h, serialize } from "./html.mjs";
 import { joinPath } from "./a11y.mjs";
 import { defaultHtmlResolver } from "./renderers.mjs";
 //#region src/html/renderToHtml.ts
@@ -25,6 +27,15 @@ import { defaultHtmlResolver } from "./renderers.mjs";
 *   });
 */
 /**
+* Build the recursion-cap sentinel element. The label is interpolated
+* via `h()` + `serialize` so any HTML in `meta.description` (which is
+* schema-author content but can equally be sourced from user-supplied
+* JSON Schema input) is escaped — never interpolated into raw markup.
+*/
+function recursionSentinelHtml(label) {
+	return serialize(h("fieldset", { class: "sc-recursive" }, h("em", {}, `↻ ${label} (recursive)`)));
+}
+/**
 * Render a schema to an HTML string.
 *
 * @param schema - Zod schema, JSON Schema, or OpenAPI document
@@ -44,9 +55,8 @@ function renderToHtml(schema, options = {}) {
 		rootDocument
 	});
 	const resolver = options.resolver ?? defaultHtmlResolver;
-	const MAX_HTML_DEPTH = 10;
 	const makeRenderChild = (currentDepth, parentPath) => (childTree, childValue, pathSuffix) => {
-		if (currentDepth >= MAX_HTML_DEPTH) return `<fieldset class="sc-recursive"><em>\u21bb ${typeof childTree.meta.description === "string" ? childTree.meta.description : "schema"} (recursive)</em></fieldset>`;
+		if (currentDepth >= 10) return recursionSentinelHtml(typeof childTree.meta.description === "string" ? childTree.meta.description : "schema");
 		const childPath = joinPath(parentPath, pathSuffix);
 		return renderFieldHtml(childTree, childValue, resolver, childPath, makeRenderChild(currentDepth + 1, childPath));
 	};
@@ -73,4 +83,4 @@ function renderFieldHtml(tree, value, resolver, path, renderChild) {
 	return renderFn(props);
 }
 //#endregion
-export { renderToHtml };
+export { recursionSentinelHtml, renderToHtml };

package/dist/html/renderToHtmlStream.d.mts

@@ -1,5 +1,5 @@
-import { T as SchemaMeta } from "../types-BnxPEElk.mjs";
-import { o as HtmlResolver } from "../renderer-DI6ZYf7a.mjs";
+import { w as SchemaMeta } from "../types-BTB73MB8.mjs";
+import { o as HtmlResolver } from "../renderer-CXJ8y0qw.mjs";
 
 //#region src/html/renderToHtmlStream.d.ts
 interface StreamRenderOptions {

package/dist/html/renderToHtmlStream.mjs

@@ -69,8 +69,19 @@ function prepareTree(schema, options) {
 		resolver: options.resolver ?? defaultHtmlResolver
 	};
 }
+/**
+* Cooperative scheduler yield used between async chunks. Resolves on the
+* next microtask so the event loop can process queued I/O and timers
+* without the four-millisecond clamp browsers apply to nested
+* `setTimeout(..., 0)` calls. The cumulative cost of `setTimeout`-based
+* yielding on a deep schema is measurable; the microtask form is free.
+*/
 function schedulerYield() {
-	return new Promise((resolve) => setTimeout(resolve, 0));
+	return new Promise((resolve) => {
+		queueMicrotask(() => {
+			resolve(void 0);
+		});
+	});
 }
 //#endregion
 export { renderToHtmlChunks, renderToHtmlReadable, renderToHtmlStream };

package/dist/html/renderers.d.mts

@@ -1,15 +1,50 @@
-import { M as WalkedField } from "../types-BnxPEElk.mjs";
-import { o as HtmlResolver } from "../renderer-DI6ZYf7a.mjs";
+import { dateInputType } from "../core/formats.mjs";
+import { o as HtmlResolver } from "../renderer-CXJ8y0qw.mjs";
+import { matchUnionOption } from "../core/unionMatch.mjs";
 
 //#region src/html/renderers.d.ts
-declare function dateInputType(format: string | undefined): string | undefined;
 /**
- * Normalise a structural path into a valid, `sc-` prefixed HTML ID.
- * Dots (object nesting) and brackets (array indices) become hyphens so
- * the id remains a valid CSS selector and predictable in test queries.
+ * Thin wrapper over `fieldDomId` from `core/idPath.ts`. Every render
+ * pipeline must derive ids from the same canonical normaliser so that
+ * `aria-controls`, `aria-labelledby`, and `htmlFor` references resolve
+ * consistently across the React, sync-HTML, and streaming-HTML outputs.
+ *
+ * The wrapper tolerates an empty path here (returning `sc-`) for the
+ * sole reason that a leaf renderer at the schema root would otherwise
+ * throw — `renderToHtml(z.string())` is a rare but valid call shape.
+ * Container renderers thread a non-empty path through `renderChild`, so
+ * the empty-id fallback can never produce sibling collisions inside a
+ * structured form.
+ *
+ * TODO(round7-integration): once `renderToHtml` always threads a stable
+ * root path (e.g. `"$"`) into the leaf renderers, drop this wrapper and
+ * call `fieldDomId` directly so the throw fires as designed.
  */
 declare function fieldId(path: string): string;
-declare function matchUnionOption(options: WalkedField[], value: unknown): WalkedField | undefined;
+/**
+ * Tab-panel id for a discriminated union at `path`. Delegates to the
+ * canonical `panelIdFor` from `core/idPath.ts` for the normal case so
+ * the sync, streaming, and React renderers all emit identical ids; falls
+ * back to a structurally-equivalent string when the renderer is invoked
+ * with an empty root path (a discriminated union at the schema root —
+ * see the `fieldId` doc comment for the wider context).
+ *
+ * Exported because `streamRenderers.ts` needs to derive identical ids
+ * — the panel id on the `<div role="tabpanel">` must match the
+ * `aria-controls` on every tab regardless of which pipeline rendered it.
+ *
+ * TODO(round7-integration): drop the empty-path branch once `renderToHtml`
+ * threads a stable root path so `panelIdFor` can be called directly.
+ */
+declare function panelId(path: string): string;
+/**
+ * Tab id for tab `i` within a discriminated union at `path`. Mirror of
+ * `panelId` above — see its comment.
+ *
+ * TODO(round7-integration): drop the empty-path branch once `renderToHtml`
+ * threads a stable root path so `tabIdFor` can be called directly.
+ */
+declare function tabId(path: string, i: number): string;
 declare const defaultHtmlResolver: HtmlResolver;
 //#endregion
-export { dateInputType, defaultHtmlResolver, fieldId, matchUnionOption };
+export { dateInputType, defaultHtmlResolver, fieldId, matchUnionOption, panelId, tabId };