schema-components 2.0.1 → 2.1.0

package/dist/lit/types.d.mts

@@ -0,0 +1,2 @@
+import { i as _LitFunctionShapeAssertion, n as LitRenderFunction, r as LitRenderProps, t as LitComponentResolver } from "../types-BCy7K3nk.mjs";
+export { LitComponentResolver, LitRenderFunction, LitRenderProps, _LitFunctionShapeAssertion };

package/dist/lit/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/lit/widget.d.mts

@@ -0,0 +1,71 @@
+//#region src/lit/widget.d.ts
+/**
+ * Widget registry for the Lit adapter.
+ *
+ * Where the React adapter's widget registry stores function values
+ * (`(props: RenderProps) => unknown`), the Lit adapter stores Custom
+ * Element tag names — because every renderer override on the Web
+ * Components side IS a Custom Element. A schema field carrying
+ * `.meta({ component: "color-picker" })` is rendered by looking up
+ * the tag name registered against `"color-picker"` and emitting an
+ * instance of that element with the per-field props attached.
+ *
+ * Two scopes are supported:
+ *
+ * 1. **Global** — `registerLitWidget(name, tag)` writes to a module-level
+ *    map shared by every `<schema-component>` in the document. Matches
+ *    the React `registerWidget()` global default behaviour.
+ * 2. **Instance** — the `widgets` property on `<schema-component>` (a
+ *    `LitWidgetMap` from `lit/contexts.ts`) overrides the global map
+ *    for the wrapped subtree.
+ *
+ * Resolution order: instance widgets → global widgets → resolver →
+ * default Custom Element registry. The same order the React adapter
+ * implements; the only difference is the per-step lookup returns a
+ * tag name rather than a function value.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Register a widget globally. The widget is resolved when a schema
+ * field has `.meta({ component: name })` and the rendered element is
+ * an instance of the matching Custom Element tag.
+ *
+ * `tag` must be a valid Custom Element name (containing a hyphen) and
+ * SHOULD be registered via `customElements.define` before any
+ * `<schema-component>` in the document instantiates the corresponding
+ * field — otherwise the browser emits an unupgraded element and the
+ * registered handler never runs.
+ *
+ * @example
+ * ```ts
+ * import { registerLitWidget } from "schema-components/lit/widget";
+ * import "./my-color-picker.ts";   // calls customElements.define("my-color-picker", ...)
+ *
+ * registerLitWidget("color-picker", "my-color-picker");
+ * ```
+ *
+ * @param name - Widget hint name (matches `.meta({ component })`).
+ * @param tag - Custom Element tag name (e.g. `my-color-picker`).
+ */
+declare function registerLitWidget(name: string, tag: string): void;
+/**
+ * Resolve a widget hint to a Custom Element tag name, considering
+ * instance widgets first and falling back to the global registry.
+ *
+ * @param name - Widget hint name from `.meta({ component })`.
+ * @param instanceWidgets - Optional instance-scoped overrides.
+ * @returns The Custom Element tag, or `undefined` when no widget is
+ *   registered under `name` at either scope.
+ */
+declare function resolveLitWidget(name: string, instanceWidgets?: ReadonlyMap<string, string>): string | undefined;
+/**
+ * Clear every globally registered widget. Intended for test isolation
+ * — `registerLitWidget` writes to module-level state, and that state
+ * leaks across test cases without an explicit reset.
+ *
+ * @internal
+ */
+declare function __clearGlobalLitWidgets(): void;
+//#endregion
+export { __clearGlobalLitWidgets, registerLitWidget, resolveLitWidget };

package/dist/lit/widget.mjs

@@ -0,0 +1,87 @@
+//#region src/lit/widget.ts
+/**
+* Widget registry for the Lit adapter.
+*
+* Where the React adapter's widget registry stores function values
+* (`(props: RenderProps) => unknown`), the Lit adapter stores Custom
+* Element tag names — because every renderer override on the Web
+* Components side IS a Custom Element. A schema field carrying
+* `.meta({ component: "color-picker" })` is rendered by looking up
+* the tag name registered against `"color-picker"` and emitting an
+* instance of that element with the per-field props attached.
+*
+* Two scopes are supported:
+*
+* 1. **Global** — `registerLitWidget(name, tag)` writes to a module-level
+*    map shared by every `<schema-component>` in the document. Matches
+*    the React `registerWidget()` global default behaviour.
+* 2. **Instance** — the `widgets` property on `<schema-component>` (a
+*    `LitWidgetMap` from `lit/contexts.ts`) overrides the global map
+*    for the wrapped subtree.
+*
+* Resolution order: instance widgets → global widgets → resolver →
+* default Custom Element registry. The same order the React adapter
+* implements; the only difference is the per-step lookup returns a
+* tag name rather than a function value.
+*
+* @packageDocumentation
+*/
+/**
+* Global widget registry — `widget-name` → custom element tag name.
+*
+* Internal; consumers register via {@link registerLitWidget} and read
+* via {@link resolveLitWidget} so the map shape can evolve without
+* breaking callers.
+*/
+const globalLitWidgets = /* @__PURE__ */ new Map();
+/**
+* Register a widget globally. The widget is resolved when a schema
+* field has `.meta({ component: name })` and the rendered element is
+* an instance of the matching Custom Element tag.
+*
+* `tag` must be a valid Custom Element name (containing a hyphen) and
+* SHOULD be registered via `customElements.define` before any
+* `<schema-component>` in the document instantiates the corresponding
+* field — otherwise the browser emits an unupgraded element and the
+* registered handler never runs.
+*
+* @example
+* ```ts
+* import { registerLitWidget } from "schema-components/lit/widget";
+* import "./my-color-picker.ts";   // calls customElements.define("my-color-picker", ...)
+*
+* registerLitWidget("color-picker", "my-color-picker");
+* ```
+*
+* @param name - Widget hint name (matches `.meta({ component })`).
+* @param tag - Custom Element tag name (e.g. `my-color-picker`).
+*/
+function registerLitWidget(name, tag) {
+	globalLitWidgets.set(name, tag);
+}
+/**
+* Resolve a widget hint to a Custom Element tag name, considering
+* instance widgets first and falling back to the global registry.
+*
+* @param name - Widget hint name from `.meta({ component })`.
+* @param instanceWidgets - Optional instance-scoped overrides.
+* @returns The Custom Element tag, or `undefined` when no widget is
+*   registered under `name` at either scope.
+*/
+function resolveLitWidget(name, instanceWidgets) {
+	const instance = instanceWidgets?.get(name);
+	if (instance !== void 0) return instance;
+	return globalLitWidgets.get(name);
+}
+/**
+* Clear every globally registered widget. Intended for test isolation
+* — `registerLitWidget` writes to module-level state, and that state
+* leaks across test cases without an explicit reset.
+*
+* @internal
+*/
+function __clearGlobalLitWidgets() {
+	globalLitWidgets.clear();
+}
+//#endregion
+export { __clearGlobalLitWidgets, registerLitWidget, resolveLitWidget };

package/dist/{normalise-DB-Xtjmn.mjs → normalise-BkePrJ4v.mjs}

@@ -125,7 +125,7 @@ function compositeAlreadyAllowsNull(options) {
 * values into each `oneOf`/`anyOf` option's discriminator property.
 *
 * In OpenAPI 3.0, `discriminator` is a sibling of `oneOf`/`anyOf`:
-*   discriminator: { propertyName: "type" }
+*   `discriminator: { propertyName: "type" }`
 * The walker detects discriminated unions from `oneOf` + `const` on a
 * property, so this normaliser injects the `const` values from the
 * `mapping` or infers them from `$ref` fragment names.
@@ -1308,7 +1308,7 @@ function normaliseSwaggerHeader(header, diagnostics, pointer = "") {
 * Deep-rewrite $ref strings in a normalised Swagger 2.0 document
 * from Swagger 2.0 locations to OpenAPI 3.x locations using the
 * shared {@link rewriteSwaggerRefPrefix} mapping. Mutates the object
-* in place \u2014 called only on the fresh clone produced by
+* in place — called only on the fresh clone produced by
 * normaliseSwagger2Document.
 */
 function rewriteSwaggerRefs(node) {
@@ -1764,12 +1764,12 @@ function applyDraft04Translations(node, ctx) {
 * single node.
 *
 * In Draft 04:
-* - `exclusiveMinimum: true` + `minimum: 5` → value must be > 5
-* - `exclusiveMinimum: false` (or absent) + `minimum: 5` → value must be >= 5
+* - `exclusiveMinimum: true` + `minimum: 5` → value must be \> 5
+* - `exclusiveMinimum: false` (or absent) + `minimum: 5` → value must be \>= 5
 *
 * In Draft 06+:
-* - `exclusiveMinimum: 5` → value must be > 5 (no separate `minimum`)
-* - `minimum: 5` → value must be >= 5
+* - `exclusiveMinimum: 5` → value must be \> 5 (no separate `minimum`)
+* - `minimum: 5` → value must be \>= 5
 *
 * The transform converts boolean form to number form so the walker can
 * treat `exclusiveMinimum`/`exclusiveMaximum` uniformly as numbers.

package/dist/openapi/ApiCallbacks.d.mts

@@ -1,4 +1,4 @@
-import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
 import { CallbackInfo } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/ApiLinks.d.mts

@@ -1,4 +1,4 @@
-import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
 import { LinkInfo } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/ApiResponseHeaders.d.mts

@@ -1,4 +1,4 @@
-import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
 import { HeaderInfo } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/ApiSecurity.d.mts

@@ -1,4 +1,4 @@
-import { w as SchemaMeta } from "../types-BrYbjC7_.mjs";
+import { w as SchemaMeta } from "../types-BBQaEPfE.mjs";
 import { SecurityRequirement, SecurityScheme } from "./parser.mjs";
 import { ReactNode } from "react";
 

package/dist/openapi/components.d.mts

@@ -1,7 +1,7 @@
-import { u as FieldOverride, w as SchemaMeta } from "../types-BrYbjC7_.mjs";
-import { r as DiagnosticSink } from "../diagnostics-BTrm3O6J.mjs";
-import { WidgetMap } from "../core/renderer.mjs";
-import { InferParameterOverrides, InferRequestBodyFields, InferResponseFields, OpenAPIRequestBodyType, OpenAPIResponseType } from "../core/typeInference.mjs";
+import { u as FieldOverride, w as SchemaMeta } from "../types-BBQaEPfE.mjs";
+import { r as DiagnosticSink } from "../diagnostics-mftUZI7c.mjs";
+import { d as WidgetMap } from "../renderer-ab9E52Bp.mjs";
+import { a as InferParameterOverrides, l as OpenAPIRequestBodyType, o as InferRequestBodyFields, s as InferResponseFields, u as OpenAPIResponseType } from "../typeInference-Y8tNEQJk.mjs";
 import { ReactNode } from "react";
 
 //#region src/openapi/components.d.ts
@@ -363,7 +363,7 @@ interface ApiResponseProps<Doc = unknown, Path extends PathKeysOf<Doc> = PathKey
  * picked out of `schema` by `path`, `method`, and `status`.
  *
  * Status resolution follows the OpenAPI priority order: concrete code
- * (e.g. `"200"`) > class wildcard (e.g. `"2XX"`) > `"default"`. When
+ * (e.g. `"200"`) \> class wildcard (e.g. `"2XX"`) \> `"default"`. When
  * `schema` is typed `as const`, `fields` autocomplete resolves from
  * the response schema; pass `contentType` to narrow inference to a
  * specific media type.

package/dist/openapi/components.mjs

@@ -286,7 +286,7 @@ function ApiRequestBody({ schema: doc, path, method, value, onChange, meta, fiel
 * picked out of `schema` by `path`, `method`, and `status`.
 *
 * Status resolution follows the OpenAPI priority order: concrete code
-* (e.g. `"200"`) > class wildcard (e.g. `"2XX"`) > `"default"`. When
+* (e.g. `"200"`) \> class wildcard (e.g. `"2XX"`) \> `"default"`. When
 * `schema` is typed `as const`, `fields` autocomplete resolves from
 * the response schema; pass `contentType` to narrow inference to a
 * specific media type.

package/dist/openapi/parser.d.mts

@@ -1,5 +1,5 @@
-import { m as JsonObject } from "../types-BrYbjC7_.mjs";
-import { i as DiagnosticsOptions } from "../diagnostics-BTrm3O6J.mjs";
+import { m as JsonObject } from "../types-BBQaEPfE.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-mftUZI7c.mjs";
 
 //#region src/openapi/parser.d.ts
 /**

package/dist/openapi/resolve.d.mts

@@ -1,4 +1,4 @@
-import { i as DiagnosticsOptions } from "../diagnostics-BTrm3O6J.mjs";
+import { i as DiagnosticsOptions } from "../diagnostics-mftUZI7c.mjs";
 import { OpenApiDocument, OperationInfo, ParameterInfo, RequestBodyInfo, ResponseInfo } from "./parser.mjs";
 
 //#region src/openapi/resolve.d.ts

package/dist/openapi/resolve.mjs

@@ -3,7 +3,7 @@ import "../core/limits.mjs";
 import { emitDiagnostic } from "../core/diagnostics.mjs";
 import { isPrototypePollutingKey } from "../core/uri.mjs";
 import { detectOpenApiVersion } from "../core/version.mjs";
-import { o as normaliseOpenApiSchemas, r as documentContainsKeyword } from "../normalise-DB-Xtjmn.mjs";
+import { o as normaliseOpenApiSchemas, r as documentContainsKeyword } from "../normalise-BkePrJ4v.mjs";
 import { resolveRefChain } from "../core/refChain.mjs";
 import { extractParameters, extractRequestBody, extractResponses, listAllOperations, parseOpenApiDocument } from "./parser.mjs";
 //#region src/openapi/resolve.ts

package/dist/preact/SchemaComponent.d.mts

@@ -0,0 +1,3 @@
+import { a as InferredValue, i as InferredOutputValue, r as InferredInputValue, t as InferFields } from "../inferValue-eAnh50EM.mjs";
+import { a as SchemaProvider, c as registerWidget, i as SchemaFieldProps, n as SchemaComponentProps, r as SchemaField, t as SchemaComponent } from "../SchemaComponent-B__6-5-E.mjs";
+export { type InferFields, type InferredInputValue, type InferredOutputValue, type InferredValue, SchemaComponent, type SchemaComponentProps, SchemaField, type SchemaFieldProps, SchemaProvider, registerWidget };

package/dist/preact/SchemaComponent.mjs

@@ -0,0 +1,26 @@
+import { SchemaComponent, SchemaField, SchemaProvider, registerWidget } from "../react/SchemaComponent.mjs";
+//#region src/preact/SchemaComponent.ts
+/**
+* Preact entry point for `<SchemaComponent>`, `<SchemaProvider>`,
+* `<SchemaField>` and `registerWidget`.
+*
+* Every export below is the React adapter export imported under the
+* same name and re-exported. The Preact entry point works because the
+* consumer aliases `react` to `preact/compat` in their bundler — see
+* the "Preact support" section of the README for the alias config
+* required in Vite, Next.js, and Node consumers. Without the alias,
+* the React imports here resolve to the real React runtime, which
+* defeats the purpose of importing from the Preact entry point.
+*
+* Implementation note: the renderer tree is intentionally identical to
+* the React adapter. `preact/compat` translates React-style `onChange`
+* to `onInput`, matching the "fires on every keystroke" semantics that
+* the controlled inputs in `react/headlessRenderers.tsx` rely on.
+*
+* The `import` + plain `export { ... }` idiom below (rather than
+* `export { ... } from`) is deliberate: the project's lint rules ban
+* `export ... from` outside `index` files, so each binding is brought
+* into local scope before being exported.
+*/
+//#endregion
+export { SchemaComponent, SchemaField, SchemaProvider, registerWidget };

package/dist/preact/SchemaErrorBoundary.d.mts

@@ -0,0 +1,2 @@
+import { SchemaErrorBoundary, SchemaErrorBoundaryProps } from "../react/SchemaErrorBoundary.mjs";
+export { SchemaErrorBoundary, type SchemaErrorBoundaryProps };

package/dist/preact/SchemaErrorBoundary.mjs

@@ -0,0 +1,20 @@
+import { SchemaErrorBoundary } from "../react/SchemaErrorBoundary.mjs";
+//#region src/preact/SchemaErrorBoundary.ts
+/**
+* Preact entry point for `<SchemaErrorBoundary>`.
+*
+* The export is the React adapter export imported under the same name
+* and re-exported. The Preact entry point works because the consumer
+* aliases `react` to `preact/compat` in their bundler — see the
+* "Preact support" section of the README for the alias config required
+* in Vite, Next.js, and Node consumers. The class component relies on
+* `componentDidCatch` / `getDerivedStateFromError`, both of which are
+* provided by `preact/compat`.
+*
+* The `import` + plain `export { ... }` idiom below (rather than
+* `export { ... } from`) is deliberate: the project's lint rules ban
+* `export ... from` outside `index` files, so each binding is brought
+* into local scope before being exported.
+*/
+//#endregion
+export { SchemaErrorBoundary };

package/dist/preact/SchemaView.d.mts

@@ -0,0 +1,2 @@
+import { SchemaView, SchemaViewProps } from "../react/SchemaView.mjs";
+export { SchemaView, type SchemaViewProps };

package/dist/preact/SchemaView.mjs

@@ -0,0 +1,22 @@
+import { SchemaView } from "../react/SchemaView.mjs";
+//#region src/preact/SchemaView.ts
+/**
+* Preact entry point for `<SchemaView>` — the read-only renderer.
+*
+* The export is the React adapter export imported under the same name
+* and re-exported. The Preact entry point works because the consumer
+* aliases `react` to `preact/compat` in their bundler — see the
+* "Preact support" section of the README for the alias config required
+* in Vite, Next.js, and Node consumers.
+*
+* Limitation: React Server Components is React-only. Under Preact,
+* `<SchemaView>` runs as a client component and the zero-client-JS
+* deployment story documented in the React README does not apply.
+*
+* The `import` + plain `export { ... }` idiom below (rather than
+* `export { ... } from`) is deliberate: the project's lint rules ban
+* `export ... from` outside `index` files, so each binding is brought
+* into local scope before being exported.
+*/
+//#endregion
+export { SchemaView };

package/dist/preact/headless.d.mts

@@ -0,0 +1,2 @@
+import { headlessResolver } from "../react/headless.mjs";
+export { headlessResolver };

package/dist/preact/headless.mjs

@@ -0,0 +1,18 @@
+import { headlessResolver } from "../react/headless.mjs";
+//#region src/preact/headless.ts
+/**
+* Preact entry point for the default headless `ComponentResolver`.
+*
+* The export is the React adapter export imported under the same name
+* and re-exported. The Preact entry point works because the consumer
+* aliases `react` to `preact/compat` in their bundler — see the
+* "Preact support" section of the README for the alias config required
+* in Vite, Next.js, and Node consumers.
+*
+* The `import` + plain `export { ... }` idiom below (rather than
+* `export { ... } from`) is deliberate: the project's lint rules ban
+* `export ... from` outside `index` files, so each binding is brought
+* into local scope before being exported.
+*/
+//#endregion
+export { headlessResolver };