schema-components 1.12.11 → 1.14.0

package/dist/openapi/ApiCallbacks.d.mts

@@ -0,0 +1,16 @@
+import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { CallbackInfo } from "./parser.mjs";
+import { ReactNode } from "react";
+
+//#region src/openapi/ApiCallbacks.d.ts
+interface ApiCallbacksProps {
+  /** Callback definitions for this operation. */
+  callbacks: CallbackInfo[];
+  /** Optional meta overrides. */
+  meta?: SchemaMeta;
+}
+declare function ApiCallbacks({
+  callbacks
+}: ApiCallbacksProps): ReactNode;
+//#endregion
+export { ApiCallbacks, ApiCallbacksProps };

package/dist/openapi/ApiCallbacks.mjs

@@ -0,0 +1,34 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/openapi/ApiCallbacks.tsx
+function ApiCallbacks({ callbacks }) {
+	if (callbacks.length === 0) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		"data-callbacks": true,
+		children: [/* @__PURE__ */ jsx("h4", { children: "Callbacks" }), callbacks.map((callback) => /* @__PURE__ */ jsxs("div", {
+			"data-callback": callback.name,
+			children: [/* @__PURE__ */ jsx("span", {
+				"data-callback-name": true,
+				children: callback.name
+			}), callback.operations.map((op) => /* @__PURE__ */ jsxs("div", {
+				"data-callback-operation": true,
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						"data-callback-method": true,
+						children: op.method.toUpperCase()
+					}),
+					" ",
+					/* @__PURE__ */ jsx("span", {
+						"data-callback-path": true,
+						children: op.path
+					}),
+					op.summary && /* @__PURE__ */ jsx("span", {
+						"data-callback-summary": true,
+						children: op.summary
+					})
+				]
+			}, `${op.method}-${op.path}`))]
+		}, callback.name))]
+	});
+}
+//#endregion
+export { ApiCallbacks };

package/dist/openapi/ApiLinks.d.mts

@@ -0,0 +1,16 @@
+import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { LinkInfo } from "./parser.mjs";
+import { ReactNode } from "react";
+
+//#region src/openapi/ApiLinks.d.ts
+interface ApiLinksProps {
+  /** Link definitions for a response. */
+  links: LinkInfo[];
+  /** Optional meta overrides. */
+  meta?: SchemaMeta;
+}
+declare function ApiLinks({
+  links
+}: ApiLinksProps): ReactNode;
+//#endregion
+export { ApiLinks, ApiLinksProps };

package/dist/openapi/ApiLinks.mjs

@@ -0,0 +1,42 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/openapi/ApiLinks.tsx
+function ApiLinks({ links }) {
+	if (links.length === 0) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		"data-links": true,
+		children: [/* @__PURE__ */ jsx("h4", { children: "Links" }), links.map((link) => /* @__PURE__ */ jsxs("div", {
+			"data-link": link.name,
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					"data-link-name": true,
+					children: link.name
+				}),
+				link.operationId && /* @__PURE__ */ jsx("span", {
+					"data-link-operation-id": true,
+					children: link.operationId
+				}),
+				link.operationRef && /* @__PURE__ */ jsx("span", {
+					"data-link-operation-ref": true,
+					children: link.operationRef
+				}),
+				link.description && /* @__PURE__ */ jsx("span", {
+					"data-link-description": true,
+					children: link.description
+				}),
+				link.parameters.size > 0 && /* @__PURE__ */ jsx("dl", {
+					"data-link-parameters": true,
+					children: [...link.parameters.entries()].map(([paramName, paramValue]) => /* @__PURE__ */ jsxs("span", {
+						"data-link-parameter": paramName,
+						children: [
+							paramName,
+							": ",
+							paramValue
+						]
+					}, paramName))
+				})
+			]
+		}, link.name))]
+	});
+}
+//#endregion
+export { ApiLinks };

package/dist/openapi/ApiResponseHeaders.d.mts

@@ -0,0 +1,16 @@
+import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { HeaderInfo } from "./parser.mjs";
+import { ReactNode } from "react";
+
+//#region src/openapi/ApiResponseHeaders.d.ts
+interface ApiResponseHeadersProps {
+  /** Header definitions for a response. */
+  headers: Map<string, HeaderInfo>;
+  /** Optional meta overrides. */
+  meta?: SchemaMeta;
+}
+declare function ApiResponseHeaders({
+  headers
+}: ApiResponseHeadersProps): ReactNode;
+//#endregion
+export { ApiResponseHeaders, ApiResponseHeadersProps };

package/dist/openapi/ApiResponseHeaders.mjs

@@ -0,0 +1,35 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/openapi/ApiResponseHeaders.tsx
+function ApiResponseHeaders({ headers }) {
+	if (headers.size === 0) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		"data-response-headers": true,
+		children: [/* @__PURE__ */ jsx("h5", { children: "Headers" }), [...headers.entries()].map(([name, header]) => /* @__PURE__ */ jsxs("div", {
+			"data-header": name,
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					"data-header-name": true,
+					children: name
+				}),
+				header.description && /* @__PURE__ */ jsx("span", {
+					"data-header-description": true,
+					children: header.description
+				}),
+				header.required && /* @__PURE__ */ jsx("span", {
+					"data-required": true,
+					children: "*"
+				}),
+				header.deprecated && /* @__PURE__ */ jsx("span", {
+					"data-deprecated": true,
+					children: "Deprecated"
+				}),
+				header.schema !== void 0 && "type" in header.schema && typeof header.schema.type === "string" ? /* @__PURE__ */ jsx("span", {
+					"data-header-type": true,
+					children: header.schema.type
+				}) : void 0
+			]
+		}, name))]
+	});
+}
+//#endregion
+export { ApiResponseHeaders };

package/dist/openapi/ApiSecurity.d.mts

@@ -0,0 +1,19 @@
+import { T as SchemaMeta } from "../types-D_5ST7SS.mjs";
+import { SecurityRequirement, SecurityScheme } from "./parser.mjs";
+import { ReactNode } from "react";
+
+//#region src/openapi/ApiSecurity.d.ts
+interface ApiSecurityProps {
+  /** Security requirements for this operation. */
+  requirements: SecurityRequirement[];
+  /** Security schemes from the document's components. */
+  schemes: Map<string, SecurityScheme>;
+  /** Optional meta overrides. */
+  meta?: SchemaMeta;
+}
+declare function ApiSecurity({
+  requirements,
+  schemes
+}: ApiSecurityProps): ReactNode;
+//#endregion
+export { ApiSecurity, ApiSecurityProps };

package/dist/openapi/ApiSecurity.mjs

@@ -0,0 +1,33 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/openapi/ApiSecurity.tsx
+function ApiSecurity({ requirements, schemes }) {
+	if (requirements.length === 0) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		"data-security": true,
+		children: [/* @__PURE__ */ jsx("h4", { children: "Security" }), requirements.map((req, index) => {
+			const scheme = schemes.get(req.name);
+			return /* @__PURE__ */ jsxs("div", {
+				"data-security-scheme": req.name,
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						"data-security-name": true,
+						children: req.name
+					}),
+					scheme !== void 0 && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
+						"data-security-type": true,
+						children: scheme.type
+					}), scheme.description && /* @__PURE__ */ jsx("span", {
+						"data-security-description": true,
+						children: scheme.description
+					})] }),
+					req.scopes.length > 0 && /* @__PURE__ */ jsx("span", {
+						"data-security-scopes": true,
+						children: req.scopes.join(", ")
+					})
+				]
+			}, `${req.name}-${String(index)}`);
+		})]
+	});
+}
+//#endregion
+export { ApiSecurity };

package/dist/openapi/bundle.d.mts

@@ -0,0 +1,47 @@
+//#region src/openapi/bundle.d.ts
+/**
+ * OpenAPI document bundler — inlines external $ref files.
+ *
+ * Walks all `$ref` strings in an OpenAPI document, fetches external
+ * documents via a user-provided resolver, inlines their schemas into
+ * `components.schemas` with synthesised names, and rewrites the refs
+ * to point to the inlined copies.
+ *
+ * This is an opt-in async pre-step. The synchronous core API is unchanged;
+ * consumers call `bundleOpenApiDoc` once before rendering.
+ *
+ * Usage:
+ * ```ts
+ * import { bundleOpenApiDoc } from "schema-components/openapi/bundle";
+ *
+ * const resolver = async (uri: string) => {
+ *     const response = await fetch(uri);
+ *     return response.json();
+ * };
+ *
+ * const bundled = await bundleOpenApiDoc(doc, resolver);
+ * // Now pass bundled to SchemaComponent / ApiOperation
+ * ```
+ */
+/**
+ * Resolver function for external documents.
+ * Called with the URI portion of an external $ref (everything before `#`).
+ * Returns the parsed JSON document.
+ */
+type BundleResolver = (uri: string) => unknown;
+/**
+ * Bundle an OpenAPI document by inlining all external $ref targets.
+ *
+ * Walks every $ref in the document. For external refs (not starting with `#`),
+ * calls the resolver to fetch the external document, extracts the referenced
+ * schema, inlines it into `components.schemas` with a synthesised name, and
+ * rewrites the $ref to point to the inlined copy.
+ *
+ * The resolver is called once per unique URI and the result is cached.
+ *
+ * Returns a deep-cloned document with all external refs resolved.
+ * The original document is never mutated.
+ */
+declare function bundleOpenApiDoc(doc: Record<string, unknown>, resolver: BundleResolver): Promise<Record<string, unknown>>;
+//#endregion
+export { BundleResolver, bundleOpenApiDoc };

package/dist/openapi/bundle.mjs

@@ -0,0 +1,95 @@
+import { isObject } from "../core/guards.mjs";
+//#region src/openapi/bundle.ts
+/**
+* OpenAPI document bundler — inlines external $ref files.
+*
+* Walks all `$ref` strings in an OpenAPI document, fetches external
+* documents via a user-provided resolver, inlines their schemas into
+* `components.schemas` with synthesised names, and rewrites the refs
+* to point to the inlined copies.
+*
+* This is an opt-in async pre-step. The synchronous core API is unchanged;
+* consumers call `bundleOpenApiDoc` once before rendering.
+*
+* Usage:
+* ```ts
+* import { bundleOpenApiDoc } from "schema-components/openapi/bundle";
+*
+* const resolver = async (uri: string) => {
+*     const response = await fetch(uri);
+*     return response.json();
+* };
+*
+* const bundled = await bundleOpenApiDoc(doc, resolver);
+* // Now pass bundled to SchemaComponent / ApiOperation
+* ```
+*/
+/**
+* Bundle an OpenAPI document by inlining all external $ref targets.
+*
+* Walks every $ref in the document. For external refs (not starting with `#`),
+* calls the resolver to fetch the external document, extracts the referenced
+* schema, inlines it into `components.schemas` with a synthesised name, and
+* rewrites the $ref to point to the inlined copy.
+*
+* The resolver is called once per unique URI and the result is cached.
+*
+* Returns a deep-cloned document with all external refs resolved.
+* The original document is never mutated.
+*/
+async function bundleOpenApiDoc(doc, resolver) {
+	const result = structuredClone(doc);
+	const uriCache = /* @__PURE__ */ new Map();
+	if (!isObject(result.components)) result.components = {};
+	if (!isObject(result.components)) result.components = {};
+	if (isObject(result.components) && !isObject(result.components.schemas)) result.components.schemas = {};
+	await walkAndInline(result, uriCache, resolver);
+	return result;
+}
+/**
+* Walk a document tree, find external $ref strings, resolve them,
+* inline the targets, and rewrite the refs.
+*/
+async function walkAndInline(node, uriCache, resolver) {
+	if (!isObject(node)) return;
+	if (typeof node.$ref === "string" && !node.$ref.startsWith("#")) {
+		const ref = node.$ref;
+		const hashIndex = ref.indexOf("#");
+		const uri = hashIndex >= 0 ? ref.slice(0, hashIndex) : ref;
+		const fragment = hashIndex >= 0 ? ref.slice(hashIndex) : "#";
+		let externalDoc = uriCache.get(uri);
+		if (externalDoc === void 0) {
+			const resolved = await resolver(uri);
+			if (isObject(resolved)) {
+				externalDoc = resolved;
+				uriCache.set(uri, externalDoc);
+			}
+		}
+		if (externalDoc !== void 0) {
+			const target = resolveFragment(externalDoc, fragment);
+			if (isObject(target)) {
+				delete node.$ref;
+				for (const [key, value] of Object.entries(target)) node[key] = value;
+			}
+		}
+	}
+	for (const value of Object.values(node)) if (isObject(value)) await walkAndInline(value, uriCache, resolver);
+	else if (Array.isArray(value)) for (const item of value) await walkAndInline(item, uriCache, resolver);
+}
+/**
+* Resolve a JSON Pointer fragment within a document.
+*/
+function resolveFragment(doc, fragment) {
+	if (fragment === "#" || fragment === "") return doc;
+	if (!fragment.startsWith("#/")) return void 0;
+	const parts = fragment.slice(2).split("/");
+	let current = doc;
+	for (const part of parts) {
+		if (!isObject(current)) return void 0;
+		const decoded = part.replace(/~1/g, "/").replace(/~0/g, "~");
+		current = current[decoded];
+	}
+	return isObject(current) ? current : void 0;
+}
+//#endregion
+export { bundleOpenApiDoc };

package/dist/openapi/components.d.mts

@@ -1,4 +1,5 @@
-import { c as InferResponseFields, m as SchemaMeta, o as InferParameterOverrides, r as FieldOverride, s as InferRequestBodyFields } from "../types-BJzEgJdX.mjs";
+import { T as SchemaMeta, u as FieldOverride } from "../types-D_5ST7SS.mjs";
+import { i as InferResponseFields, n as InferParameterOverrides, r as InferRequestBodyFields, u as UnsafeFields } from "../typeInference-k7FXfTVO.mjs";
 import { WidgetMap } from "../react/SchemaComponent.mjs";
 import { ReactNode } from "react";
 
@@ -12,6 +13,11 @@ interface ApiOperationProps<Doc = unknown, Path extends string = string, Method
   responseValue?: unknown;
   meta?: SchemaMeta;
   requestBodyFields?: Doc extends Record<string, unknown> ? InferRequestBodyFields<Doc, Path, Method> : Record<string, FieldOverride>;
+  /** Escape hatch for recursive schemas where type-level inference fails.
+   * Typed as Record<string, FieldOverride> — use when the schema contains
+   * deeply nested $ref chains.
+   */
+  unsafeFields?: UnsafeFields;
   /** Instance-scoped widgets. */
   widgets?: WidgetMap;
 }

package/dist/openapi/components.mjs

@@ -1,9 +1,14 @@
 import { toRecordOrUndefined } from "../core/guards.mjs";
-import { normaliseSchema } from "../core/adapter.mjs";
 import { SchemaNormalisationError } from "../core/errors.mjs";
+import { normaliseSchema } from "../core/adapter.mjs";
 import { walk } from "../core/walker.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 { renderField } from "../react/SchemaComponent.mjs";
-import { resolveOperation, resolveParameters, resolveRequestBody, resolveResponse, toDoc } from "./resolve.mjs";
+import { getParsed, resolveOperation, resolveParameters, resolveRequestBody, resolveResponse, toDoc } from "./resolve.mjs";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 //#region src/openapi/components.tsx
 function noop() {}
@@ -33,10 +38,19 @@ function renderSchema(schema, rootDocument, options) {
 function ApiOperation({ schema: doc, path, method, requestBodyValue, onRequestBodyChange, responseValue, meta, requestBodyFields, widgets }) {
 	const rootDoc = toDoc(doc);
 	const resolved = resolveOperation(rootDoc, path, method);
+	const parsed = getParsed(rootDoc);
+	const securityReqs = getSecurityRequirements(parsed, path, method);
+	const securitySchemes = getSecuritySchemes(parsed);
+	const callbacks = listCallbacks(parsed, path, method);
 	return /* @__PURE__ */ jsxs("section", {
 		"data-operation": `${method.toUpperCase()} ${path}`,
 		children: [
 			/* @__PURE__ */ jsx(OperationHeader, { operation: resolved.operation }),
+			/* @__PURE__ */ jsx(ApiSecurity, {
+				requirements: securityReqs,
+				schemes: securitySchemes
+			}),
+			/* @__PURE__ */ jsx(ApiCallbacks, { callbacks }),
 			resolved.parameters.length > 0 && /* @__PURE__ */ jsxs("section", {
 				"data-parameters": true,
 				children: [/* @__PURE__ */ jsx("h4", { children: "Parameters" }), /* @__PURE__ */ jsx(ParameterList, {
@@ -74,7 +88,9 @@ function ApiOperation({ schema: doc, path, method, requestBodyValue, onRequestBo
 					rootDoc,
 					value: responseValue,
 					meta,
-					widgets
+					widgets,
+					path,
+					method
 				}, response.statusCode))]
 			})
 		]
@@ -138,7 +154,9 @@ function ApiResponse({ schema: doc, path, method, status, value, meta, fields, w
 		value,
 		fields,
 		meta,
-		widgets
+		widgets,
+		path,
+		method
 	});
 }
 function OperationHeader({ operation }) {
@@ -174,7 +192,7 @@ function ParameterList({ parameters, rootDoc, overrides, meta, widgets }) {
 		]
 	}, param.name)) });
 }
-function ResponseCard({ response, rootDoc, value, fields, meta, widgets }) {
+function ResponseCard({ response, rootDoc, value, fields, meta, widgets, path, method }) {
 	if (response.schema === void 0) return /* @__PURE__ */ jsxs("div", {
 		"data-status": response.statusCode,
 		children: [
@@ -183,6 +201,10 @@ function ResponseCard({ response, rootDoc, value, fields, meta, widgets }) {
 			/* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx("em", { children: "No schema" }) })
 		]
 	});
+	let links = [];
+	if (path !== void 0 && method !== void 0) try {
+		links = getLinks(getParsed(rootDoc), path, method, response.statusCode);
+	} catch {}
 	return /* @__PURE__ */ jsxs("div", {
 		"data-status": response.statusCode,
 		children: [
@@ -196,7 +218,9 @@ function ResponseCard({ response, rootDoc, value, fields, meta, widgets }) {
 					...meta
 				},
 				widgets
-			})
+			}),
+			/* @__PURE__ */ jsx(ApiResponseHeaders, { headers: response.headers }),
+			/* @__PURE__ */ jsx(ApiLinks, { links })
 		]
 	});
 }

package/dist/openapi/parser.d.mts

@@ -1,4 +1,4 @@
-import { l as JsonObject } from "../types-BJzEgJdX.mjs";
+import { m as JsonObject } from "../types-D_5ST7SS.mjs";
 
 //#region src/openapi/parser.d.ts
 interface OpenApiDocument {
@@ -28,6 +28,7 @@ interface ResponseInfo {
   description: string | undefined;
   contentTypes: string[];
   schema: JsonObject | undefined;
+  headers: Map<string, HeaderInfo>;
 }
 interface RequestBodyInfo {
   required: boolean;
@@ -35,11 +36,67 @@ interface RequestBodyInfo {
   contentTypes: string[];
   schema: JsonObject | undefined;
 }
+interface SecurityRequirement {
+  name: string;
+  scopes: string[];
+}
+interface SecurityScheme {
+  type: string;
+  description: string | undefined;
+  name: string | undefined;
+  location: string | undefined;
+  scheme: string | undefined;
+  bearerFormat: string | undefined;
+  flows: JsonObject | undefined;
+  openIdConnectUrl: string | undefined;
+}
+interface HeaderInfo {
+  name: string;
+  description: string | undefined;
+  required: boolean;
+  deprecated: boolean;
+  schema: JsonObject | undefined;
+}
+interface WebhookInfo {
+  name: string;
+  operations: OperationInfo[];
+}
+interface ExternalDocs {
+  url: string;
+  description: string | undefined;
+}
+interface XmlInfo {
+  name: string | undefined;
+  namespace: string | undefined;
+  prefix: string | undefined;
+  attribute: boolean;
+  wrapped: boolean;
+}
+interface CallbackInfo {
+  name: string;
+  operations: OperationInfo[];
+}
+interface LinkInfo {
+  name: string;
+  operationId: string | undefined;
+  operationRef: string | undefined;
+  description: string | undefined;
+  parameters: Map<string, string>;
+  requestBody: string | undefined;
+}
 declare function parseOpenApiDocument(doc: JsonObject): OpenApiDocument;
 declare function getSchema(parsed: OpenApiDocument, ref: string): JsonObject | undefined;
 declare function listOperations(parsed: OpenApiDocument): OperationInfo[];
 declare function getParameters(parsed: OpenApiDocument, path: string, method: string): ParameterInfo[];
 declare function getRequestBody(parsed: OpenApiDocument, path: string, method: string): RequestBodyInfo | undefined;
 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 listWebhooks(parsed: OpenApiDocument): WebhookInfo[];
+declare function getExternalDocs(obj: JsonObject): ExternalDocs | undefined;
+declare function getXmlInfo(schema: JsonObject): XmlInfo | undefined;
+declare function listCallbacks(parsed: OpenApiDocument, path: string, method: string): CallbackInfo[];
+declare function getLinks(parsed: OpenApiDocument, path: string, method: string, statusCode: string): LinkInfo[];
 //#endregion
-export { OpenApiDocument, OperationInfo, ParameterInfo, ParameterLocation, RequestBodyInfo, ResponseInfo, getParameters, getRequestBody, getResponses, getSchema, listOperations, parseOpenApiDocument };
+export { CallbackInfo, ExternalDocs, HeaderInfo, LinkInfo, OpenApiDocument, OperationInfo, ParameterInfo, ParameterLocation, RequestBodyInfo, ResponseInfo, SecurityRequirement, SecurityScheme, WebhookInfo, XmlInfo, getExternalDocs, getLinks, getParameters, getRequestBody, getResponseHeaders, getResponses, getSchema, getSecurityRequirements, getSecuritySchemes, getXmlInfo, listCallbacks, listOperations, listWebhooks, parseOpenApiDocument };