@zudojs/openapi 0.1.0 → 1.1.0

package/dist/openApiSchema/schemaRegistry.core.d.ts

@@ -1,28 +1,45 @@
-import type { OpenAPISchema } from "../openApiTypes/openApiTypes.core.js";
+import type { OpenAPIReference, OpenAPISchema } from "../openApiTypes/openApiTypes.core.js";
+import type { SchemaConversionOptions } from "./schemaConverter.core.js";
 /**
  * Schema registry for OpenAPI component schemas.
  */
 export interface SchemaRegistry {
-    register(name: string, schema: unknown): void;
+    register(name: string, schema: unknown): OpenAPISchema;
     get(name: string): OpenAPISchema | undefined;
+    has(name: string): boolean;
     convert(name: string, schema: unknown): OpenAPISchema;
-    ref(name: string): {
-        $ref: string;
-    };
+    ref(name: string): OpenAPIReference;
+    /** Conversion warnings, keyed by the component they came from. */
+    warnings(): ReadonlyMap<string, readonly string[]>;
+    /** Every registered schema, ready to drop into `components.schemas`. */
+    all(): Readonly<Record<string, OpenAPISchema>>;
     clear(): void;
 }
+/** Options for {@link SchemaRegistryImpl}. */
+export interface SchemaRegistryOptions extends SchemaConversionOptions {
+    /**
+     * Reports what a conversion could not express. Without a sink these are
+     * easy to lose, and "unsupported schema type" silently becoming `{}` is how
+     * a specification ends up documenting nothing.
+     */
+    readonly onWarning?: (name: string, warnings: readonly string[]) => void;
+}
 /**
  * Default schema registry implementation.
  */
 export declare class SchemaRegistryImpl implements SchemaRegistry {
     private readonly schemas;
-    private readonly pending;
-    register(name: string, schema: unknown): void;
+    private readonly conversionWarnings;
+    private readonly options;
+    constructor(options?: SchemaRegistryOptions);
+    private convertAndRecord;
+    register(name: string, schema: unknown): OpenAPISchema;
     get(name: string): OpenAPISchema | undefined;
+    has(name: string): boolean;
     convert(name: string, schema: unknown): OpenAPISchema;
-    ref(name: string): {
-        $ref: string;
-    };
+    ref(name: string): OpenAPIReference;
+    warnings(): ReadonlyMap<string, readonly string[]>;
+    all(): Readonly<Record<string, OpenAPISchema>>;
     clear(): void;
 }
 //# sourceMappingURL=schemaRegistry.core.d.ts.map

package/dist/openApiSchema/schemaRegistry.core.js

@@ -1,36 +1,55 @@
 import { convertSchema } from "./schemaConverter.core.js";
+import { createComponentReference } from "./references.core.js";
+import { OpenAPIComponentConflictError } from "../openApiErrors/openApiError.types.js";
 /**
  * Default schema registry implementation.
  */
 export class SchemaRegistryImpl {
     schemas = new Map();
-    pending = new Map();
+    conversionWarnings = new Map();
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    convertAndRecord(name, schema) {
+        const result = convertSchema(schema, this.options);
+        if (result.warnings.length > 0) {
+            this.conversionWarnings.set(name, result.warnings);
+            this.options.onWarning?.(name, result.warnings);
+        }
+        this.schemas.set(name, result.schema);
+        return result.schema;
+    }
     register(name, schema) {
         if (this.schemas.has(name)) {
-            throw new Error(`Schema "${name}" is already registered.`);
+            throw new OpenAPIComponentConflictError("schemas", name);
         }
-        const result = convertSchema(schema);
-        this.schemas.set(name, result.schema);
+        return this.convertAndRecord(name, schema);
     }
     get(name) {
         return this.schemas.get(name);
     }
+    has(name) {
+        return this.schemas.has(name);
+    }
     convert(name, schema) {
-        if (this.schemas.has(name)) {
-            return this.schemas.get(name);
-        }
-        const result = convertSchema(schema);
-        this.schemas.set(name, result.schema);
-        return result.schema;
+        const existing = this.schemas.get(name);
+        if (existing)
+            return existing;
+        return this.convertAndRecord(name, schema);
     }
     ref(name) {
-        return {
-            $ref: `#/components/schemas/${name}`,
-        };
+        return createComponentReference("schemas", name);
+    }
+    warnings() {
+        return new Map(this.conversionWarnings);
+    }
+    all() {
+        return Object.fromEntries(this.schemas);
     }
     clear() {
         this.schemas.clear();
-        this.pending.clear();
+        this.conversionWarnings.clear();
     }
 }
 //# sourceMappingURL=schemaRegistry.core.js.map

package/dist/openApiSerialization/openApiSerializer.core.d.ts

@@ -1,12 +1,18 @@
 import type { OpenAPIDocument } from "../openApiTypes/openApiTypes.core.js";
 /**
- * Serializes an OpenAPI document to JSON string.
+ * Serializes an OpenAPI document to a JSON string.
  */
-export declare function toOpenAPIJSON(document: OpenAPIDocument): string;
+export declare function toOpenAPIJSON(document: OpenAPIDocument, options?: {
+    readonly indent?: number;
+}): string;
 /**
- * Serializes an OpenAPI document to YAML string.
+ * Serializes an OpenAPI document to a YAML string.
  *
- * Note: This requires a YAML library. For now, returns JSON as a fallback.
+ * A real YAML encoder, not JSON under a different name: an OpenAPI document
+ * is plain data — maps, arrays and scalars — which is exactly the subset of
+ * YAML that can be emitted correctly without a full library. Strings that
+ * YAML would reinterpret (`true`, `null`, `1.0`, anything starting with a
+ * reserved character) are quoted.
  */
 export declare function toOpenAPIYAML(document: OpenAPIDocument): string;
 //# sourceMappingURL=openApiSerializer.core.d.ts.map

package/dist/openApiSerialization/openApiSerializer.core.js

@@ -1,26 +1,152 @@
-import { OpenAPISerializationError } from "../openApiErrors/openApiError.core.js";
+import { OpenAPISerializationError } from "../openApiErrors/openApiError.types.js";
 /**
- * Serializes an OpenAPI document to JSON string.
+ * Serializes an OpenAPI document to a JSON string.
  */
-export function toOpenAPIJSON(document) {
+export function toOpenAPIJSON(document, options) {
     try {
-        return JSON.stringify(document, null, 2);
+        return JSON.stringify(document, null, options?.indent ?? 2);
     }
     catch (error) {
-        throw new OpenAPISerializationError(`Failed to serialize OpenAPI document to JSON: ${error.message}`);
+        throw new OpenAPISerializationError(`Failed to serialize the OpenAPI document to JSON: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
 }
+/* ── YAML ──────────────────────────────────────────────────────────────── */
 /**
- * Serializes an OpenAPI document to YAML string.
+ * Strings that must be quoted because bare YAML would read them as something
+ * else: the booleans and null forms YAML 1.1 recognises, plus the empty
+ * string.
+ */
+const YAML_RESERVED = new Set([
+    "",
+    "true",
+    "false",
+    "yes",
+    "no",
+    "on",
+    "off",
+    "null",
+    "~",
+    "y",
+    "n",
+]);
+/** A bare (unquoted) YAML scalar may not start with these. */
+const YAML_UNSAFE_START = /^[-?:,[\]{}#&*!|>'"%@`\s]/;
+const YAML_UNSAFE_ANYWHERE = /[:#\n\r\t]|: |\s#/;
+const YAML_NUMERIC = /^[-+]?(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?$/;
+function quoteYamlString(value) {
+    // Double quotes with JSON escaping is always valid YAML and needs no
+    // decision about block scalars or line folding.
+    return JSON.stringify(value);
+}
+function yamlScalar(value) {
+    if (YAML_RESERVED.has(value.toLowerCase()) ||
+        YAML_UNSAFE_START.test(value) ||
+        YAML_UNSAFE_ANYWHERE.test(value) ||
+        YAML_NUMERIC.test(value) ||
+        value !== value.trim()) {
+        return quoteYamlString(value);
+    }
+    return value;
+}
+function yamlKey(key) {
+    return yamlScalar(key);
+}
+function isEmptyContainer(value) {
+    if (Array.isArray(value))
+        return value.length === 0;
+    if (typeof value === "object" && value !== null) {
+        return Object.keys(value).length === 0;
+    }
+    return false;
+}
+function toYaml(value, indent, seen) {
+    const pad = "  ".repeat(indent);
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "null";
+    switch (typeof value) {
+        case "string":
+            return yamlScalar(value);
+        case "number":
+            if (Number.isFinite(value))
+                return String(value);
+            // YAML distinguishes infinity from not-a-number; collapsing both onto
+            // `.nan` turns an out-of-range bound into an unrepresentable one.
+            if (Number.isNaN(value))
+                return ".nan";
+            return value > 0 ? ".inf" : "-.inf";
+        case "boolean":
+            return value ? "true" : "false";
+        case "bigint":
+            return value.toString();
+        default:
+            break;
+    }
+    if (typeof value !== "object") {
+        return quoteYamlString(String(value));
+    }
+    const container = value;
+    if (seen.has(container)) {
+        throw new OpenAPISerializationError("Failed to serialize the OpenAPI document to YAML: the document contains a cycle.");
+    }
+    seen.add(container);
+    try {
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                return "[]";
+            return value
+                .map((entry) => {
+                const rendered = toYaml(entry, indent + 1, seen);
+                if (typeof entry === "object" &&
+                    entry !== null &&
+                    !isEmptyContainer(entry)) {
+                    // Nested block: put the first line beside the dash.
+                    return `${pad}- ${rendered.slice((indent + 1) * 2)}`;
+                }
+                return `${pad}- ${rendered}`;
+            })
+                .join("\n");
+        }
+        const entries = Object.entries(value).filter(([, entry]) => entry !== undefined);
+        if (entries.length === 0)
+            return "{}";
+        return entries
+            .map(([key, entry]) => {
+            const renderedKey = `${pad}${yamlKey(key)}:`;
+            if (entry === null)
+                return `${renderedKey} null`;
+            if (typeof entry !== "object") {
+                return `${renderedKey} ${toYaml(entry, indent + 1, seen)}`;
+            }
+            if (isEmptyContainer(entry)) {
+                return `${renderedKey} ${Array.isArray(entry) ? "[]" : "{}"}`;
+            }
+            return `${renderedKey}\n${toYaml(entry, indent + 1, seen)}`;
+        })
+            .join("\n");
+    }
+    finally {
+        seen.delete(container);
+    }
+}
+/**
+ * Serializes an OpenAPI document to a YAML string.
  *
- * Note: This requires a YAML library. For now, returns JSON as a fallback.
+ * A real YAML encoder, not JSON under a different name: an OpenAPI document
+ * is plain data — maps, arrays and scalars — which is exactly the subset of
+ * YAML that can be emitted correctly without a full library. Strings that
+ * YAML would reinterpret (`true`, `null`, `1.0`, anything starting with a
+ * reserved character) are quoted.
  */
 export function toOpenAPIYAML(document) {
     try {
-        return JSON.stringify(document, null, 2);
+        return `${toYaml(document, 0, new WeakSet())}\n`;
     }
     catch (error) {
-        throw new OpenAPISerializationError(`Failed to serialize OpenAPI document to YAML: ${error.message}`);
+        if (error instanceof OpenAPISerializationError)
+            throw error;
+        throw new OpenAPISerializationError(`Failed to serialize the OpenAPI document to YAML: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
 }
 //# sourceMappingURL=openApiSerializer.core.js.map

package/dist/openApiTypes/index.d.ts

@@ -3,5 +3,5 @@
  *
  * Core OpenAPI specification types.
  */
-export type { OpenAPIVersion, OpenAPIDocument, OpenAPIComponents, OpenAPISecurityRequirement, OpenAPIParameterLocation, OpenAPIResponse, OpenAPIParameter, OpenAPIRequestBody, OpenAPIMediaType, OpenAPIEncoding, OpenAPIHeader, OpenAPILink, OpenAPIExample, OpenAPIPaths, OpenAPIPathItem, OpenAPIOperation, OpenAPIResponses, OpenAPIServer, OpenAPIServerVariable, OpenAPIInfo, OpenAPIContact, OpenAPILicense, OpenAPIExternalDocumentation, OpenAPISchema, OpenAPIDiscriminator, OpenAPIXml, OpenAPISecurityScheme, OpenAPIOAuthFlows, OpenAPIOAuthFlow, OpenAPITag, OpenAPIReference, } from "./openApiTypes.core.js";
+export type { OpenAPIVersion, OpenAPIDocument, OpenAPIComponents, OpenAPISecurityRequirement, OpenAPIParameterLocation, OpenAPIResponse, OpenAPIParameter, OpenAPIRequestBody, OpenAPIMediaType, OpenAPIEncoding, OpenAPIHeader, OpenAPILink, OpenAPIExample, OpenAPIPaths, OpenAPIPathItem, OpenAPIOperation, OpenAPIResponses, OpenAPIServer, OpenAPIServerVariable, OpenAPIInfo, OpenAPILogo, OpenAPIContact, OpenAPILicense, OpenAPIExternalDocumentation, OpenAPISchema, OpenAPIDiscriminator, OpenAPIXml, OpenAPISecurityScheme, OpenAPIOAuthFlows, OpenAPIOAuthFlow, OpenAPITag, OpenAPIReference, } from "./openApiTypes.core.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/openApiTypes/openApiDocument.type.d.ts

@@ -23,6 +23,22 @@ export interface OpenAPIInfo {
     readonly termsOfService?: string;
     readonly contact?: OpenAPIContact;
     readonly license?: OpenAPILicense;
+    /**
+     * Vendor extension rendered as a logo by ReDoc, Scalar and other viewers.
+     * Set automatically to the Zudo mark by {@link OpenAPIManager} unless
+     * branding is disabled or a logo is supplied.
+     */
+    readonly "x-logo"?: OpenAPILogo;
+}
+/** The `x-logo` vendor extension (`info["x-logo"]`). */
+export interface OpenAPILogo {
+    /** Image URL or data URI. */
+    readonly url: string;
+    /** Where clicking the logo navigates. */
+    readonly href?: string;
+    readonly altText?: string;
+    /** Background colour painted behind the logo by viewers that support it. */
+    readonly backgroundColor?: string;
 }
 export interface OpenAPIContact {
     readonly name?: string;

package/dist/openApiTypes/openApiSchema.type.d.ts

@@ -1,28 +1,51 @@
 /**
  * OpenAPI schema types.
+ *
+ * Follows JSON Schema 2020-12 as OpenAPI 3.1 does, while keeping the 3.0-only
+ * `nullable` keyword available for documents targeting 3.0.x.
  */
 export interface OpenAPISchema {
     readonly title?: string;
-    readonly type?: string;
+    /** A single type, or — in 3.1 — a union such as `["string", "null"]`. */
+    readonly type?: string | readonly string[];
     readonly properties?: Readonly<Record<string, OpenAPISchema>>;
     readonly required?: readonly string[];
     readonly description?: string;
     readonly format?: string;
     readonly default?: unknown;
+    /** OpenAPI 3.0 only. In 3.1, nullability is part of `type`. */
     readonly nullable?: boolean;
     readonly readOnly?: boolean;
     readonly writeOnly?: boolean;
     readonly deprecated?: boolean;
     readonly example?: unknown;
+    readonly examples?: readonly unknown[];
     readonly enum?: readonly unknown[];
+    readonly const?: unknown;
     readonly $ref?: string;
     readonly allOf?: readonly OpenAPISchema[];
     readonly oneOf?: readonly OpenAPISchema[];
     readonly anyOf?: readonly OpenAPISchema[];
+    readonly not?: OpenAPISchema;
     readonly items?: OpenAPISchema;
+    /** JSON Schema 2020-12 positional items, used for tuples. */
+    readonly prefixItems?: readonly OpenAPISchema[];
     readonly additionalProperties?: OpenAPISchema | boolean;
     readonly discriminator?: OpenAPIDiscriminator;
     readonly xml?: OpenAPIXml;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly pattern?: string;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly exclusiveMinimum?: number | boolean;
+    readonly exclusiveMaximum?: number | boolean;
+    readonly multipleOf?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly uniqueItems?: boolean;
+    readonly minProperties?: number;
+    readonly maxProperties?: number;
     readonly extensions?: Readonly<Record<string, unknown>>;
 }
 export interface OpenAPIDiscriminator {

package/dist/openApiTypes/openApiSchema.type.js

@@ -1,5 +1,8 @@
 /**
  * OpenAPI schema types.
+ *
+ * Follows JSON Schema 2020-12 as OpenAPI 3.1 does, while keeping the 3.0-only
+ * `nullable` keyword available for documents targeting 3.0.x.
  */
 export {};
 //# sourceMappingURL=openApiSchema.type.js.map

package/dist/openApiUi/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @zudojs/openapi/openApiUi
+ *
+ * Branded documentation pages (Swagger UI / ReDoc) and the Zudo brand assets.
+ */
+export { renderOpenAPIUI, zudoLogo, escapeHtml, type OpenAPIUIOptions, type OpenAPIUIRenderer, } from "./openApiUi.core.js";
+export { ZUDO_MARK_SVG, ZUDO_MARK_DARK_SVG, ZUDO_WORDMARK_SVG, ZUDO_WORDMARK_DARK_SVG, ZUDO_FAVICON_SVG, ZUDO_MARK_DATA_URI, ZUDO_MARK_DARK_DATA_URI, ZUDO_WORDMARK_DATA_URI, ZUDO_WORDMARK_DARK_DATA_URI, ZUDO_FAVICON_DATA_URI, ZUDO_SITE_URL, svgToDataUri, } from "./openApiUi.brand.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/openApiUi/index.js

@@ -0,0 +1,8 @@
+/**
+ * @zudojs/openapi/openApiUi
+ *
+ * Branded documentation pages (Swagger UI / ReDoc) and the Zudo brand assets.
+ */
+export { renderOpenAPIUI, zudoLogo, escapeHtml, } from "./openApiUi.core.js";
+export { ZUDO_MARK_SVG, ZUDO_MARK_DARK_SVG, ZUDO_WORDMARK_SVG, ZUDO_WORDMARK_DARK_SVG, ZUDO_FAVICON_SVG, ZUDO_MARK_DATA_URI, ZUDO_MARK_DARK_DATA_URI, ZUDO_WORDMARK_DATA_URI, ZUDO_WORDMARK_DARK_DATA_URI, ZUDO_FAVICON_DATA_URI, ZUDO_SITE_URL, svgToDataUri, } from "./openApiUi.brand.js";
+//# sourceMappingURL=index.js.map

package/dist/openApiUi/openApiUi.brand.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @zudojs/openapi/openApiUi
+ *
+ * Zudo brand assets embedded as data URIs so generated documentation pages
+ * carry the logo without depending on any external host.
+ */
+/** The Zudo mark for light backgrounds: navy modules, red diagonal. */
+export declare const ZUDO_MARK_SVG: string;
+/** The Zudo mark for dark backgrounds: off-white modules, red diagonal. */
+export declare const ZUDO_MARK_DARK_SVG: string;
+/** The full wordmark (mark + ZUDO letters) for light backgrounds. */
+export declare const ZUDO_WORDMARK_SVG: string;
+/** The wordmark for dark backgrounds. */
+export declare const ZUDO_WORDMARK_DARK_SVG: string;
+/** A 32×32 favicon: red tile, off-white Z. */
+export declare const ZUDO_FAVICON_SVG: string;
+/** Encodes an SVG string as a `data:` URI usable in `<img src>` or CSS. */
+export declare function svgToDataUri(svg: string): string;
+export declare const ZUDO_MARK_DATA_URI: string;
+export declare const ZUDO_MARK_DARK_DATA_URI: string;
+export declare const ZUDO_WORDMARK_DATA_URI: string;
+export declare const ZUDO_WORDMARK_DARK_DATA_URI: string;
+export declare const ZUDO_FAVICON_DATA_URI: string;
+/** Where the logo links by default. */
+export declare const ZUDO_SITE_URL = "https://zudo.dev";
+//# sourceMappingURL=openApiUi.brand.d.ts.map

package/dist/openApiUi/openApiUi.brand.js

@@ -0,0 +1,44 @@
+/**
+ * @zudojs/openapi/openApiUi
+ *
+ * Zudo brand assets embedded as data URIs so generated documentation pages
+ * carry the logo without depending on any external host.
+ */
+/** The Zudo mark for light backgrounds: navy modules, red diagonal. */
+export const ZUDO_MARK_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 80 80" role="img" aria-label="Zudo">' +
+    '<g fill="#1A1A2E"><rect x="6" y="6" width="12" height="12"/><rect x="20" y="6" width="12" height="12"/><rect x="34" y="6" width="12" height="12"/><rect x="48" y="6" width="12" height="12"/><rect x="62" y="6" width="12" height="12"/>' +
+    '<rect x="6" y="62" width="12" height="12"/><rect x="20" y="62" width="12" height="12"/><rect x="34" y="62" width="12" height="12"/><rect x="48" y="62" width="12" height="12"/><rect x="62" y="62" width="12" height="12"/></g>' +
+    '<g fill="#C0392B"><rect x="48" y="20" width="12" height="12"/><rect x="34" y="34" width="12" height="12"/><rect x="20" y="48" width="12" height="12"/></g>' +
+    "</svg>";
+/** The Zudo mark for dark backgrounds: off-white modules, red diagonal. */
+export const ZUDO_MARK_DARK_SVG = ZUDO_MARK_SVG.replace('fill="#1A1A2E"', 'fill="#FAFAF9"');
+/** The full wordmark (mark + ZUDO letters) for light backgrounds. */
+export const ZUDO_WORDMARK_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 330 80" role="img" aria-label="Zudo">' +
+    ZUDO_MARK_SVG.replace(/^<svg[^>]*>/, "").replace(/<\/svg>$/, "") +
+    '<g fill="none" stroke="#1A1A2E" stroke-width="12" stroke-linecap="square" stroke-linejoin="miter" transform="translate(100 18)">' +
+    '<path d="M6 6H34L6 38H34"/><path d="M64 6V38H92V6"/><path d="M122 6H140L150 16V28L140 38H122Z"/><path d="M180 6H208V38H180Z"/></g>' +
+    "</svg>";
+/** The wordmark for dark backgrounds. */
+export const ZUDO_WORDMARK_DARK_SVG = ZUDO_WORDMARK_SVG.replace(/#1A1A2E/g, "#FAFAF9");
+/** A 32×32 favicon: red tile, off-white Z. */
+export const ZUDO_FAVICON_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect width="32" height="32" fill="#C0392B"/>' +
+    '<rect x="5" y="6" width="22" height="5" fill="#FAFAF9"/><rect x="17" y="11" width="5" height="4" fill="#FAFAF9"/><rect x="13.5" y="14" width="5" height="4" fill="#FAFAF9"/>' +
+    '<rect x="10" y="17" width="5" height="4" fill="#FAFAF9"/><rect x="5" y="21" width="22" height="5" fill="#FAFAF9"/></svg>';
+/** Encodes an SVG string as a `data:` URI usable in `<img src>` or CSS. */
+export function svgToDataUri(svg) {
+    return ("data:image/svg+xml;charset=utf-8," +
+        encodeURIComponent(svg)
+            .replace(/%20/g, " ")
+            .replace(/%3D/g, "=")
+            .replace(/%3A/g, ":")
+            .replace(/%2F/g, "/")
+            .replace(/%22/g, "'"));
+}
+export const ZUDO_MARK_DATA_URI = svgToDataUri(ZUDO_MARK_SVG);
+export const ZUDO_MARK_DARK_DATA_URI = svgToDataUri(ZUDO_MARK_DARK_SVG);
+export const ZUDO_WORDMARK_DATA_URI = svgToDataUri(ZUDO_WORDMARK_SVG);
+export const ZUDO_WORDMARK_DARK_DATA_URI = svgToDataUri(ZUDO_WORDMARK_DARK_SVG);
+export const ZUDO_FAVICON_DATA_URI = svgToDataUri(ZUDO_FAVICON_SVG);
+/** Where the logo links by default. */
+export const ZUDO_SITE_URL = "https://zudo.dev";
+//# sourceMappingURL=openApiUi.brand.js.map

package/dist/openApiUi/openApiUi.core.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @zudojs/openapi/openApiUi
+ *
+ * Renders a branded documentation page (Swagger UI or ReDoc) for a served
+ * OpenAPI document. The page carries the Zudo mark in its header and as its
+ * favicon, and reads the specification from `specUrl`.
+ *
+ * The returned string is a complete HTML document; serve it with
+ * `content-type: text/html`. {@link OpenAPIManager.toUIResponse} does that.
+ */
+import type { OpenAPILogo } from "../openApiTypes/openApiTypes.core.js";
+/** Which viewer to render. */
+export type OpenAPIUIRenderer = "swagger" | "redoc";
+/** Options for {@link renderOpenAPIUI}. */
+export interface OpenAPIUIOptions {
+    /** URL the page fetches the specification from, e.g. `/openapi.json`. */
+    readonly specUrl: string;
+    /** Page title. Default: "API reference". */
+    readonly title?: string;
+    /** Viewer. Default: "swagger". */
+    readonly renderer?: OpenAPIUIRenderer;
+    /**
+     * Logo shown in the page header. Default: the Zudo wordmark linking to
+     * zudo.dev. Pass `false` to render no logo at all.
+     */
+    readonly logo?: OpenAPILogo | false;
+    /** Favicon URL or data URI. Default: the Zudo favicon. */
+    readonly favicon?: string | false;
+    /** Extra CSS appended after the built-in theme. */
+    readonly customCss?: string;
+    /**
+     * Base URL the viewer's own assets load from. Defaults to a public CDN:
+     * `https://unpkg.com/swagger-ui-dist@5` for Swagger UI and
+     * `https://cdn.redoc.ly/redoc/latest/bundles` for ReDoc. Point it at a
+     * self-hosted copy for air-gapped deployments.
+     */
+    readonly assetsBaseUrl?: string;
+    /** Options forwarded to `SwaggerUIBundle(...)`; ignored by ReDoc. */
+    readonly swaggerOptions?: Readonly<Record<string, unknown>>;
+}
+/** The default logo used by every branded page and by `info["x-logo"]`. */
+export declare function zudoLogo(overrides?: Partial<OpenAPILogo>): OpenAPILogo;
+/** Escapes text for safe interpolation into HTML attribute or text nodes. */
+export declare function escapeHtml(value: string): string;
+/** Renders a complete, branded documentation page for `options.specUrl`. */
+export declare function renderOpenAPIUI(options: OpenAPIUIOptions): string;
+//# sourceMappingURL=openApiUi.core.d.ts.map