fumadocs-openapi 4.4.1 → 5.0.0

package/dist/index.js

@@ -1,1068 +1,290 @@
-// src/generate.ts
-import Parser from "@apidevtools/json-schema-ref-parser";
+import Parser from '@apidevtools/json-schema-ref-parser';
+import Slugger from 'github-slugger';
+import { dump } from 'js-yaml';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, parse, dirname } from 'node:path';
+import fg from 'fast-glob';
 
-// src/build-routes.ts
-var methodKeys = [
-  "get",
-  "post",
-  "patch",
-  "delete",
-  "head",
-  "put"
-];
-function buildRoutes(document) {
-  const map = /* @__PURE__ */ new Map();
-  for (const [path, value] of Object.entries(document.paths)) {
-    if (!value) continue;
-    const methodMap = /* @__PURE__ */ new Map();
-    for (const methodKey of methodKeys) {
-      const operation = value[methodKey];
-      if (!operation) continue;
-      const info = buildOperation(methodKey, operation);
-      const tags = operation.tags ?? [];
-      for (const tag of [...tags, "all"]) {
-        const list = methodMap.get(tag) ?? [];
-        list.push(info);
-        methodMap.set(tag, list);
-      }
-    }
-    for (const [tag, methods] of methodMap.entries()) {
-      const list = map.get(tag) ?? [];
-      list.push({
-        ...value,
-        path,
-        methods
-      });
-      map.set(tag, list);
-    }
-  }
-  return map;
-}
-function buildOperation(method, operation) {
-  return {
-    ...operation,
-    parameters: operation.parameters ?? [],
-    method: method.toUpperCase()
-  };
+function createMethod(method, operation) {
+    return {
+        ...operation,
+        parameters: operation.parameters ?? [],
+        method: method.toUpperCase()
+    };
 }
 
-// src/utils/generate-document.ts
-import { dump } from "js-yaml";
-
-// src/render/element.ts
-function createElement(name, props, ...child) {
-  const s = [];
-  const params = Object.entries(props).map(([key, value]) => `${key}={${JSON.stringify(value)}}`).join(" ");
-  s.push(params.length > 0 ? `<${name} ${params}>` : `<${name}>`);
-  s.push(...child.filter((v) => v.length > 0));
-  s.push(`</${name}>`);
-  return s.join("\n\n");
-}
-function p(child) {
-  if (!child) return "";
-  return child.replace("<", "\\<").replace(">", "\\>");
-}
-function span(child) {
-  return `<span>${p(child)}</span>`;
-}
-function codeblock({ language, title }, child) {
-  return [
-    title ? `\`\`\`${language} title=${JSON.stringify(title)}` : `\`\`\`${language}`,
-    child.trim(),
-    "```"
-  ].join("\n");
-}
-function heading(depth, child) {
-  return `${"#".repeat(depth)} ${child.trim()}`;
+const methodKeys = [
+    'get',
+    'post',
+    'patch',
+    'delete',
+    'head',
+    'put'
+];
+/**
+ * Build the route information of tags, use `.get('all')` to get all entries
+ */ function buildRoutes(document) {
+    const map = new Map();
+    for (const [path, value] of Object.entries(document.paths)){
+        if (!value) continue;
+        const methodMap = new Map();
+        for (const methodKey of methodKeys){
+            const operation = value[methodKey];
+            if (!operation) continue;
+            const info = createMethod(methodKey, operation);
+            const tags = operation.tags ?? [];
+            for (const tag of [
+                ...tags,
+                'all'
+            ]){
+                const list = methodMap.get(tag) ?? [];
+                list.push(info);
+                methodMap.set(tag, list);
+            }
+        }
+        for (const [tag, methods] of methodMap.entries()){
+            const list = map.get(tag) ?? [];
+            list.push({
+                ...value,
+                path,
+                methods
+            });
+            map.set(tag, list);
+        }
+    }
+    return map;
 }
 
-// src/render/renderer.ts
-var defaultRenderer = {
-  Root: (props, child) => createElement("Root", props, ...child),
-  API: (child) => createElement("API", {}, ...child),
-  APIInfo: (props, child) => createElement("APIInfo", props, ...child),
-  APIExample: (child) => createElement("APIExample", {}, ...child),
-  Responses: (props, child) => createElement("Responses", props, ...child),
-  Response: (props, child) => createElement("Response", props, ...child),
-  ResponseTypes: (child) => createElement("ResponseTypes", {}, ...child),
-  ExampleResponse: (json) => createElement("ExampleResponse", {}, codeblock({ language: "json" }, json)),
-  TypeScriptResponse: (code) => createElement(
-    "TypeScriptResponse",
-    {},
-    codeblock({ language: "ts" }, code)
-  ),
-  Property: (props, child) => createElement("Property", props, ...child),
-  ObjectCollapsible: (props, child) => createElement("ObjectCollapsible", props, ...child),
-  Requests: (items, child) => createElement("Requests", { items }, ...child),
-  Request: ({ language, code, name }) => createElement("Request", { value: name }, codeblock({ language }, code)),
-  APIPlayground: (props) => createElement("APIPlayground", props)
-};
-
-// src/utils/generate-document.ts
 function generateDocument(content, options, frontmatter) {
-  const banner = dump({
-    title: frontmatter.title,
-    description: frontmatter.description,
-    full: true,
-    ...frontmatter.context.type === "operation" ? {
-      method: frontmatter.context.endpoint.method,
-      route: frontmatter.context.route.path
-    } : void 0,
-    ...options.frontmatter?.(
-      frontmatter.title,
-      frontmatter.description,
-      frontmatter.context
-    )
-  }).trim();
-  const finalImports = (options.imports ?? [
-    {
-      names: Object.keys(defaultRenderer),
-      from: "fumadocs-openapi/ui"
+    const out = [];
+    const banner = dump({
+        title: frontmatter.title,
+        description: frontmatter.description,
+        full: true,
+        ...frontmatter.context.type === 'operation' ? {
+            method: frontmatter.context.endpoint.method,
+            route: frontmatter.context.route.path
+        } : undefined,
+        ...options.frontmatter?.(frontmatter.title, frontmatter.description, frontmatter.context)
+    }).trim();
+    if (banner.length > 0) out.push(`---\n${banner}\n---`);
+    const imports = options.imports?.map((item)=>`import { ${item.names.join(', ')} } from ${JSON.stringify(item.from)};`).join('\n');
+    if (imports) {
+        out.push(imports);
     }
-  ]).map(
-    (item) => `import { ${item.names.join(", ")} } from ${JSON.stringify(item.from)};`
-  ).join("\n");
-  return `---
-${banner}
----
-
-${finalImports}
-
-${content}`;
+    out.push(content);
+    return out.join('\n\n');
 }
 
-// src/utils/id-to-title.ts
 function idToTitle(id) {
-  const result = [];
-  for (const c of id) {
-    if (result.length === 0) result.push(c.toLocaleUpperCase());
-    else if (/^[A-Z]$/.test(c) && result.at(-1) !== " ") result.push(" ", c);
-    else if (c === "-") result.push(" ");
-    else result.push(c);
-  }
-  return result.join("");
-}
-
-// src/endpoint.ts
-import { sample as sample2 } from "openapi-sampler";
-
-// src/utils/schema.ts
-function noRef(v) {
-  return v;
-}
-function getPreferredMedia(body) {
-  const type = getPreferredType(body);
-  if (type) return body[type];
-}
-function getPreferredType(body) {
-  if ("application/json" in body) return "application/json";
-  return Object.keys(body)[0];
-}
-function toSampleInput(value) {
-  return typeof value === "string" ? value : JSON.stringify(value, null, 2);
-}
-
-// src/utils/generate-input.ts
-import { sample } from "openapi-sampler";
-function generateInput(method, schema) {
-  return sample(schema, {
-    skipReadOnly: method !== "GET",
-    skipWriteOnly: method === "GET"
-  });
-}
-
-// src/endpoint.ts
-function createEndpoint(path, method, baseUrl) {
-  const params = [];
-  const responses = {};
-  for (const param of method.parameters) {
-    if (param.schema) {
-      params.push({
-        name: param.name,
-        in: param.in,
-        schema: noRef(param.schema),
-        sample: param.example ?? sample2(param.schema)
-      });
-    } else if (param.content) {
-      const key = getPreferredType(param.content);
-      const content = key ? param.content[key] : void 0;
-      if (!key || !content?.schema)
-        throw new Error(
-          `Cannot find parameter schema for ${param.name} in ${path} ${method.method}`
-        );
-      params.push({
-        name: param.name,
-        in: param.in,
-        schema: noRef(content.schema),
-        sample: content.example ?? param.example ?? sample2(content.schema)
-      });
+    let result = [];
+    for (const c of id){
+        if (result.length === 0) result.push(c.toLocaleUpperCase());
+        else if (c === '.') result = [];
+        else if (/^[A-Z]$/.test(c) && result.at(-1) !== ' ') result.push(' ', c);
+        else if (c === '-') result.push(' ');
+        else result.push(c);
     }
-  }
-  let bodyOutput;
-  if (method.requestBody) {
-    const body = noRef(method.requestBody).content;
-    const type = getPreferredType(body);
-    const schema = type ? noRef(body[type].schema) : void 0;
-    if (!type || !schema)
-      throw new Error(`Cannot find body schema for ${path} ${method.method}`);
-    bodyOutput = {
-      schema,
-      mediaType: type,
-      sample: body[type].example ?? generateInput(method.method, schema)
-    };
-  }
-  for (const [code, value] of Object.entries(method.responses)) {
-    const mediaTypes = noRef(value).content ?? {};
-    const responseSchema = noRef(getPreferredMedia(mediaTypes)?.schema);
-    if (!responseSchema) continue;
-    responses[code] = {
-      schema: responseSchema
-    };
-  }
-  let pathWithParameters = path;
-  const queryParams = new URLSearchParams();
-  for (const param of params) {
-    const value = generateInput(method.method, param.schema);
-    if (param.in === "query")
-      queryParams.append(param.name, toSampleInput(value));
-    if (param.in === "path")
-      pathWithParameters = pathWithParameters.replace(
-        `{${param.name}}`,
-        toSampleInput(value)
-      );
-  }
-  if (queryParams.size > 0)
-    pathWithParameters = `${pathWithParameters}?${queryParams.toString()}`;
-  return {
-    url: new URL(`${baseUrl}${pathWithParameters}`).toString(),
-    body: bodyOutput,
-    responses,
-    method: method.method,
-    parameters: params
-  };
-}
-
-// src/utils/generate-response.ts
-function getExampleResponse(endpoint, code) {
-  if (code in endpoint.responses) {
-    const value = generateInput(
-      endpoint.method,
-      endpoint.responses[code].schema
-    );
-    return JSON.stringify(value, null, 2);
-  }
+    return result.join('');
 }
 
-// src/requests/curl.ts
-function getSampleRequest(endpoint) {
-  const s = [];
-  s.push(`curl -X ${endpoint.method} "${endpoint.url}"`);
-  for (const param of endpoint.parameters) {
-    if (param.in === "header") {
-      const header = `${param.name}: ${toSampleInput(param.sample)}`;
-      s.push(`-H "${header}"`);
-    }
-  }
-  if (endpoint.body?.mediaType === "multipart/form-data")
-    console.warn("Curl sample with form data body isn't supported.");
-  if (endpoint.body) s.push(`-d '${toSampleInput(endpoint.body.sample)}'`);
-  return s.join(" \\\n  ");
-}
-
-// src/requests/javascript.ts
-function getSampleRequest2(endpoint) {
-  const s = [];
-  const options = /* @__PURE__ */ new Map();
-  const headers = {};
-  for (const param of endpoint.parameters) {
-    if (param.in === "header") {
-      headers[param.name] = generateInput(endpoint.method, param.schema);
+async function generateAll(pathOrDocument, options = {}) {
+    const document = await Parser.dereference(pathOrDocument);
+    const routes = buildRoutes(document).get('all') ?? [];
+    const operations = [];
+    for (const route of routes){
+        for (const method of route.methods){
+            operations.push({
+                method: method.method.toLowerCase(),
+                path: route.path
+            });
+        }
     }
-  }
-  options.set("method", JSON.stringify(endpoint.method));
-  if (Object.keys(headers).length > 0) {
-    options.set("headers", JSON.stringify(headers, void 0, 2));
-  }
-  if (endpoint.body?.mediaType === "multipart/form-data" && typeof endpoint.body.sample === "object" && endpoint.body.sample) {
-    s.push(`const formData = new FormData();`);
-    for (const [key, value] of Object.entries(endpoint.body.sample))
-      s.push(`formData.set(${key}, ${JSON.stringify(value)})`);
-    options.set("body", "formData");
-  } else if (endpoint.body) {
-    options.set(
-      "body",
-      `JSON.stringify(${JSON.stringify(endpoint.body.sample, null, 2).split("\n").map((v, i) => i > 0 ? `  ${v}` : v).join("\n")})`
-    );
-  }
-  const optionsStr = Array.from(options.entries()).map(([k, v]) => `  ${k}: ${v}`).join(",\n");
-  s.push(`fetch(${JSON.stringify(endpoint.url)}, {
-${optionsStr}
-});`);
-  return s.join("\n\n");
-}
-
-// src/utils/get-typescript-schema.ts
-import { compile } from "json-schema-to-typescript";
-async function getTypescriptSchema(endpoint, code) {
-  if (code in endpoint.responses) {
-    return compile(endpoint.responses[code].schema, "Response", {
-      bannerComment: "",
-      additionalProperties: false,
-      format: true,
-      enableConstEnums: false
+    return generateDocument(pageContent(document, {
+        operations,
+        hasHead: true
+    }), options, {
+        title: document.info.title,
+        description: document.info.description,
+        context: {
+            type: 'file',
+            routes
+        }
     });
-  }
 }
-
-// src/utils/get-security.ts
-function getScheme(requirement, document) {
-  const results = [];
-  const schemas = document.components?.securitySchemes ?? {};
-  for (const [key, scopes] of Object.entries(requirement)) {
-    if (!(key in schemas)) return [];
-    const schema = noRef(schemas[key]);
-    results.push({
-      ...schema,
-      scopes
+async function generateOperations(pathOrDocument, options = {}) {
+    const document = await Parser.dereference(pathOrDocument);
+    const routes = buildRoutes(document).get('all') ?? [];
+    return routes.flatMap((route)=>{
+        return route.methods.map((method)=>{
+            if (!method.operationId) throw new Error('Operation ID is required for generating docs.');
+            const content = generateDocument(pageContent(document, {
+                operations: [
+                    {
+                        path: route.path,
+                        method: method.method.toLowerCase()
+                    }
+                ],
+                hasHead: false
+            }), options, {
+                title: method.summary ?? idToTitle(method.operationId),
+                description: method.description,
+                context: {
+                    type: 'operation',
+                    endpoint: method,
+                    route
+                }
+            });
+            return {
+                content,
+                route,
+                method
+            };
+        });
     });
-  }
-  return results;
-}
-
-// src/render/playground.ts
-function renderPlayground(path, method, ctx) {
-  let currentId = 0;
-  const bodyContent = noRef(method.requestBody)?.content;
-  const mediaType = bodyContent ? getPreferredType(bodyContent) : void 0;
-  const context = {
-    allowFile: mediaType === "multipart/form-data",
-    schema: {},
-    nextId() {
-      return String(currentId++);
-    },
-    registered: /* @__PURE__ */ new WeakMap()
-  };
-  return ctx.renderer.APIPlayground({
-    authorization: getAuthorizationField(method, ctx),
-    method: method.method,
-    route: path,
-    bodyType: mediaType === "multipart/form-data" ? "form-data" : "json",
-    path: method.parameters.filter((v) => v.in === "path").map((v) => parameterToField(v, context)),
-    query: method.parameters.filter((v) => v.in === "query").map((v) => parameterToField(v, context)),
-    header: method.parameters.filter((v) => v.in === "header").map((v) => parameterToField(v, context)),
-    body: bodyContent && mediaType && bodyContent[mediaType].schema ? toSchema(noRef(bodyContent[mediaType].schema), true, context) : void 0,
-    schemas: context.schema
-  });
-}
-function getAuthorizationField(method, ctx) {
-  const security = method.security ?? ctx.document.security ?? [];
-  if (security.length === 0) return;
-  const singular = security.find(
-    (requirements) => Object.keys(requirements).length === 1
-  );
-  if (!singular) return;
-  const scheme = getScheme(singular, ctx.document)[0];
-  return {
-    type: "string",
-    name: "Authorization",
-    defaultValue: scheme.type === "oauth2" || scheme.type === "http" && scheme.scheme === "bearer" ? "Bearer" : "Basic",
-    isRequired: security.every(
-      (requirements) => Object.keys(requirements).length > 0
-    ),
-    description: "The Authorization access token"
-  };
-}
-function getIdFromSchema(schema, required, ctx) {
-  const registered = ctx.registered.get(schema);
-  if (registered === void 0) {
-    const id = ctx.nextId();
-    ctx.registered.set(schema, id);
-    ctx.schema[id] = toSchema(schema, required, ctx);
-    return id;
-  }
-  return registered;
 }
-function parameterToField(v, ctx) {
-  return {
-    name: v.name,
-    ...toSchema(
-      noRef(v.schema) ?? { type: "string" },
-      v.required ?? false,
-      ctx
-    )
-  };
-}
-function toReference(schema, required, ctx) {
-  return {
-    type: "ref",
-    isRequired: required,
-    schema: getIdFromSchema(schema, false, ctx)
-  };
-}
-function toSchema(schema, required, ctx) {
-  if (schema.type === "array") {
-    return {
-      type: "array",
-      description: schema.description ?? schema.title,
-      isRequired: required,
-      items: getIdFromSchema(noRef(schema.items), false, ctx)
-    };
-  }
-  if (schema.type === "object" || schema.properties !== void 0 || schema.allOf !== void 0) {
-    const properties = {};
-    Object.entries(schema.properties ?? {}).forEach(([key, prop]) => {
-      properties[key] = toReference(
-        noRef(prop),
-        schema.required?.includes(key) ?? false,
-        ctx
-      );
-    });
-    schema.allOf?.forEach((c) => {
-      const field = toSchema(noRef(c), true, ctx);
-      if (field.type === "object") Object.assign(properties, field.properties);
+async function generateTags(pathOrDocument, options = {}) {
+    const document = await Parser.dereference(pathOrDocument);
+    const tags = Array.from(buildRoutes(document).entries());
+    return tags.filter(([tag])=>tag !== 'all').map(([tag, routes])=>{
+        const info = document.tags?.find((t)=>t.name === tag);
+        const operations = [];
+        for (const route of routes){
+            for (const method of route.methods){
+                operations.push({
+                    method: method.method.toLowerCase(),
+                    path: route.path
+                });
+            }
+        }
+        return {
+            tag,
+            content: generateDocument(pageContent(document, {
+                operations,
+                hasHead: true
+            }), options, {
+                title: idToTitle(tag),
+                description: info?.description,
+                context: {
+                    type: 'tag',
+                    tag: info,
+                    routes
+                }
+            })
+        };
     });
-    const additional = noRef(schema.additionalProperties);
-    let additionalProperties;
-    if (additional && typeof additional === "object") {
-      if (!additional.type && !additional.anyOf && !additional.allOf && !additional.oneOf) {
-        additionalProperties = true;
-      } else {
-        additionalProperties = getIdFromSchema(additional, false, ctx);
-      }
-    } else {
-      additionalProperties = additional;
-    }
-    return {
-      type: "object",
-      isRequired: required,
-      description: schema.description ?? schema.title,
-      properties,
-      additionalProperties
+}
+function pageContent(doc, props) {
+    const slugger = new Slugger();
+    const toc = [];
+    const structuredData = {
+        headings: [],
+        contents: []
     };
-  }
-  if (schema.type === void 0) {
-    const combine = schema.anyOf ?? schema.oneOf;
-    if (combine) {
-      return {
-        type: "switcher",
-        description: schema.description ?? schema.title,
-        items: Object.fromEntries(
-          combine.map((c, idx) => {
-            const item = noRef(c);
-            return [
-              item.title ?? item.type ?? `Item ${idx.toString()}`,
-              toReference(item, true, ctx)
-            ];
-          })
-        ),
-        isRequired: required
-      };
+    for (const item of props.operations){
+        const operation = doc.paths[item.path]?.[item.method];
+        if (!operation) continue;
+        if (props.hasHead && operation.operationId) {
+            const title = operation.summary ?? (operation.operationId ? idToTitle(operation.operationId) : item.path);
+            const id = slugger.slug(title);
+            toc.push({
+                depth: 2,
+                title,
+                url: `#${id}`
+            });
+            structuredData.headings.push({
+                content: title,
+                id
+            });
+        }
+        if (operation.description) structuredData.contents.push({
+            content: operation.description,
+            heading: structuredData.headings.at(-1)?.id
+        });
     }
-    return {
-      type: "null",
-      isRequired: false
-    };
-  }
-  if (ctx.allowFile && schema.type === "string" && schema.format === "binary") {
-    return {
-      type: "file",
-      isRequired: required,
-      description: schema.description ?? schema.title
-    };
-  }
-  return {
-    type: schema.type === "integer" ? "number" : schema.type,
-    defaultValue: schema.example ?? "",
-    isRequired: required,
-    description: schema.description ?? schema.title
-  };
-}
+    return `<APIPage operations={${JSON.stringify(props.operations)}} hasHead={${JSON.stringify(props.hasHead)}} />
 
-// src/render/schema.ts
-var keys = {
-  example: "Example",
-  default: "Default",
-  minimum: "Minimum",
-  maximum: "Maximum",
-  minLength: "Minimum length",
-  maxLength: "Maximum length",
-  pattern: "Pattern",
-  format: "Format"
-};
-function isObject(schema) {
-  return schema.type === "object" || schema.properties !== void 0 || schema.additionalProperties !== void 0;
-}
-function schemaElement(name, schema, ctx) {
-  return render(name, schema, {
-    ...ctx,
-    stack: []
-  });
-}
-function render(name, schema, ctx) {
-  if (schema.readOnly && !ctx.readOnly) return "";
-  if (schema.writeOnly && !ctx.writeOnly) return "";
-  const { renderer } = ctx.render;
-  const child = [];
-  function field(key, value) {
-    child.push(span(`${key}: \`${value}\``));
-  }
-  if (isObject(schema) && ctx.parseObject) {
-    const { additionalProperties, properties } = schema;
-    if (additionalProperties === true) {
-      child.push(
-        renderer.Property(
-          {
-            name: "[key: string]",
-            type: "any"
-          },
-          []
-        )
-      );
-    } else if (additionalProperties) {
-      child.push(
-        render("[key: string]", noRef(additionalProperties), {
-          ...ctx,
-          required: false,
-          parseObject: false
-        })
-      );
+export function startup() {
+    if (toc) {
+        // toc might be immutable
+        while (toc.length > 0) toc.pop()
+        toc.push(...${JSON.stringify(toc)})
     }
-    Object.entries(properties ?? {}).forEach(([key, value]) => {
-      child.push(
-        render(key, noRef(value), {
-          ...ctx,
-          required: schema.required?.includes(key) ?? false,
-          parseObject: false
-        })
-      );
-    });
-    return child.join("\n\n");
-  }
-  child.push(p(schema.description));
-  for (const [key, value] of Object.entries(keys)) {
-    if (key in schema) {
-      field(value, JSON.stringify(schema[key]));
+    
+    if (structuredData) {
+        structuredData.headings = ${JSON.stringify(structuredData.headings)}
+        structuredData.contents = ${JSON.stringify(structuredData.contents)}
     }
-  }
-  if (schema.enum) {
-    field(
-      "Value in",
-      schema.enum.map((value) => JSON.stringify(value)).join(" | ")
-    );
-  }
-  if (isObject(schema) && !ctx.parseObject) {
-    child.push(
-      renderer.ObjectCollapsible({ name }, [
-        render(name, schema, {
-          ...ctx,
-          parseObject: true,
-          required: false
-        })
-      ])
-    );
-  } else if (schema.allOf) {
-    child.push(
-      renderer.ObjectCollapsible({ name }, [
-        render(name, combineSchema(schema.allOf.map(noRef)), {
-          ...ctx,
-          parseObject: true,
-          required: false
-        })
-      ])
-    );
-  } else {
-    const mentionedObjectTypes = [
-      ...schema.anyOf ?? schema.oneOf ?? [],
-      ...schema.not ? [schema.not] : [],
-      ...schema.type === "array" ? [schema.items] : []
-    ].map(noRef).filter((s) => isComplexType(s) && !ctx.stack.includes(s));
-    ctx.stack.push(schema);
-    child.push(
-      ...mentionedObjectTypes.map(
-        (s, idx) => renderer.ObjectCollapsible(
-          { name: s.title ?? `Object ${(idx + 1).toString()}` },
-          [
-            render("element", noRef(s), {
-              ...ctx,
-              parseObject: true,
-              required: false
-            })
-          ]
-        )
-      )
-    );
-    ctx.stack.pop();
-  }
-  return renderer.Property(
-    {
-      name,
-      type: getSchemaType(schema, ctx),
-      required: ctx.required,
-      deprecated: schema.deprecated
-    },
-    child
-  );
-}
-function combineSchema(schema) {
-  const result = {
-    type: "object"
-  };
-  function add(s) {
-    result.properties ??= {};
-    if (s.properties) {
-      Object.assign(result.properties, s.properties);
-    }
-    result.additionalProperties ??= {};
-    if (s.additionalProperties === true) {
-      result.additionalProperties = true;
-    } else if (s.additionalProperties && typeof result.additionalProperties !== "boolean") {
-      Object.assign(result.additionalProperties, s.additionalProperties);
-    }
-    if (s.allOf) {
-      add(combineSchema(s.allOf.map(noRef)));
-    }
-  }
-  schema.forEach(add);
-  return result;
-}
-function isComplexType(schema) {
-  if (schema.anyOf ?? schema.oneOf ?? schema.allOf) return true;
-  return isObject(schema) || schema.type === "array";
-}
-function getSchemaType(schema, ctx) {
-  if (schema.nullable) {
-    const type = getSchemaType({ ...schema, nullable: false }, ctx);
-    return type === "unknown" ? "null" : `${type} | null`;
-  }
-  if (schema.title) return schema.title;
-  if (schema.type === "array")
-    return `array<${getSchemaType(noRef(schema.items), ctx)}>`;
-  if (schema.oneOf)
-    return schema.oneOf.map((one) => getSchemaType(noRef(one), ctx)).join(" | ");
-  if (schema.allOf)
-    return schema.allOf.map((one) => getSchemaType(noRef(one), ctx)).join(" & ");
-  if (schema.not) return `not ${getSchemaType(noRef(schema.not), ctx)}`;
-  if (schema.anyOf) {
-    return `Any properties in ${schema.anyOf.map((one) => getSchemaType(noRef(one), ctx)).join(", ")}`;
-  }
-  if (schema.type === "string" && schema.format === "binary" && ctx.allowFile)
-    return "File";
-  if (schema.type) return schema.type;
-  if (isObject(schema)) return "object";
-  return "unknown";
 }
 
-// src/render/operation.ts
-async function renderOperation(path, method, ctx, hasHead = true) {
-  let level = 2;
-  const body = noRef(method.requestBody);
-  const security = method.security ?? ctx.document.security;
-  const info = [];
-  const example = [];
-  if (hasHead) {
-    info.push(
-      heading(
-        level,
-        method.summary ?? (method.operationId ? idToTitle(method.operationId) : path)
-      )
-    );
-    level++;
-    if (method.description) info.push(p(method.description));
-  }
-  info.push(renderPlayground(path, method, ctx));
-  if (security) {
-    info.push(heading(level, "Authorization"));
-    info.push(getAuthSection(security, ctx));
-  }
-  if (body) {
-    const type = getPreferredType(body.content);
-    if (!type)
-      throw new Error(`No supported media type for body content: ${path}`);
-    info.push(
-      heading(level, `Request Body ${!body.required ? "(Optional)" : ""}`),
-      p(body.description),
-      schemaElement("body", noRef(body.content[type].schema ?? {}), {
-        parseObject: true,
-        readOnly: method.method === "GET",
-        writeOnly: method.method !== "GET",
-        required: body.required ?? false,
-        render: ctx,
-        allowFile: type === "multipart/form-data"
-      })
-    );
-  }
-  const parameterGroups = /* @__PURE__ */ new Map();
-  const endpoint = createEndpoint(path, method, ctx.baseUrl);
-  for (const param of method.parameters) {
-    const schema = noRef(
-      param.schema ?? getPreferredMedia(param.content ?? {})?.schema
-    );
-    if (!schema) continue;
-    const content = schemaElement(
-      param.name,
-      {
-        ...schema,
-        description: param.description ?? schema.description,
-        deprecated: (param.deprecated ?? false) || (schema.deprecated ?? false)
-      },
-      {
-        parseObject: false,
-        readOnly: method.method === "GET",
-        writeOnly: method.method !== "GET",
-        required: param.required ?? false,
-        render: ctx,
-        allowFile: false
-      }
-    );
-    const groupName = {
-      path: "Path Parameters",
-      query: "Query Parameters",
-      header: "Header Parameters",
-      cookie: "Cookie Parameters"
-    }[param.in] ?? "Other Parameters";
-    const group = parameterGroups.get(groupName) ?? [];
-    group.push(content);
-    parameterGroups.set(groupName, group);
-  }
-  for (const [group, parameters] of Array.from(parameterGroups.entries())) {
-    info.push(heading(level, group), ...parameters);
-  }
-  info.push(getResponseTable(method));
-  const samples = dedupe([
-    {
-      label: "cURL",
-      source: getSampleRequest(endpoint),
-      lang: "bash"
-    },
-    {
-      label: "JavaScript",
-      source: getSampleRequest2(endpoint),
-      lang: "js"
-    },
-    ...ctx.generateCodeSamples ? await ctx.generateCodeSamples(endpoint) : [],
-    ...method["x-codeSamples"] ?? []
-  ]);
-  example.push(
-    ctx.renderer.Requests(
-      samples.map((s) => s.label),
-      samples.map(
-        (s) => ctx.renderer.Request({
-          name: s.label,
-          code: s.source,
-          language: s.lang
-        })
-      )
-    )
-  );
-  example.push(await getResponseTabs(endpoint, method, ctx));
-  return ctx.renderer.API([
-    ctx.renderer.APIInfo({ method: method.method, route: path }, info),
-    ctx.renderer.APIExample(example)
-  ]);
-}
-function dedupe(samples) {
-  const set = /* @__PURE__ */ new Set();
-  const out = [];
-  for (let i = samples.length - 1; i >= 0; i--) {
-    if (set.has(samples[i].label)) continue;
-    set.add(samples[i].label);
-    out.unshift(samples[i]);
-  }
-  return out;
-}
-function getAuthSection(requirements, { document, renderer }) {
-  const info = [];
-  for (const requirement of requirements) {
-    if (info.length > 0) info.push(`---`);
-    for (const schema of getScheme(requirement, document)) {
-      if (schema.type === "http") {
-        info.push(
-          renderer.Property(
-            {
-              name: "Authorization",
-              type: {
-                basic: "Basic <token>",
-                bearer: "Bearer <token>"
-              }[schema.scheme] ?? "<token>",
-              required: true
-            },
-            [p(schema.description), `In: \`header\``]
-          )
-        );
-      }
-      if (schema.type === "oauth2") {
-        info.push(
-          renderer.Property(
-            {
-              name: "Authorization",
-              type: "Bearer <token>",
-              required: true
-            },
-            [
-              p(schema.description),
-              `In: \`header\``,
-              `Scope: \`${schema.scopes.length > 0 ? schema.scopes.join(", ") : "none"}\``
-            ]
-          )
-        );
-      }
-      if (schema.type === "apiKey") {
-        info.push(
-          renderer.Property(
-            {
-              name: schema.name,
-              type: "<token>",
-              required: true
-            },
-            [p(schema.description), `In: \`${schema.in}\``]
-          )
-        );
-      }
-      if (schema.type === "openIdConnect") {
-        info.push(
-          renderer.Property(
-            {
-              name: "OpenID Connect",
-              type: "<token>",
-              required: true
-            },
-            [p(schema.description)]
-          )
-        );
-      }
-    }
-  }
-  return info.join("\n\n");
-}
-function getResponseTable(operation) {
-  const table = [];
-  table.push(`| Status code | Description |`);
-  table.push(`| ----------- | ----------- |`);
-  Object.entries(operation.responses).forEach(([code, value]) => {
-    table.push(`| \`${code}\` | ${noRef(value).description} |`);
-  });
-  return table.join("\n");
-}
-async function getResponseTabs(endpoint, operation, { renderer, generateTypeScriptSchema }) {
-  const items = [];
-  const child = [];
-  for (const code of Object.keys(operation.responses)) {
-    const example = getExampleResponse(endpoint, code);
-    let ts;
-    if (generateTypeScriptSchema) {
-      ts = await generateTypeScriptSchema(endpoint, code);
-    } else if (generateTypeScriptSchema === void 0) {
-      ts = await getTypescriptSchema(endpoint, code);
-    }
-    const description = code in endpoint.responses ? endpoint.responses[code].schema.description : void 0;
-    if (example) {
-      items.push(code);
-      child.push(
-        renderer.Response({ value: code }, [
-          p(description),
-          renderer.ResponseTypes([
-            renderer.ExampleResponse(example),
-            ...ts ? [renderer.TypeScriptResponse(ts)] : []
-          ])
-        ])
-      );
-    }
-  }
-  if (items.length === 0) return "";
-  return renderer.Responses(
-    {
-      items
-    },
-    child
-  );
+{startup()}`;
 }
 
-// src/generate.ts
-async function generate(pathOrDocument, options = {}) {
-  const document = await Parser.dereference(pathOrDocument);
-  const routes = buildRoutes(document).get("all") ?? [];
-  const ctx = getContext(document, options);
-  const child = [];
-  for (const route of routes) {
-    for (const method of route.methods) {
-      child.push(await renderOperation(route.path, method, ctx));
-    }
-  }
-  return generateDocument(
-    ctx.renderer.Root({ baseUrl: ctx.baseUrl }, child),
-    options,
-    {
-      ...document.info,
-      context: {
-        type: "file",
-        routes
-      }
-    }
-  );
-}
-async function generateOperations(pathOrDocument, options = {}) {
-  const document = await Parser.dereference(pathOrDocument);
-  const routes = buildRoutes(document).get("all") ?? [];
-  const ctx = getContext(document, options);
-  return await Promise.all(
-    routes.flatMap((route) => {
-      return route.methods.map(async (method) => {
-        if (!method.operationId)
-          throw new Error("Operation ID is required for generating docs.");
-        const content = generateDocument(
-          ctx.renderer.Root({ baseUrl: ctx.baseUrl }, [
-            await renderOperation(route.path, method, ctx, false)
-          ]),
-          options,
-          {
-            title: method.summary ?? method.method,
-            description: method.description,
-            context: {
-              type: "operation",
-              endpoint: method,
-              route
-            }
-          }
-        );
-        return {
-          id: method.operationId,
-          content,
-          route
-        };
-      });
-    })
-  );
-}
-async function generateTags(pathOrDocument, options = {}) {
-  const document = await Parser.dereference(pathOrDocument);
-  const tags = Array.from(buildRoutes(document).entries());
-  const ctx = getContext(document, options);
-  return await Promise.all(
-    tags.filter(([tag]) => tag !== "all").map(async ([tag, routes]) => {
-      const info = document.tags?.find((t) => t.name === tag);
-      const child = [];
-      for (const route of routes) {
-        for (const method of route.methods) {
-          child.push(await renderOperation(route.path, method, ctx));
+async function generateFiles({ input, output, name: nameFn, per = 'file', cwd = process.cwd(), groupBy = 'none', ...options }) {
+    const outputDir = join(cwd, output);
+    const resolvedInputs = await fg.glob(input, {
+        absolute: true,
+        cwd
+    });
+    await Promise.all(resolvedInputs.map(async (path)=>{
+        if (per === 'file') {
+            let filename = parse(path).name;
+            if (nameFn) filename = nameFn('file', filename);
+            const outPath = join(outputDir, `${filename}.mdx`);
+            const result = await generateAll(path, options);
+            await write(outPath, result);
+            console.log(`Generated: ${outPath}`);
+            return;
         }
-      }
-      return {
-        tag,
-        content: generateDocument(
-          ctx.renderer.Root({ baseUrl: ctx.baseUrl }, child),
-          options,
-          {
-            title: idToTitle(tag),
-            description: info?.description,
-            context: {
-              type: "tag",
-              tag: info,
-              routes
-            }
-          }
-        )
-      };
-    })
-  );
-}
-function getContext(document, options) {
-  return {
-    document,
-    renderer: {
-      ...defaultRenderer,
-      ...options.renderer
-    },
-    generateTypeScriptSchema: options.generateTypeScriptSchema,
-    generateCodeSamples: options.generateCodeSamples,
-    baseUrl: document.servers?.[0].url ?? "https://example.com"
-  };
-}
-
-// src/generate-file.ts
-import { mkdir, writeFile } from "fs/promises";
-import { dirname, join, parse } from "path";
-import fg from "fast-glob";
-async function generateFiles({
-  input,
-  output,
-  name: nameFn,
-  per = "file",
-  cwd = process.cwd(),
-  groupByFolder = false,
-  ...options
-}) {
-  const outputDir = join(cwd, output);
-  const resolvedInputs = await fg.glob(input, { absolute: true, cwd });
-  await Promise.all(
-    resolvedInputs.map(async (path) => {
-      let filename = parse(path).name;
-      filename = nameFn?.("file", filename) ?? filename;
-      if (per === "file") {
-        const outPath = join(outputDir, `${filename}.mdx`);
-        const result = await generate(path, options);
-        await write(outPath, result);
-        console.log(`Generated: ${outPath}`);
-        return;
-      }
-      if (per === "operation") {
-        const routeFolders = /* @__PURE__ */ new Set();
-        const results2 = await generateOperations(path, options);
-        await Promise.all(
-          results2.map(async (result) => {
-            const outPath = groupByFolder ? join(
-              outputDir,
-              filename,
-              result.route.summary ? getFilename(result.route.summary) : getFilenameFromRoute(result.route.path),
-              `${getFilename(result.id)}.mdx`
-            ) : join(outputDir, filename, `${getFilename(result.id)}.mdx`);
-            if (groupByFolder && !routeFolders.has(dirname(outPath))) {
-              routeFolders.add(dirname(outPath));
-              if (result.route.summary) {
-                const metaFile = join(dirname(outPath), "meta.json");
-                await write(
-                  metaFile,
-                  JSON.stringify({
-                    title: result.route.summary
-                  })
-                );
-                console.log(`Generated Meta: ${metaFile}`);
-              }
-            }
+        if (per === 'operation') {
+            const metaFiles = new Set();
+            const results = await generateOperations(path, options);
+            await Promise.all(results.map(async (result)=>{
+                let outPath;
+                if (!result.method.operationId) return;
+                const id = result.method.operationId.split('.').at(-1) ?? result.method.operationId;
+                if (groupBy === 'tag' && result.method.tags && result.method.tags.length > 0) {
+                    if (result.method.tags.length > 1) console.warn(`${result.route.path} has more than 1 tag, which isn't allowed under 'groupBy: tag'. Only the first tag will be considered.`);
+                    outPath = join(outputDir, getFilename(result.method.tags[0]), `${getFilename(id)}.mdx`);
+                } else if (groupBy === 'route') {
+                    outPath = join(outputDir, result.route.summary ? getFilename(result.route.summary) : getFilenameFromRoute(result.route.path), `${getFilename(id)}.mdx`);
+                    const metaFile = join(dirname(outPath), 'meta.json');
+                    if (result.route.summary && !metaFiles.has(metaFile)) {
+                        metaFiles.add(metaFile);
+                        await write(metaFile, JSON.stringify({
+                            title: result.route.summary
+                        }));
+                        console.log(`Generated Meta: ${metaFile}`);
+                    }
+                } else {
+                    outPath = join(outputDir, `${getFilename(id)}.mdx`);
+                }
+                await write(outPath, result.content);
+                console.log(`Generated: ${outPath}`);
+            }));
+            return;
+        }
+        const results = await generateTags(path, options);
+        for (const result of results){
+            let tagName = result.tag;
+            tagName = nameFn?.('tag', tagName) ?? getFilename(tagName);
+            const outPath = join(outputDir, `${tagName}.mdx`);
             await write(outPath, result.content);
             console.log(`Generated: ${outPath}`);
-          })
-        );
-        return;
-      }
-      const results = await generateTags(path, options);
-      for (const result of results) {
-        let tagName = result.tag;
-        tagName = nameFn?.("tag", tagName) ?? getFilename(tagName);
-        const outPath = join(outputDir, filename, `${tagName}.mdx`);
-        await write(outPath, result.content);
-        console.log(`Generated: ${outPath}`);
-      }
-    })
-  );
+        }
+    }));
 }
 function getFilenameFromRoute(path) {
-  return path.split("/").filter((v) => !v.startsWith("{") && !v.endsWith("}")).at(-1) ?? "";
+    return path.replaceAll('.', '/').split('/').filter((v)=>!v.startsWith('{') && !v.endsWith('}')).at(-1) ?? '';
 }
 function getFilename(s) {
-  return s.replace(
-    /[A-Z]/g,
-    (match, idx) => idx === 0 ? match : `-${match.toLowerCase()}`
-  ).replace(/\s+/g, "-").toLowerCase();
+    return s.replace(/[A-Z]/g, (match, idx)=>idx === 0 ? match : `-${match.toLowerCase()}`).replace(/\s+/g, '-').toLowerCase();
 }
 async function write(path, content) {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, content);
+    await mkdir(dirname(path), {
+        recursive: true
+    });
+    await writeFile(path, content);
 }
-export {
-  createElement,
-  defaultRenderer,
-  generate,
-  generateFiles,
-  generateOperations,
-  generateTags
-};
+
+export { generateAll, generateFiles, generateOperations, generateTags };