schema-components 2.0.2 → 2.1.1

package/dist/SchemaComponent-BxzzsHsK.mjs

@@ -0,0 +1,668 @@
+import { isObject, toRecordOrUndefined } from "./core/guards.mjs";
+import "./core/limits.mjs";
+import { SchemaFieldError, SchemaNormalisationError, SchemaRenderError } from "./core/errors.mjs";
+import { normaliseSchema } from "./core/adapter.mjs";
+import { SC_CLASSES } from "./core/cssClasses.mjs";
+import { buildRenderProps } from "./core/renderer.mjs";
+import { walk } from "./core/walker.mjs";
+import { ScString } from "./lit/renderers/scString.mjs";
+import { ScNumber } from "./lit/renderers/scNumber.mjs";
+import { ScBoolean } from "./lit/renderers/scBoolean.mjs";
+import { ScEnum } from "./lit/renderers/scEnum.mjs";
+import { ScObject } from "./lit/renderers/scObject.mjs";
+import { ScArray } from "./lit/renderers/scArray.mjs";
+import { ScTuple } from "./lit/renderers/scTuple.mjs";
+import { ScRecord } from "./lit/renderers/scRecord.mjs";
+import { ScUnion } from "./lit/renderers/scUnion.mjs";
+import { ScDiscriminated } from "./lit/renderers/scDiscriminated.mjs";
+import { ScFile } from "./lit/renderers/scFile.mjs";
+import { ScUnknown } from "./lit/renderers/scUnknown.mjs";
+import { ScLiteral, ScNever, ScNull } from "./lit/renderers/scLiteralNullNever.mjs";
+import { ScConditional, ScNegation } from "./lit/renderers/scConditional.mjs";
+import { resolveLitWidget } from "./lit/widget.mjs";
+import { LitElement, html } from "lit";
+//#region src/lit/SchemaView.ts
+/**
+* `<schema-view>` — read-only Lit Custom Element variant of
+* `<schema-component>`.
+*
+* Parallel to React's `<SchemaView>`: renders the supplied schema +
+* value in read-only mode, never emits a `change` event, and ignores
+* any user input on a nested control. Subclasses
+* `<schema-component>` so the implementation work is just forcing
+* `readOnly = true` and refusing to propagate child change events.
+*
+* **SSR caveat.** This element ALSO runs under `@lit-labs/ssr` for
+* the equivalent of React's server-rendered `<SchemaView>`. The
+* server path uses Declarative Shadow DOM via the `renderToString`
+* helper in `lit/ssr.ts`. See that module's docstring for the
+* documented limitations: `@lit-labs/ssr` is labs status,
+* `@lit/context` does not server-render, and light-DOM-only
+* components are not supported.
+*
+* @packageDocumentation
+*/
+/**
+* Lit Custom Element rendering a schema in read-only mode.
+*
+* Tag: `<schema-view>` (registered by `registerSchemaComponents`).
+*/
+var SchemaView = class extends SchemaComponent {
+	constructor() {
+		super();
+		this.readOnly = true;
+	}
+	connectedCallback() {
+		super.connectedCallback();
+		this.readOnly = true;
+	}
+};
+//#endregion
+//#region src/lit/SchemaField.ts
+/**
+* `<schema-field>` — Lit Custom Element rendering a single field from
+* a schema by dot-separated `path`.
+*
+* Parallel to React's `<SchemaField>`. The element walks the supplied
+* schema, resolves the field at `path`, and renders just that branch.
+* Useful for forms where the layout is hand-built and each field
+* needs its own renderer slot.
+*
+* Implementation note: `<schema-field>` extends `<schema-component>`
+* so the normalisation / dispatch logic is inherited. The override
+* here intercepts the post-walk tree and substitutes the path-
+* targeted branch.
+*
+* @packageDocumentation
+*/
+/**
+* Lit Custom Element rendering a single sub-field of a schema.
+*
+* Tag: `<schema-field>` (registered by `registerSchemaComponents`).
+*/
+var SchemaField = class extends SchemaComponent {
+	static properties = {
+		...SchemaComponent.properties,
+		path: { attribute: false }
+	};
+	constructor() {
+		super();
+		this.path = "";
+	}
+	render() {
+		if (this.schema === void 0 || this.path.length === 0) return html``;
+		let jsonSchema;
+		let rootMeta;
+		let rootDocument;
+		try {
+			const normalised = normaliseSchema(this.schema, this.ref);
+			jsonSchema = normalised.jsonSchema;
+			rootMeta = normalised.rootMeta;
+			rootDocument = normalised.rootDocument;
+		} catch (err) {
+			if (err instanceof SchemaNormalisationError) throw err;
+			throw new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", this.schema, "unknown");
+		}
+		const walkOptions = {
+			componentMeta: this.meta,
+			rootMeta,
+			fieldOverrides: toRecordOrUndefined(this.fields),
+			rootDocument
+		};
+		const root = walk(jsonSchema, walkOptions);
+		const located = locateField(root, this.path);
+		if (located === void 0) throw new SchemaFieldError(`No field at path ${this.path}`, root, this.path);
+		const { tree, value } = located;
+		const valueToRender = value ?? tree.defaultValue;
+		const userResolver = this.resolver ?? createDefaultLitResolver();
+		const renderChild = this.makeRenderChild(0, this.path, userResolver);
+		return this.renderField(tree, valueToRender, (next) => {
+			this.dispatchEvent(new CustomEvent("change", { detail: {
+				value: next,
+				path: this.path
+			} }));
+		}, userResolver, renderChild, this.path);
+	}
+};
+/**
+* Resolve a dot-separated path through a walked field tree, also
+* tracking the value at the same position. Mirrors
+* `react/fieldPath.ts::resolvePath` + `resolveValue` rolled into one.
+*
+* @internal
+*/
+function locateField(root, path) {
+	const segments = splitPath(path);
+	let currentTree = root;
+	let currentValue = void 0;
+	for (const segment of segments) {
+		const numericIndex = parseIndex(segment);
+		if (numericIndex !== void 0) {
+			if (currentTree.type === "array" && currentTree.element) {
+				currentTree = currentTree.element;
+				currentValue = Array.isArray(currentValue) ? currentValue[numericIndex] : void 0;
+				continue;
+			}
+			if (currentTree.type === "tuple") {
+				const next = currentTree.prefixItems[numericIndex];
+				if (next === void 0) return void 0;
+				currentTree = next;
+				currentValue = Array.isArray(currentValue) ? currentValue[numericIndex] : void 0;
+				continue;
+			}
+			return;
+		}
+		if (currentTree.type === "object") {
+			const next = currentTree.fields[segment];
+			if (next === void 0) return void 0;
+			currentTree = next;
+			currentValue = isObject(currentValue) ? currentValue[segment] : void 0;
+			continue;
+		}
+		if (currentTree.type === "record") {
+			currentTree = currentTree.valueType;
+			currentValue = isObject(currentValue) ? currentValue[segment] : void 0;
+			continue;
+		}
+		return;
+	}
+	return {
+		tree: currentTree,
+		value: currentValue
+	};
+}
+/**
+* Split a dot-separated path with bracketed indices into its
+* structural segments. `"a.b[0].c"` → `["a", "b", "[0]", "c"]`.
+*/
+function splitPath(path) {
+	const out = [];
+	let current = "";
+	for (const ch of path) {
+		if (ch === ".") {
+			if (current.length > 0) {
+				out.push(current);
+				current = "";
+			}
+			continue;
+		}
+		if (ch === "[") {
+			if (current.length > 0) out.push(current);
+			current = "[";
+			continue;
+		}
+		if (ch === "]") {
+			current += "]";
+			out.push(current);
+			current = "";
+			continue;
+		}
+		current += ch;
+	}
+	if (current.length > 0) out.push(current);
+	return out;
+}
+/**
+* Parse a `[i]` bracketed-index segment to a number. Returns
+* `undefined` for non-numeric or non-bracketed input.
+*/
+function parseIndex(segment) {
+	if (!segment.startsWith("[") || !segment.endsWith("]")) return void 0;
+	const inner = segment.slice(1, -1);
+	if (inner.length === 0) return void 0;
+	const n = Number(inner);
+	if (!Number.isInteger(n) || n < 0) return void 0;
+	return n;
+}
+//#endregion
+//#region src/lit/registry.ts
+/**
+* Mapping from the canonical built-in tag (without prefix) to the
+* `BaseScElement` subclass that backs it. Exported so consumers can
+* introspect what {@link registerSchemaComponents} will register —
+* useful for diagnostics and for building documentation surfaces.
+*
+* The top-level orchestrator elements (`schema-component`,
+* `schema-view`, `schema-field`) are listed alongside the per-type
+* `<sc-*>` elements; the structural type relaxes to `HTMLElement` so
+* every constructor is assignable.
+*/
+const BUILT_IN_ELEMENTS = Object.freeze({
+	"schema-component": SchemaComponent,
+	"schema-view": SchemaView,
+	"schema-field": SchemaField,
+	"sc-string": ScString,
+	"sc-number": ScNumber,
+	"sc-boolean": ScBoolean,
+	"sc-enum": ScEnum,
+	"sc-object": ScObject,
+	"sc-array": ScArray,
+	"sc-tuple": ScTuple,
+	"sc-record": ScRecord,
+	"sc-union": ScUnion,
+	"sc-discriminated": ScDiscriminated,
+	"sc-conditional": ScConditional,
+	"sc-negation": ScNegation,
+	"sc-literal": ScLiteral,
+	"sc-null": ScNull,
+	"sc-never": ScNever,
+	"sc-file": ScFile,
+	"sc-unknown": ScUnknown
+});
+/**
+* Register every built-in `<sc-*>` Custom Element on the global
+* `customElements` registry, optionally namespaced under `prefix`.
+*
+* Re-registering the same tag is a no-op — `customElements.get(tag)`
+* is checked first so calling this function twice (or alongside
+* another library that registered the same tag) does not throw.
+*
+* @param prefix - Optional prefix prepended to every built-in tag.
+*   E.g. `registerSchemaComponents("myapp-")` registers
+*   `<myapp-sc-string>`, `<myapp-sc-number>`, …, avoiding collisions
+*   with another library that may have shipped its own `<sc-*>`
+*   elements. Pass an empty string (the default) to use the
+*   canonical names.
+* @returns A {@link RegistrationResult} carrying the canonical-tag →
+*   registered-tag map and the list of elements skipped because the
+*   tag was already registered. The map is used by the default
+*   resolver to look up the right tag when the consumer chose a
+*   custom prefix.
+*
+* @example
+* ```ts
+* // Default registration — tags are <sc-string>, <sc-number>, ...
+* import { registerSchemaComponents } from "schema-components/lit/registry";
+* const tags = registerSchemaComponents();
+*
+* // Namespaced registration — tags are <myapp-sc-string>, ...
+* const namespaced = registerSchemaComponents("myapp-");
+* ```
+*/
+function registerSchemaComponents(prefix = "") {
+	const registered = {};
+	const skipped = [];
+	for (const [canonical, ctor] of Object.entries(BUILT_IN_ELEMENTS)) {
+		const tag = `${prefix}${canonical}`;
+		if (customElements.get(tag) !== void 0) {
+			registered[canonical] = tag;
+			skipped.push(tag);
+			continue;
+		}
+		customElements.define(tag, ctor);
+		registered[canonical] = tag;
+	}
+	return {
+		tags: registered,
+		skipped
+	};
+}
+//#endregion
+//#region src/lit/defaultResolver.ts
+/**
+* Default Lit {@link LitComponentResolver} that dispatches every
+* built-in schema type to the matching `<sc-*>` Custom Element.
+*
+* Where the React adapter's headless resolver composes per-type
+* functions that return React elements, the Lit equivalent emits a
+* `<sc-string>` / `<sc-number>` / … Custom Element with the per-field
+* props attached. The element itself is responsible for rendering —
+* the resolver is just a tag-name lookup with property assignment.
+*
+* When the consumer registered the elements with a non-empty prefix
+* (`registerSchemaComponents("myapp-")`), the resolver looks up the
+* prefixed tag from the {@link RegistrationResult.tags} map so the
+* right element is instantiated. A consumer that never called
+* `registerSchemaComponents` falls back to the canonical `sc-*`
+* names — letting tests render the elements directly with
+* `customElements.define` while keeping the production path
+* consumer-controlled.
+*
+* Implementation note: because Lit's `html` tagged template does not
+* support dynamically-named element tags, the resolver builds each
+* Custom Element via `document.createElement` and interpolates the
+* resulting `Node` into the template. This trades one shared cache
+* entry for any tag prefix — Lit's template caching is keyed on the
+* literal, so all 17 dispatches share the same cache slot — for the
+* loss of strictly-typed attribute templating. Per-field props are
+* still assigned through statically-typed property accessors below.
+*
+* @packageDocumentation
+*/
+/**
+* Map of every `WalkedField.type` to its matching canonical `<sc-*>`
+* tag. Exhaustive over the discriminated union — adding a new variant
+* to the walker forces a deliberate update here.
+*
+* Exported so theme adapters can introspect the mapping when building
+* their own resolvers (e.g. a shadcn-flavoured Web Components theme
+* that wraps `<sc-string>` in a `<sl-input>`-style shell).
+*/
+const TYPE_TO_CANONICAL_TAG = Object.freeze({
+	string: "sc-string",
+	number: "sc-number",
+	boolean: "sc-boolean",
+	null: "sc-null",
+	enum: "sc-enum",
+	object: "sc-object",
+	array: "sc-array",
+	tuple: "sc-tuple",
+	record: "sc-record",
+	union: "sc-union",
+	discriminatedUnion: "sc-discriminated",
+	conditional: "sc-conditional",
+	negation: "sc-negation",
+	literal: "sc-literal",
+	file: "sc-file",
+	never: "sc-never",
+	unknown: "sc-unknown"
+});
+/**
+* Build the default Lit resolver for the supplied
+* {@link RegistrationResult}.
+*
+* Each render function emits a Lit `html` template whose body is a
+* dynamically-created `<sc-*>` element with every field prop assigned.
+* The change callback is forwarded directly so user input on a leaf
+* renderer reaches the orchestrator without going through a Custom
+* Event boundary on the fast path.
+*
+* When no `registration` is supplied, the resolver emits the
+* canonical `sc-*` tags. Useful in tests where `customElements.define`
+* may have been called separately and the consumer doesn't need a
+* prefixed registration object.
+*/
+function createDefaultLitResolver(registration) {
+	const tags = registration?.tags ?? Object.fromEntries(Object.keys(BUILT_IN_ELEMENTS).map((tag) => [tag, tag]));
+	function tagFor(type) {
+		const canonical = TYPE_TO_CANONICAL_TAG[type];
+		return tags[canonical] ?? canonical;
+	}
+	function elementRenderer(type) {
+		return (props) => renderTagged(tagFor(type), props);
+	}
+	return {
+		string: elementRenderer("string"),
+		number: elementRenderer("number"),
+		boolean: elementRenderer("boolean"),
+		null: elementRenderer("null"),
+		enum: elementRenderer("enum"),
+		object: elementRenderer("object"),
+		array: elementRenderer("array"),
+		tuple: elementRenderer("tuple"),
+		record: elementRenderer("record"),
+		union: elementRenderer("union"),
+		discriminatedUnion: elementRenderer("discriminatedUnion"),
+		conditional: elementRenderer("conditional"),
+		negation: elementRenderer("negation"),
+		literal: elementRenderer("literal"),
+		file: elementRenderer("file"),
+		never: elementRenderer("never"),
+		unknown: elementRenderer("unknown")
+	};
+}
+/**
+* Build a Lit template fragment that renders a single Custom Element
+* by tag name with every per-field prop attached.
+*
+* Pure DOM-side path. The `lit-labs/ssr` path (`renderToString` in
+* `lit/ssr.ts`) takes a separate code path that emits Declarative
+* Shadow DOM markup; this helper is for the browser render only.
+*/
+function renderTagged(tag, props) {
+	if (typeof document === "undefined") return html``;
+	const el = document.createElement(tag);
+	applyProperties(el, props);
+	return html`${el}`;
+}
+/**
+* Assign every prop from {@link LitRenderProps} onto the created
+* element. Element constructors created with `document.createElement`
+* are typed as `HTMLElement`; we narrow through the `BaseScElement`
+* field shape (every built-in implements it) so the assignment is
+* statically typed without an `as` cast.
+*
+* If the element turns out NOT to be a `BaseScElement` (a tag prefix
+* collision with a consumer-registered third-party element, or a
+* misconfigured override), the assignment still succeeds because the
+* built-in field shape is structurally identical to a plain object —
+* the consumer is responsible for matching the field surface.
+*/
+function applyProperties(el, props) {
+	Reflect.set(el, "tree", props.tree);
+	Reflect.set(el, "value", props.value);
+	Reflect.set(el, "readOnly", props.readOnly);
+	Reflect.set(el, "writeOnly", props.writeOnly);
+	Reflect.set(el, "path", props.path);
+	Reflect.set(el, "meta", props.meta);
+	Reflect.set(el, "constraints", props.constraints);
+	if (props.examples !== void 0) Reflect.set(el, "examples", props.examples);
+	Reflect.set(el, "change", props.change);
+	Reflect.set(el, "renderChild", props.renderChild);
+}
+//#endregion
+//#region src/lit/SchemaComponent.ts
+/**
+* `<schema-component>` — top-level Lit Custom Element for editable
+* schema-driven UI.
+*
+* Parity with the React `<SchemaComponent>` for the rendering path:
+*
+* - Accepts a Zod schema, JSON Schema, or OpenAPI document via the
+*   `schema` property (NOT attribute — see "Property-only schema/
+*   value/resolver" in `lit/README.md`).
+* - Walks the schema via `normaliseSchema` → `walk` from
+*   `core/walker.ts` and dispatches every node through a Lit
+*   resolver — by default, the {@link createDefaultLitResolver}
+*   resolver that renders the built-in `<sc-*>` Custom Elements.
+* - Emits a public `change` Custom Event on every user edit, with
+*   the updated root value in `event.detail.value`. Cross-framework
+*   wrappers translate this into the host framework's event /
+*   binding primitive (React's `onChange`, Vue `@change`, Svelte
+*   `on:change`).
+*
+* The element is registered by {@link registerSchemaComponents}; tag
+* name defaults to `<schema-component>`. Pass a non-empty prefix
+* (`registerSchemaComponents("myapp-")`) to namespace the top-level
+* tag alongside every `<sc-*>` child.
+*
+* @packageDocumentation
+*/
+/**
+* Lit Custom Element for editable schema-driven UI.
+*
+* Tag: `<schema-component>` (default) or `<{prefix}schema-component>`
+* (when `registerSchemaComponents(prefix)` is called).
+*
+* **Required:** call {@link registerSchemaComponents} once at module
+* setup before instantiating this element in HTML markup, otherwise
+* none of the per-type `<sc-*>` children will upgrade and the tree
+* will render as unknown elements.
+*/
+var SchemaComponent = class extends LitElement {
+	/**
+	* Element property declarations.
+	*
+	* All four "data" properties (`schema`, `value`, `resolver`,
+	* `widgets`) carry `attribute: false`: Custom Element attributes
+	* are strings, and these payloads (an arbitrary Zod schema, an
+	* arbitrary JS value, a resolver function map, a widget tag map)
+	* cannot round-trip through attribute serialisation. Set them via
+	* direct property assignment.
+	*
+	* `readOnly` is a boolean attribute (and reflects to DOM) so the
+	* common "render read-only view" case is reachable from plain
+	* HTML markup (`<schema-component readonly></schema-component>`).
+	* The capitalisation is `readOnly` on the property and `readonly`
+	* on the attribute — matching the HTML `readonly` attribute on
+	* `<input>` / `<textarea>`.
+	*/
+	static properties = {
+		schema: { attribute: false },
+		value: { attribute: false },
+		resolver: { attribute: false },
+		widgets: { attribute: false },
+		fields: { attribute: false },
+		meta: { attribute: false },
+		ref: { attribute: false },
+		io: { attribute: false },
+		idPrefix: { attribute: false },
+		onDiagnostic: { attribute: false },
+		readOnly: {
+			type: Boolean,
+			reflect: true,
+			attribute: "readonly"
+		},
+		strict: { type: Boolean }
+	};
+	constructor() {
+		super();
+		this.schema = void 0;
+		this.value = void 0;
+		this.readOnly = false;
+		this.strict = false;
+	}
+	render() {
+		if (this.schema === void 0) return html``;
+		let jsonSchema;
+		let rootMeta;
+		let rootDocument;
+		try {
+			const diagnosticsOptions = this.onDiagnostic !== void 0 || this.strict ? this.buildDiagnostics() : void 0;
+			const normaliseOptions = diagnosticsOptions !== void 0 || this.io !== void 0 ? {
+				...diagnosticsOptions !== void 0 ? { diagnostics: diagnosticsOptions } : {},
+				...this.io !== void 0 ? { io: this.io } : {}
+			} : void 0;
+			const normalised = normaliseSchema(this.schema, this.ref, normaliseOptions);
+			jsonSchema = normalised.jsonSchema;
+			rootMeta = normalised.rootMeta;
+			rootDocument = normalised.rootDocument;
+		} catch (err) {
+			if (err instanceof SchemaNormalisationError) throw err;
+			throw new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", this.schema, "unknown");
+		}
+		const mergedMeta = { ...this.meta };
+		if (this.readOnly) mergedMeta.readOnly = true;
+		const walkOptions = {
+			componentMeta: mergedMeta,
+			rootMeta,
+			fieldOverrides: toRecordOrUndefined(this.fields),
+			rootDocument,
+			...this.onDiagnostic !== void 0 || this.strict ? { diagnostics: this.buildDiagnostics() } : {}
+		};
+		const tree = walk(jsonSchema, walkOptions);
+		const userResolver = this.resolver ?? createDefaultLitResolver();
+		const rootPath = this.idPrefix ?? "root";
+		const rootChange = (next) => {
+			this.value = next;
+			this.dispatchEvent(new CustomEvent("change", {
+				detail: { value: next },
+				bubbles: false,
+				composed: false
+			}));
+			this.requestUpdate();
+		};
+		const renderChild = this.makeRenderChild(0, rootPath, userResolver);
+		return this.renderField(tree, this.value ?? tree.defaultValue, rootChange, userResolver, renderChild, rootPath);
+	}
+	/**
+	* Build the recursive `renderChild` closure threaded through every
+	* container renderer.
+	*/
+	makeRenderChild(currentDepth, parentPath, userResolver) {
+		const joinPath = (parent, suffix) => {
+			if (suffix === void 0) return parent;
+			return suffix.startsWith("[") ? `${parent}${suffix}` : `${parent}.${suffix}`;
+		};
+		return (childTree, childValue, childChange, pathSuffix) => {
+			const childPath = joinPath(parentPath, pathSuffix);
+			if (currentDepth >= 10) {
+				const label = typeof childTree.meta.description === "string" ? childTree.meta.description : "schema";
+				return html`<fieldset class=${SC_CLASSES.recursive}>
+                    <em>${`↻ ${label} (recursive)`}</em>
+                </fieldset>`;
+			}
+			const grandChild = this.makeRenderChild(currentDepth + 1, childPath, userResolver);
+			return this.renderField(childTree, childValue, childChange, userResolver, grandChild, childPath);
+		};
+	}
+	/**
+	* Dispatch a single walked field through the resolver, widget
+	* registry, and recursion limit. Parallel to
+	* `renderField` in `react/SchemaComponent.tsx`.
+	*/
+	renderField(tree, value, change, userResolver, renderChild, path) {
+		const componentHint = tree.meta.component;
+		if (typeof componentHint === "string") {
+			const widget = resolveLitWidget(componentHint, this.widgets);
+			if (widget !== void 0) {
+				if (typeof document === "undefined") return html``;
+				const el = document.createElement(widget);
+				this.applyWidgetProperties(el, tree, value, change, path);
+				return html`${el}`;
+			}
+		}
+		const renderFn = userResolver[litResolverKey(tree.type)];
+		if (renderFn !== void 0) {
+			const adaptedRenderChild = (childTree, childValue, childOnChange, pathSuffix) => renderChild(childTree, childValue, childOnChange, pathSuffix);
+			const coreProps = buildRenderProps(tree, value, change, adaptedRenderChild, path);
+			const litProps = {
+				value: coreProps.value,
+				readOnly: coreProps.readOnly,
+				writeOnly: coreProps.writeOnly,
+				meta: coreProps.meta,
+				constraints: coreProps.constraints,
+				path: coreProps.path,
+				tree: coreProps.tree,
+				change,
+				renderChild,
+				...coreProps.examples !== void 0 ? { examples: coreProps.examples } : {}
+			};
+			try {
+				return renderFn(litProps);
+			} catch (err) {
+				throw new SchemaRenderError(err instanceof Error ? err.message : `Render function threw for type "${tree.type}"`, tree, tree.type, err);
+			}
+		}
+		if (value === void 0 || value === null) return html`<span>—</span>`;
+		return html`<span>${typeof value === "string" ? value : JSON.stringify(value)}</span>`;
+	}
+	applyWidgetProperties(el, tree, value, change, path) {
+		Reflect.set(el, "tree", tree);
+		Reflect.set(el, "value", value);
+		Reflect.set(el, "readOnly", this.readOnly);
+		Reflect.set(el, "path", path);
+		Reflect.set(el, "meta", tree.meta);
+		Reflect.set(el, "constraints", tree.constraints);
+		Reflect.set(el, "change", change);
+	}
+	buildDiagnostics() {
+		const opts = {};
+		if (this.onDiagnostic !== void 0) opts.diagnostics = this.onDiagnostic;
+		if (this.strict) opts.strict = true;
+		return opts;
+	}
+};
+function litResolverKey(type) {
+	switch (type) {
+		case "string":
+		case "number":
+		case "boolean":
+		case "null":
+		case "enum":
+		case "object":
+		case "array":
+		case "tuple":
+		case "record":
+		case "union":
+		case "discriminatedUnion":
+		case "conditional":
+		case "negation":
+		case "literal":
+		case "file":
+		case "never":
+		case "unknown": return type;
+	}
+}
+//#endregion
+export { registerSchemaComponents as a, BUILT_IN_ELEMENTS as i, TYPE_TO_CANONICAL_TAG as n, SchemaField as o, createDefaultLitResolver as r, SchemaView as s, SchemaComponent as t };