schema-components 1.18.0 → 1.19.0

package/dist/openapi/ApiSecurity.mjs

@@ -13,7 +13,7 @@ function ApiSecurity({ requirements, schemes }) {
 						"data-security-name": true,
 						children: req.name
 					}),
-					scheme !== void 0 && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+					scheme !== void 0 && /* @__PURE__ */ jsxs(Fragment, { children: [scheme.type !== void 0 && /* @__PURE__ */ jsx("span", {
 						"data-security-type": true,
 						children: scheme.type
 					}), scheme.description && /* @__PURE__ */ jsx("span", {

package/dist/openapi/bundle.mjs

@@ -88,6 +88,7 @@ async function walkAndInline(node, schemasNode, uriCache, inlineCache, resolver)
 			}
 			if (inlinedName !== void 0) node.$ref = `#/components/schemas/${inlinedName}`;
 		}
+		return;
 	}
 	for (const value of Object.values(node)) if (isObject(value)) await walkAndInline(value, schemasNode, uriCache, inlineCache, resolver);
 	else if (Array.isArray(value)) for (const item of value) await walkAndInline(item, schemasNode, uriCache, inlineCache, resolver);

package/dist/openapi/components.mjs

@@ -1,14 +1,14 @@
 import { isObject, toRecordOrUndefined } from "../core/guards.mjs";
 import { walk } from "../core/walker.mjs";
-import { joinPath, renderField, sanitisePrefix } from "../react/SchemaComponent.mjs";
 import { ApiCallbacks } from "./ApiCallbacks.mjs";
 import { ApiLinks } from "./ApiLinks.mjs";
 import { ApiResponseHeaders } from "./ApiResponseHeaders.mjs";
 import { ApiSecurity } from "./ApiSecurity.mjs";
 import { getLinks, getSecurityRequirements, getSecuritySchemes, listCallbacks } from "./parser.mjs";
+import { joinPath, renderField, sanitisePrefix } from "../react/SchemaComponent.mjs";
 import { getParsed, resolveOperation, resolveParameters, resolveRequestBody, resolveResponse, toDoc } from "./resolve.mjs";
-import { useId } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useId } from "react";
 //#region src/openapi/components.tsx
 /**
 * OpenAPI React components with type-safe generics.
@@ -184,6 +184,10 @@ function OperationHeader({ operation }) {
 			operation.path
 		] }),
 		operation.summary && /* @__PURE__ */ jsx("p", { children: operation.summary }),
+		operation.description && /* @__PURE__ */ jsx("p", {
+			"data-description": true,
+			children: operation.description
+		}),
 		operation.deprecated && /* @__PURE__ */ jsx("span", {
 			"data-deprecated": true,
 			children: "Deprecated"

package/dist/openapi/parser.d.mts

@@ -41,7 +41,7 @@ interface SecurityRequirement {
   scopes: string[];
 }
 interface SecurityScheme {
-  type: string;
+  type: string | undefined;
   description: string | undefined;
   name: string | undefined;
   location: string | undefined;
@@ -92,7 +92,7 @@ declare function getRequestBody(parsed: OpenApiDocument, path: string, method: s
 declare function getResponses(parsed: OpenApiDocument, path: string, method: string): ResponseInfo[];
 declare function getSecurityRequirements(parsed: OpenApiDocument, path: string, method: string): SecurityRequirement[];
 declare function getSecuritySchemes(parsed: OpenApiDocument): Map<string, SecurityScheme>;
-declare function getResponseHeaders(response: JsonObject): Map<string, HeaderInfo>;
+declare function getResponseHeaders(response: JsonObject, doc?: JsonObject): Map<string, HeaderInfo>;
 declare function listWebhooks(parsed: OpenApiDocument): WebhookInfo[];
 declare function getExternalDocs(obj: JsonObject): ExternalDocs | undefined;
 declare function getXmlInfo(schema: JsonObject): XmlInfo | undefined;

package/dist/openapi/parser.mjs

@@ -33,7 +33,10 @@ const METHODS = [
 	"post",
 	"put",
 	"patch",
-	"delete"
+	"delete",
+	"head",
+	"options",
+	"trace"
 ];
 /**
 * Resolve a path item, following a `$ref` to `components/pathItems/<Name>`
@@ -143,7 +146,7 @@ function getResponses(parsed, path, method) {
 		const content = getProperty(response, "content");
 		const contentTypes = isObject(content) ? Object.keys(content) : [];
 		const schema = isObject(content) ? extractSchemaFromContent(content) : void 0;
-		const headers = getResponseHeaders(response);
+		const headers = getResponseHeaders(response, parsed.doc);
 		result.push({
 			statusCode,
 			description: getString(response, "description"),
@@ -196,7 +199,7 @@ function getSecuritySchemes(parsed) {
 		if (!isObject(scheme)) continue;
 		const flowsProp = getProperty(scheme, "flows");
 		result.set(name, {
-			type: getString(scheme, "type") ?? "",
+			type: getString(scheme, "type"),
 			description: getString(scheme, "description"),
 			name: getString(scheme, "name"),
 			location: getString(scheme, "in"),
@@ -208,14 +211,14 @@ function getSecuritySchemes(parsed) {
 	}
 	return result;
 }
-function getResponseHeaders(response) {
+function getResponseHeaders(response, doc) {
 	const result = /* @__PURE__ */ new Map();
 	const headers = getProperty(response, "headers");
 	if (!isObject(headers)) return result;
 	for (const [name, headerObj] of Object.entries(headers)) {
 		if (!isObject(headerObj)) continue;
 		const ref = getString(headerObj, "$ref");
-		const header = (ref !== void 0 ? resolveRefInDoc(headerObj, ref) : void 0) ?? headerObj;
+		const header = (ref !== void 0 && doc !== void 0 ? resolveRefInDoc(doc, ref) : void 0) ?? headerObj;
 		const schemaProp = getProperty(header, "schema");
 		result.set(name, {
 			name,

package/dist/openapi/resolve.d.mts

@@ -7,11 +7,12 @@ import { OpenApiDocument, OperationInfo, ParameterInfo, ResponseInfo, getRequest
  *
  * Before parsing, the document is run through the version-aware
  * normalisation pipeline (`normaliseOpenApiSchemas`) so OpenAPI 3.0.x
- * keywords (`nullable`, `discriminator`, `example`) and Swagger 2.0
- * documents are converted to canonical Draft 2020-12 form. The parser
- * and downstream extractors (`getRequestBody`, `getResponses`, etc.) then
- * observe schemas in the same form `<SchemaComponent>` does, keeping the
- * OpenAPI components on the same pipeline as the top-level adapter.
+ * keywords (`nullable`, `discriminator`, `example`), OpenAPI 3.1.x
+ * `discriminator`, and Swagger 2.0 documents are all converted to
+ * canonical Draft 2020-12 form. The parser and downstream extractors
+ * (`getRequestBody`, `getResponses`, etc.) then observe schemas in the
+ * same form `<SchemaComponent>` does, keeping the OpenAPI components on
+ * the same pipeline as the top-level adapter.
  *
  * The cache is keyed by the caller-supplied document so subsequent calls
  * with the same input bypass both normalisation and parsing.

package/dist/openapi/resolve.mjs

@@ -1,6 +1,6 @@
 import { isObject } from "../core/guards.mjs";
 import { detectOpenApiVersion } from "../core/version.mjs";
-import { i as normaliseOpenApiSchemas } from "../normalise-tL9FckAk.mjs";
+import { a as normaliseOpenApiSchemas } from "../normalise-C0ofw3W6.mjs";
 import { getParameters, getRequestBody, getResponses, listOperations, parseOpenApiDocument } from "./parser.mjs";
 //#region src/openapi/resolve.ts
 /**
@@ -17,11 +17,12 @@ const docCache = /* @__PURE__ */ new WeakMap();
 *
 * Before parsing, the document is run through the version-aware
 * normalisation pipeline (`normaliseOpenApiSchemas`) so OpenAPI 3.0.x
-* keywords (`nullable`, `discriminator`, `example`) and Swagger 2.0
-* documents are converted to canonical Draft 2020-12 form. The parser
-* and downstream extractors (`getRequestBody`, `getResponses`, etc.) then
-* observe schemas in the same form `<SchemaComponent>` does, keeping the
-* OpenAPI components on the same pipeline as the top-level adapter.
+* keywords (`nullable`, `discriminator`, `example`), OpenAPI 3.1.x
+* `discriminator`, and Swagger 2.0 documents are all converted to
+* canonical Draft 2020-12 form. The parser and downstream extractors
+* (`getRequestBody`, `getResponses`, etc.) then observe schemas in the
+* same form `<SchemaComponent>` does, keeping the OpenAPI components on
+* the same pipeline as the top-level adapter.
 *
 * The cache is keyed by the caller-supplied document so subsequent calls
 * with the same input bypass both normalisation and parsing.

package/dist/react/SchemaComponent.d.mts

@@ -1,11 +1,11 @@
 import { M as WalkedField, T as SchemaMeta, d as FieldOverrides, u as FieldOverride } from "../types-D_5ST7SS.mjs";
-import { t as Diagnostic } from "../diagnostics-BYk63jsC.mjs";
-import { t as SchemaError } from "../errors-C5zRC2PU.mjs";
-import { l as RenderProps, r as ComponentResolver } from "../renderer-DXo-rXHJ.mjs";
+import { t as Diagnostic } from "../diagnostics-VgEKI_Ct.mjs";
+import { t as SchemaError } from "../errors-CnGjT1cg.mjs";
+import { l as RenderProps, r as ComponentResolver } from "../renderer-BQqiXUYP.mjs";
 import { c as PathOfType, l as ResolveOpenAPIRef, n as FromJSONSchema } from "../typeInference-5JiqIZ8t.mjs";
 import { z } from "zod";
-import { ReactNode } from "react";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+import { ReactNode } from "react";
 
 //#region src/react/SchemaComponent.d.ts
 /**

package/dist/react/SchemaComponent.mjs

@@ -7,8 +7,8 @@ import { walk } from "../core/walker.mjs";
 import { headlessResolver } from "./headless.mjs";
 import { resolvePath, resolveValue, setNestedValue } from "./fieldPath.mjs";
 import { z } from "zod";
-import { createContext, isValidElement, useCallback, useContext, useId, useMemo } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
+import { createContext, isValidElement, useCallback, useContext, useId, useMemo } from "react";
 //#region src/react/SchemaComponent.tsx
 /**
 * <SchemaComponent> — renders UI from Zod, JSON Schema, or OpenAPI schemas.
@@ -78,7 +78,7 @@ function SchemaComponent({ schema: schemaInput, ref: refInput, value, onChange,
 		rootMeta = normalised.rootMeta;
 		rootDocument = normalised.rootDocument;
 	} catch (err) {
-		const error = new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schemaInput, detectNormalisationKind(err));
+		const error = err instanceof SchemaNormalisationError ? err : new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schemaInput, "unknown");
 		if (onError !== void 0) {
 			onError(error);
 			return null;
@@ -218,7 +218,8 @@ function SchemaField({ path, schema: schemaInput, ref: refInput, value, onChange
 		rootMeta = normalised.rootMeta;
 		rootDocument = normalised.rootDocument;
 	} catch (err) {
-		throw new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schemaInput, detectNormalisationKind(err));
+		if (err instanceof SchemaNormalisationError) throw err;
+		throw new SchemaNormalisationError(err instanceof Error ? err.message : "Failed to normalise schema", schemaInput, "unknown");
 	}
 	const fieldTree = resolvePath(walk(jsonSchema, {
 		componentMeta: fieldMeta,
@@ -284,16 +285,5 @@ function isFieldErrorCallback(value) {
 function isCallable(value) {
 	return typeof value === "function";
 }
-function detectNormalisationKind(err) {
-	if (err instanceof Error) {
-		const msg = err.message;
-		if (msg.includes("Zod 3")) return "zod3-unsupported";
-		if (msg.includes("Invalid Zod 4")) return "invalid-zod";
-		if (msg.includes("OpenAPI ref not found")) return "openapi-missing-ref";
-		if (msg.includes("OpenAPI")) return "openapi-invalid";
-		if (msg.includes("JSON Schema")) return "invalid-json-schema";
-	}
-	return "unknown";
-}
 //#endregion
 export { ROOT_PATH, SchemaComponent, SchemaField, SchemaProvider, joinPath, registerWidget, renderField, sanitisePrefix };

package/dist/react/SchemaView.d.mts

@@ -1,6 +1,6 @@
 import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
-import { t as Diagnostic } from "../diagnostics-BYk63jsC.mjs";
-import { r as ComponentResolver } from "../renderer-DXo-rXHJ.mjs";
+import { t as Diagnostic } from "../diagnostics-VgEKI_Ct.mjs";
+import { r as ComponentResolver } from "../renderer-BQqiXUYP.mjs";
 import { WidgetMap } from "./SchemaComponent.mjs";
 import { ReactNode } from "react";
 

package/dist/react/SchemaView.mjs

@@ -4,8 +4,8 @@ import { buildRenderProps, getRenderFunction, mergeResolvers } from "../core/ren
 import { walk } from "../core/walker.mjs";
 import { headlessResolver } from "./headless.mjs";
 import { joinPath, sanitisePrefix } from "./SchemaComponent.mjs";
-import { createElement, isValidElement, useId } from "react";
 import { jsx } from "react/jsx-runtime";
+import { createElement, isValidElement, useId } from "react";
 //#region src/react/SchemaView.tsx
 /**
 * React Server Component for read-only schema rendering.
@@ -62,6 +62,7 @@ function SchemaView({ schema: schemaInput, ref: refInput, value, fields, meta: c
 		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", schemaInput, "unknown");
 	}
 	const walkOptions = {

package/dist/react/headless.d.mts

@@ -1,10 +1,16 @@
-import { r as ComponentResolver } from "../renderer-DXo-rXHJ.mjs";
+import { r as ComponentResolver } from "../renderer-BQqiXUYP.mjs";
 
 //#region src/react/headless.d.ts
 /**
  * The headless resolver uses props.renderChild for recursive rendering.
  * No factory function needed — the renderChild is always available
  * on RenderProps.
+ *
+ * Every WalkedField variant the walker can emit has a registered renderer.
+ * Missing a registration causes `getRenderFunction` to return `undefined`
+ * and the field to render as nothing — silent invisibility. The
+ * `ComponentResolver` interface keeps each key optional for theme
+ * adapters, so the registration here is the single source of completeness.
  */
 declare const headlessResolver: ComponentResolver;
 //#endregion

package/dist/react/headless.mjs

@@ -1,22 +1,34 @@
-import { renderArray, renderBoolean, renderDiscriminatedUnion, renderEnum, renderFile, renderNumber, renderObject, renderRecord, renderRecursive, renderString, renderUnion, renderUnknown } from "./headlessRenderers.mjs";
+import { renderArray, renderBoolean, renderConditional, renderDiscriminatedUnion, renderEnum, renderFile, renderLiteral, renderNegation, renderNever, renderNull, renderNumber, renderObject, renderRecord, renderRecursive, renderString, renderTuple, renderUnion, renderUnknown } from "./headlessRenderers.mjs";
 //#region src/react/headless.tsx
 /**
 * The headless resolver uses props.renderChild for recursive rendering.
 * No factory function needed — the renderChild is always available
 * on RenderProps.
+*
+* Every WalkedField variant the walker can emit has a registered renderer.
+* Missing a registration causes `getRenderFunction` to return `undefined`
+* and the field to render as nothing — silent invisibility. The
+* `ComponentResolver` interface keeps each key optional for theme
+* adapters, so the registration here is the single source of completeness.
 */
 const headlessResolver = {
 	string: renderString,
 	number: renderNumber,
 	boolean: renderBoolean,
+	null: renderNull,
 	enum: renderEnum,
 	object: renderObject,
 	record: renderRecord,
 	array: renderArray,
+	tuple: renderTuple,
 	union: renderUnion,
 	discriminatedUnion: renderDiscriminatedUnion,
+	conditional: renderConditional,
+	negation: renderNegation,
+	literal: renderLiteral,
 	file: renderFile,
 	recursive: renderRecursive,
+	never: renderNever,
 	unknown: renderUnknown
 };
 //#endregion

package/dist/react/headlessRenderers.d.mts

@@ -1,5 +1,5 @@
 import { M as WalkedField } from "../types-D_5ST7SS.mjs";
-import { l as RenderProps } from "../renderer-DXo-rXHJ.mjs";
+import { l as RenderProps } from "../renderer-BQqiXUYP.mjs";
 import { ReactNode } from "react";
 
 //#region src/react/headlessRenderers.d.ts
@@ -57,6 +57,57 @@ declare function renderDiscriminatedUnion(props: RenderProps): ReactNode;
 declare function discriminatedUnionValueForTab(optionLabels: readonly string[], discKey: string, newIndex: number): Record<string, string> | undefined;
 declare function renderFile(props: RenderProps): ReactNode;
 declare function renderRecursive(props: RenderProps): ReactNode;
+/**
+ * Render a literal field — `z.literal("a")` or `{ const: 5 }`.
+ *
+ * Literals are non-editable by nature (the value is fixed at the schema
+ * level), so both read-only and editable modes display the literal value(s).
+ * Multiple literals (`z.literal(["a", "b"])`) render comma-separated.
+ */
+declare function renderLiteral(props: RenderProps): ReactNode;
+/**
+ * Render a null field — `z.null()` or `{ type: "null" }`.
+ *
+ * The only valid value is `null`, so render an em-dash placeholder
+ * regardless of mode. There is nothing the user can usefully change.
+ */
+declare function renderNull(props: RenderProps): ReactNode;
+/**
+ * Render a never field — `z.never()` or `{ not: {} }` / `false` schema.
+ *
+ * `never` indicates a position that cannot hold any value. We render a
+ * visible placeholder rather than throwing because some valid schemas
+ * intentionally contain `never` branches (e.g. exhaustive discriminated
+ * unions), and a runtime crash on render would be worse than a visible
+ * indicator.
+ */
+declare function renderNever(props: RenderProps): ReactNode;
+/**
+ * Render a tuple field — `z.tuple([z.string(), z.number()])` or
+ * `{ prefixItems: [...] }`.
+ *
+ * Positional rendering: each `prefixItems` entry is rendered at its index.
+ * The structural index (e.g. `[0]`) is passed as the path suffix so
+ * children get unique ids and labels.
+ */
+declare function renderTuple(props: RenderProps): ReactNode;
+/**
+ * Render a conditional field — JSON Schema `if`/`then`/`else`.
+ *
+ * Conditional schemas describe constraints rather than a single value
+ * shape, so the renderer surfaces each clause as a labelled fieldset.
+ * This mirrors the HTML renderer's annotation approach and gives a
+ * predictable structure for theme adapters that want to override it.
+ */
+declare function renderConditional(props: RenderProps): ReactNode;
+/**
+ * Render a negation field — JSON Schema `{ not: { ... } }`.
+ *
+ * Negation describes a constraint ("value must NOT match this schema")
+ * rather than a value shape. The renderer surfaces the negated schema
+ * beneath an explanatory preamble.
+ */
+declare function renderNegation(props: RenderProps): ReactNode;
 declare function renderUnknown(props: RenderProps): ReactNode;
 //#endregion
-export { defaultRecordValue, discriminatedUnionValueForTab, inputId, nextRecordKey, renameRecordKey, renderArray, renderBoolean, renderDiscriminatedUnion, renderEnum, renderFile, renderNumber, renderObject, renderRecord, renderRecursive, renderString, renderUnion, renderUnknown, toReactNode };
+export { defaultRecordValue, discriminatedUnionValueForTab, inputId, nextRecordKey, renameRecordKey, renderArray, renderBoolean, renderConditional, renderDiscriminatedUnion, renderEnum, renderFile, renderLiteral, renderNegation, renderNever, renderNull, renderNumber, renderObject, renderRecord, renderRecursive, renderString, renderTuple, renderUnion, renderUnknown, toReactNode };