@orpc/openapi 0.0.0-next.b4fc1d9 → 0.0.0-next.b50e4fc

package/dist/index.mjs

@@ -1,303 +1,41 @@
-import { isProcedure, resolveContractProcedures, toHttpPath } from '@orpc/server';
-import { fallbackORPCErrorStatus, fallbackORPCErrorMessage } from '@orpc/client';
-import { fallbackContractConfig, getEventIteratorSchemaDetails } from '@orpc/contract';
-import { StandardOpenAPIJsonSerializer } from '@orpc/openapi-client/standard';
-import { clone } from '@orpc/shared';
-import { t as toOpenAPIMethod, a as toOpenAPIPath, b as toOpenAPIEventIteratorContent, g as getDynamicParams, i as isAnySchema, c as isObjectSchema, d as separateObjectSchema, e as checkParamsSchema, f as toOpenAPIParameters, h as toOpenAPIContent, j as toOpenAPISchema } from './shared/openapi.DZzpQAb-.mjs';
-export { L as LOGIC_KEYWORDS, l as filterSchemaBranches, k as isFileSchema, s as standardizeHTTPPath } from './shared/openapi.DZzpQAb-.mjs';
-export { Format as JSONSchemaFormat } from 'json-schema-typed/draft-2020-12';
+import { c as customOpenAPIOperation } from './shared/openapi.CoREqFh3.mjs';
+export { C as CompositeSchemaConverter, L as LOGIC_KEYWORDS, O as OpenAPIGenerator, a as applyCustomOpenAPIOperation, o as applySchemaOptionality, h as checkParamsSchema, q as expandArrayableSchema, p as expandUnionSchema, n as filterSchemaBranches, g as getCustomOpenAPIOperation, l as isAnySchema, j as isFileSchema, k as isObjectSchema, u as isPrimitiveSchema, r as resolveOpenAPIJsonSchemaRef, m as separateObjectSchema, s as simplifyComposedObjectJsonSchemasAndRefs, d as toOpenAPIContent, e as toOpenAPIEventIteratorContent, b as toOpenAPIMethod, f as toOpenAPIParameters, t as toOpenAPIPath, i as toOpenAPISchema } from './shared/openapi.CoREqFh3.mjs';
+import { createORPCErrorFromJson } from '@orpc/client';
+import { StandardOpenAPISerializer, StandardOpenAPIJsonSerializer, StandardBracketNotationSerializer } from '@orpc/openapi-client/standard';
+import { ORPCError, createRouterClient } from '@orpc/server';
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+export { ContentEncoding as JSONSchemaContentEncoding, Format as JSONSchemaFormat, TypeName as JSONSchemaTypeName } from 'json-schema-typed/draft-2020-12';
+import '@orpc/client/standard';
+import '@orpc/contract';
 
-const OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
-function customOpenAPIOperation(o, extend) {
-  return new Proxy(o, {
-    get(target, prop, receiver) {
-      if (prop === OPERATION_EXTENDER_SYMBOL) {
-        return extend;
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-}
-function getCustomOpenAPIOperation(o) {
-  return o[OPERATION_EXTENDER_SYMBOL];
-}
-function applyCustomOpenAPIOperation(operation, contract) {
-  const operationCustoms = [];
-  for (const errorItem of Object.values(contract["~orpc"].errorMap)) {
-    const maybeExtender = errorItem ? getCustomOpenAPIOperation(errorItem) : void 0;
-    if (maybeExtender) {
-      operationCustoms.push(maybeExtender);
-    }
-  }
-  if (isProcedure(contract)) {
-    for (const middleware of contract["~orpc"].middlewares) {
-      const maybeExtender = getCustomOpenAPIOperation(middleware);
-      if (maybeExtender) {
-        operationCustoms.push(maybeExtender);
-      }
-    }
-  }
-  let currentOperation = operation;
-  for (const custom of operationCustoms) {
-    if (typeof custom === "function") {
-      currentOperation = custom(currentOperation, contract);
-    } else {
-      currentOperation = {
-        ...currentOperation,
-        ...custom
-      };
-    }
-  }
-  return currentOperation;
-}
-
-class CompositeSchemaConverter {
-  converters;
-  constructor(converters) {
-    this.converters = converters;
-  }
-  convert(schema, options) {
-    for (const converter of this.converters) {
-      if (converter.condition(schema, options)) {
-        return converter.convert(schema, options);
-      }
-    }
-    return [false, {}];
-  }
-}
-
-class OpenAPIGeneratorError extends Error {
-}
-class OpenAPIGenerator {
-  serializer;
-  converter;
-  constructor(options = {}) {
-    this.serializer = new StandardOpenAPIJsonSerializer(options);
-    this.converter = new CompositeSchemaConverter(options.schemaConverters ?? []);
-  }
-  async generate(router, base) {
-    const doc = clone(base);
-    doc.openapi = "3.1.1";
-    const errors = [];
-    await resolveContractProcedures({ path: [], router }, ({ contract, path }) => {
-      const operationId = path.join(".");
-      try {
-        const def = contract["~orpc"];
-        const method = toOpenAPIMethod(fallbackContractConfig("defaultMethod", def.route.method));
-        const httpPath = toOpenAPIPath(def.route.path ?? toHttpPath(path));
-        const operationObjectRef = {
-          operationId,
-          summary: def.route.summary,
-          description: def.route.description,
-          deprecated: def.route.deprecated,
-          tags: def.route.tags?.map((tag) => tag)
-        };
-        this.#request(operationObjectRef, def);
-        this.#successResponse(operationObjectRef, def);
-        this.#errorResponse(operationObjectRef, def);
-        doc.paths ??= {};
-        doc.paths[httpPath] ??= {};
-        doc.paths[httpPath][method] = applyCustomOpenAPIOperation(operationObjectRef, contract);
-      } catch (e) {
-        if (!(e instanceof OpenAPIGeneratorError)) {
-          throw e;
-        }
-        errors.push(
-          `[OpenAPIGenerator] Error occurred while generating OpenAPI for procedure at path: ${operationId}
-${e.message}`
-        );
-      }
-    });
-    if (errors.length) {
-      throw new OpenAPIGeneratorError(
-        `Some error occurred during OpenAPI generation:
-
-${errors.join("\n\n")}`
-      );
-    }
-    return this.serializer.serialize(doc)[0];
-  }
-  #request(ref, def) {
-    const method = fallbackContractConfig("defaultMethod", def.route.method);
-    const details = getEventIteratorSchemaDetails(def.inputSchema);
-    if (details) {
-      ref.requestBody = {
-        required: true,
-        content: toOpenAPIEventIteratorContent(
-          this.converter.convert(details.yields, { strategy: "input" }),
-          this.converter.convert(details.returns, { strategy: "input" })
+function createJsonifiedRouterClient(router, ...rest) {
+  const options = resolveMaybeOptionalOptions(rest);
+  const serializer = new StandardOpenAPISerializer(new StandardOpenAPIJsonSerializer(), new StandardBracketNotationSerializer());
+  options.interceptors ??= [];
+  options.interceptors.unshift(async (options2) => {
+    try {
+      return serializer.deserialize(
+        serializer.serialize(
+          await options2.next()
         )
-      };
-      return;
-    }
-    const dynamicParams = getDynamicParams(def.route.path);
-    const inputStructure = fallbackContractConfig("defaultInputStructure", def.route.inputStructure);
-    let [required, schema] = this.converter.convert(def.inputSchema, { strategy: "input" });
-    if (isAnySchema(schema) && !dynamicParams?.length) {
-      return;
-    }
-    if (inputStructure === "compact") {
-      if (dynamicParams?.length) {
-        const error2 = new OpenAPIGeneratorError(
-          'When input structure is "compact", and path has dynamic params, input schema must be an object with all dynamic params as required.'
-        );
-        if (!isObjectSchema(schema)) {
-          throw error2;
-        }
-        const [paramsSchema, rest] = separateObjectSchema(schema, dynamicParams);
-        schema = rest;
-        required = rest.required ? rest.required.length !== 0 : false;
-        if (!checkParamsSchema(paramsSchema, dynamicParams)) {
-          throw error2;
-        }
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(paramsSchema, "path"));
-      }
-      if (method === "GET") {
-        if (!isObjectSchema(schema)) {
-          throw new OpenAPIGeneratorError(
-            'When method is "GET", input schema must satisfy: object | any | unknown'
-          );
-        }
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(schema, "query"));
-      } else {
-        ref.requestBody = {
-          required,
-          content: toOpenAPIContent(schema)
-        };
-      }
-      return;
-    }
-    const error = new OpenAPIGeneratorError(
-      'When input structure is "detailed", input schema must satisfy: { params?: Record<string, unknown>, query?: Record<string, unknown>, headers?: Record<string, unknown>, body?: unknown }'
-    );
-    if (!isObjectSchema(schema)) {
-      throw error;
-    }
-    if (dynamicParams?.length && (schema.properties?.params === void 0 || !isObjectSchema(schema.properties.params) || !checkParamsSchema(schema.properties.params, dynamicParams))) {
-      throw new OpenAPIGeneratorError(
-        'When input structure is "detailed" and path has dynamic params, the "params" schema must be an object with all dynamic params as required.'
       );
-    }
-    for (const from of ["params", "query", "headers"]) {
-      const fromSchema = schema.properties?.[from];
-      if (fromSchema !== void 0) {
-        if (!isObjectSchema(fromSchema)) {
-          throw error;
-        }
-        const parameterIn = from === "params" ? "path" : from === "headers" ? "header" : "query";
-        ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(fromSchema, parameterIn));
-      }
-    }
-    if (schema.properties?.body !== void 0) {
-      ref.requestBody = {
-        required: schema.required?.includes("body"),
-        content: toOpenAPIContent(schema.properties.body)
-      };
-    }
-  }
-  #successResponse(ref, def) {
-    const outputSchema = def.outputSchema;
-    const status = fallbackContractConfig("defaultSuccessStatus", def.route.successStatus);
-    const description = fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription);
-    const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(outputSchema);
-    const outputStructure = fallbackContractConfig("defaultOutputStructure", def.route.outputStructure);
-    if (eventIteratorSchemaDetails) {
-      ref.responses ??= {};
-      ref.responses[status] = {
-        description,
-        content: toOpenAPIEventIteratorContent(
-          this.converter.convert(eventIteratorSchemaDetails.yields, { strategy: "output" }),
-          this.converter.convert(eventIteratorSchemaDetails.returns, { strategy: "output" })
-        )
-      };
-      return;
-    }
-    const [_, json] = this.converter.convert(outputSchema, { strategy: "output" });
-    ref.responses ??= {};
-    ref.responses[status] = {
-      description
-    };
-    if (outputStructure === "compact") {
-      ref.responses[status].content = toOpenAPIContent(json);
-      return;
-    }
-    const error = new OpenAPIGeneratorError(
-      'When output structure is "detailed", output schema must satisfy: { headers?: Record<string, unknown>, body?: unknown }'
-    );
-    if (!isObjectSchema(json)) {
-      throw error;
-    }
-    if (json.properties?.headers !== void 0) {
-      if (!isObjectSchema(json.properties.headers)) {
-        throw error;
-      }
-      for (const key in json.properties.headers.properties) {
-        ref.responses[status].headers ??= {};
-        ref.responses[status].headers[key] = {
-          schema: toOpenAPISchema(json.properties.headers.properties[key]),
-          required: json.properties.headers.required?.includes(key)
-        };
+    } catch (e) {
+      if (e instanceof ORPCError) {
+        throw createORPCErrorFromJson(serializer.deserialize(
+          serializer.serialize(
+            e.toJSON(),
+            { outputFormat: "plain" }
+          )
+        ));
       }
+      throw e;
     }
-    if (json.properties?.body !== void 0) {
-      ref.responses[status].content = toOpenAPIContent(json.properties.body);
-    }
-  }
-  #errorResponse(ref, def) {
-    const errorMap = def.errorMap;
-    const errors = {};
-    for (const code in errorMap) {
-      const config = errorMap[code];
-      if (!config) {
-        continue;
-      }
-      const status = fallbackORPCErrorStatus(code, config.status);
-      const message = fallbackORPCErrorMessage(code, config.message);
-      const [dataRequired, dataSchema] = this.converter.convert(config.data, { strategy: "output" });
-      errors[status] ??= [];
-      errors[status].push({
-        type: "object",
-        properties: {
-          defined: { const: true },
-          code: { const: code },
-          status: { const: status },
-          message: { type: "string", default: message },
-          data: dataSchema
-        },
-        required: dataRequired ? ["defined", "code", "status", "message", "data"] : ["defined", "code", "status", "message"]
-      });
-    }
-    ref.responses ??= {};
-    for (const status in errors) {
-      const schemas = errors[status];
-      ref.responses[status] = {
-        description: status,
-        content: toOpenAPIContent({
-          oneOf: [
-            ...schemas,
-            {
-              type: "object",
-              properties: {
-                defined: { const: false },
-                code: { type: "string" },
-                status: { type: "number" },
-                message: { type: "string" },
-                data: {}
-              },
-              required: ["defined", "code", "status", "message"]
-            }
-          ]
-        })
-      };
-    }
-  }
+  });
+  return createRouterClient(router, options);
 }
 
 const oo = {
   spec: customOpenAPIOperation
 };
 
-export { CompositeSchemaConverter, OpenAPIGenerator, applyCustomOpenAPIOperation, checkParamsSchema, customOpenAPIOperation, getCustomOpenAPIOperation, getDynamicParams, isAnySchema, isObjectSchema, oo, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };
+export { createJsonifiedRouterClient, customOpenAPIOperation, oo };

package/dist/plugins/index.d.mts

@@ -0,0 +1,86 @@
+import { OpenAPI } from '@orpc/contract';
+import { Context, HTTPPath, Router } from '@orpc/server';
+import { StandardHandlerInterceptorOptions, StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
+import { Value, Promisable } from '@orpc/shared';
+import { O as OpenAPIGeneratorOptions, a as OpenAPIGeneratorGenerateOptions } from '../shared/openapi.BGy4N6eR.mjs';
+import '@orpc/openapi-client/standard';
+import 'json-schema-typed/draft-2020-12';
+
+interface OpenAPIReferencePluginOptions<T extends Context> extends OpenAPIGeneratorOptions {
+    /**
+     * Options to pass to the OpenAPI generate.
+     *
+     */
+    specGenerateOptions?: Value<Promisable<OpenAPIGeneratorGenerateOptions>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * The URL path at which to serve the OpenAPI JSON.
+     *
+     * @default '/spec.json'
+     */
+    specPath?: HTTPPath;
+    /**
+     * The URL path at which to serve the API reference UI.
+     *
+     * @default '/'
+     */
+    docsPath?: HTTPPath;
+    /**
+     * The document title for the API reference UI.
+     *
+     * @default 'API Reference'
+     */
+    docsTitle?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * The UI library to use for rendering the API reference.
+     *
+     * @default 'scalar'
+     */
+    docsProvider?: 'scalar' | 'swagger';
+    /**
+     * Arbitrary configuration object for the UI.
+     */
+    docsConfig?: Value<Promisable<Record<string, unknown>>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * HTML to inject into the <head> of the docs page.
+     *
+     * @warning This is not escaped special characters, so must be used with caution to avoid XSS vulnerabilities.
+     *
+     * @default ''
+     */
+    docsHead?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * URL of the external script bundle for the reference UI.
+     *
+     * - For Scalar: defaults to 'https://cdn.jsdelivr.net/npm/@scalar/api-reference'
+     * - For Swagger UI: defaults to 'https://unpkg.com/swagger-ui-dist@5.17.14/swagger-ui-bundle.js'
+     */
+    docsScriptUrl?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * URL of the external CSS bundle for the reference UI (used by Swagger UI).
+     *
+     * @default 'https://unpkg.com/swagger-ui-dist@5.17.14/swagger-ui.css' (if swagger)
+     */
+    docsCssUrl?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * Override function to generate the full HTML for the docs page.
+     */
+    renderDocsHtml?: (specUrl: string, title: string, head: string, scriptUrl: string, config: Record<string, unknown> | undefined, spec: OpenAPI.Document, docsProvider: 'scalar' | 'swagger', cssUrl: string | undefined) => string;
+}
+declare class OpenAPIReferencePlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    private readonly generator;
+    private readonly specGenerateOptions;
+    private readonly specPath;
+    private readonly docsPath;
+    private readonly docsTitle;
+    private readonly docsHead;
+    private readonly docsProvider;
+    private readonly docsScriptUrl;
+    private readonly docsCssUrl;
+    private readonly docsConfig;
+    private readonly renderDocsHtml;
+    constructor(options?: OpenAPIReferencePluginOptions<T>);
+    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+
+export { OpenAPIReferencePlugin };
+export type { OpenAPIReferencePluginOptions };

package/dist/plugins/index.d.ts

@@ -0,0 +1,86 @@
+import { OpenAPI } from '@orpc/contract';
+import { Context, HTTPPath, Router } from '@orpc/server';
+import { StandardHandlerInterceptorOptions, StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
+import { Value, Promisable } from '@orpc/shared';
+import { O as OpenAPIGeneratorOptions, a as OpenAPIGeneratorGenerateOptions } from '../shared/openapi.BGy4N6eR.js';
+import '@orpc/openapi-client/standard';
+import 'json-schema-typed/draft-2020-12';
+
+interface OpenAPIReferencePluginOptions<T extends Context> extends OpenAPIGeneratorOptions {
+    /**
+     * Options to pass to the OpenAPI generate.
+     *
+     */
+    specGenerateOptions?: Value<Promisable<OpenAPIGeneratorGenerateOptions>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * The URL path at which to serve the OpenAPI JSON.
+     *
+     * @default '/spec.json'
+     */
+    specPath?: HTTPPath;
+    /**
+     * The URL path at which to serve the API reference UI.
+     *
+     * @default '/'
+     */
+    docsPath?: HTTPPath;
+    /**
+     * The document title for the API reference UI.
+     *
+     * @default 'API Reference'
+     */
+    docsTitle?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * The UI library to use for rendering the API reference.
+     *
+     * @default 'scalar'
+     */
+    docsProvider?: 'scalar' | 'swagger';
+    /**
+     * Arbitrary configuration object for the UI.
+     */
+    docsConfig?: Value<Promisable<Record<string, unknown>>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * HTML to inject into the <head> of the docs page.
+     *
+     * @warning This is not escaped special characters, so must be used with caution to avoid XSS vulnerabilities.
+     *
+     * @default ''
+     */
+    docsHead?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * URL of the external script bundle for the reference UI.
+     *
+     * - For Scalar: defaults to 'https://cdn.jsdelivr.net/npm/@scalar/api-reference'
+     * - For Swagger UI: defaults to 'https://unpkg.com/swagger-ui-dist@5.17.14/swagger-ui-bundle.js'
+     */
+    docsScriptUrl?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * URL of the external CSS bundle for the reference UI (used by Swagger UI).
+     *
+     * @default 'https://unpkg.com/swagger-ui-dist@5.17.14/swagger-ui.css' (if swagger)
+     */
+    docsCssUrl?: Value<Promisable<string>, [StandardHandlerInterceptorOptions<T>]>;
+    /**
+     * Override function to generate the full HTML for the docs page.
+     */
+    renderDocsHtml?: (specUrl: string, title: string, head: string, scriptUrl: string, config: Record<string, unknown> | undefined, spec: OpenAPI.Document, docsProvider: 'scalar' | 'swagger', cssUrl: string | undefined) => string;
+}
+declare class OpenAPIReferencePlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    private readonly generator;
+    private readonly specGenerateOptions;
+    private readonly specPath;
+    private readonly docsPath;
+    private readonly docsTitle;
+    private readonly docsHead;
+    private readonly docsProvider;
+    private readonly docsScriptUrl;
+    private readonly docsCssUrl;
+    private readonly docsConfig;
+    private readonly renderDocsHtml;
+    constructor(options?: OpenAPIReferencePluginOptions<T>);
+    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+}
+
+export { OpenAPIReferencePlugin };
+export type { OpenAPIReferencePluginOptions };

package/dist/plugins/index.mjs

@@ -0,0 +1,157 @@
+import { stringifyJSON, once, value } from '@orpc/shared';
+import { O as OpenAPIGenerator } from '../shared/openapi.CoREqFh3.mjs';
+import '@orpc/client';
+import '@orpc/client/standard';
+import '@orpc/contract';
+import '@orpc/openapi-client/standard';
+import '@orpc/server';
+import 'json-schema-typed/draft-2020-12';
+
+class OpenAPIReferencePlugin {
+  generator;
+  specGenerateOptions;
+  specPath;
+  docsPath;
+  docsTitle;
+  docsHead;
+  docsProvider;
+  docsScriptUrl;
+  docsCssUrl;
+  docsConfig;
+  renderDocsHtml;
+  constructor(options = {}) {
+    this.specGenerateOptions = options.specGenerateOptions;
+    this.docsPath = options.docsPath ?? "/";
+    this.docsTitle = options.docsTitle ?? "API Reference";
+    this.docsConfig = options.docsConfig ?? void 0;
+    this.docsProvider = options.docsProvider ?? "scalar";
+    this.docsScriptUrl = options.docsScriptUrl ?? (this.docsProvider === "swagger" ? "https://unpkg.com/swagger-ui-dist/swagger-ui-bundle.js" : "https://cdn.jsdelivr.net/npm/@scalar/api-reference");
+    this.docsCssUrl = options.docsCssUrl ?? (this.docsProvider === "swagger" ? "https://unpkg.com/swagger-ui-dist/swagger-ui.css" : void 0);
+    this.docsHead = options.docsHead ?? "";
+    this.specPath = options.specPath ?? "/spec.json";
+    this.generator = new OpenAPIGenerator(options);
+    const escapeHtmlEntities = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    const escapeJsonForHtml = (obj) => stringifyJSON(obj).replace(/&/g, "\\u0026").replace(/'/g, "\\u0027").replace(/</g, "\\u003C").replace(/>/g, "\\u003E").replace(/\//g, "\\u002F");
+    this.renderDocsHtml = options.renderDocsHtml ?? ((specUrl, title, head, scriptUrl, config, spec, docsProvider, cssUrl) => {
+      let body;
+      if (docsProvider === "swagger") {
+        const swaggerConfig = {
+          dom_id: "#app",
+          spec,
+          deepLinking: true,
+          presets: [
+            "SwaggerUIBundle.presets.apis",
+            "SwaggerUIBundle.presets.standalone"
+          ],
+          plugins: [
+            "SwaggerUIBundle.plugins.DownloadUrl"
+          ],
+          ...config
+        };
+        body = `
+        <body>
+          <div id="app"></div>
+
+          <script src="${escapeHtmlEntities(scriptUrl)}"><\/script>
+
+          <!-- IMPORTANT: assign to a variable first to prevent ), ( in values breaking the call expression. -->
+          <!-- IMPORTANT: escapeJsonForHtml ensures <, > cannot terminate the <\/script> tag prematurely. -->
+          <script>
+            const swaggerConfig = ${escapeJsonForHtml(swaggerConfig).replace(/"(SwaggerUIBundle\.[^"]+)"/g, "$1")}
+
+            window.onload = () => {
+              window.ui = SwaggerUIBundle(swaggerConfig)
+            }
+          <\/script>
+        </body>
+        `;
+      } else {
+        const scalarConfig = {
+          content: stringifyJSON(spec),
+          ...config
+        };
+        body = `
+        <body>
+          <div id="app"></div>
+ 
+          <script src="${escapeHtmlEntities(scriptUrl)}"><\/script>
+ 
+          <!-- IMPORTANT: assign to a variable first to prevent ), ( in values breaking the call expression. -->
+          <!-- IMPORTANT: escapeJsonForHtml ensures <, > cannot terminate the <\/script> tag prematurely. -->
+          <script>
+            const scalarConfig = ${escapeJsonForHtml(scalarConfig)}
+
+            Scalar.createApiReference('#app', scalarConfig)
+          <\/script>
+        </body>
+        `;
+      }
+      return `
+        <!doctype html>
+        <html>
+          <head>
+            <meta charset="utf-8" />
+            <meta name="viewport" content="width=device-width, initial-scale=1" />
+            <title>${escapeHtmlEntities(title)}</title>
+            ${cssUrl ? `<link rel="stylesheet" type="text/css" href="${escapeHtmlEntities(cssUrl)}" />` : ""}
+            ${head}
+          </head>
+          ${body}
+        </html>
+        `;
+    });
+  }
+  init(options, router) {
+    options.interceptors ??= [];
+    options.interceptors.push(async (options2) => {
+      const res = await options2.next();
+      if (res.matched || options2.request.method !== "GET") {
+        return res;
+      }
+      const prefix = options2.prefix ?? "";
+      const requestPathname = options2.request.url.pathname.replace(/\/$/, "") || "/";
+      const docsUrl = new URL(`${prefix}${this.docsPath}`.replace(/\/$/, ""), options2.request.url.origin);
+      const specUrl = new URL(`${prefix}${this.specPath}`.replace(/\/$/, ""), options2.request.url.origin);
+      const generateSpec = once(async () => {
+        return await this.generator.generate(router, {
+          servers: [{ url: new URL(prefix, options2.request.url.origin).toString() }],
+          ...await value(this.specGenerateOptions, options2)
+        });
+      });
+      if (requestPathname === specUrl.pathname) {
+        const spec = await generateSpec();
+        return {
+          matched: true,
+          response: {
+            status: 200,
+            headers: {},
+            body: new File([stringifyJSON(spec)], "spec.json", { type: "application/json" })
+          }
+        };
+      }
+      if (requestPathname === docsUrl.pathname) {
+        const html = this.renderDocsHtml(
+          specUrl.toString(),
+          await value(this.docsTitle, options2),
+          await value(this.docsHead, options2),
+          await value(this.docsScriptUrl, options2),
+          await value(this.docsConfig, options2),
+          await generateSpec(),
+          this.docsProvider,
+          await value(this.docsCssUrl, options2)
+        );
+        return {
+          matched: true,
+          response: {
+            status: 200,
+            headers: {},
+            body: new File([html], "api-reference.html", { type: "text/html" })
+          }
+        };
+      }
+      return res;
+    });
+  }
+}
+
+export { OpenAPIReferencePlugin };