@contractkit/explorer-ui 0.10.0

package/dist/index.js

@@ -0,0 +1,687 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/html.ts
+var RAW = /* @__PURE__ */ Symbol("raw");
+function raw(value) {
+  return {
+    [RAW]: true,
+    value
+  };
+}
+__name(raw, "raw");
+function isRaw(value) {
+  return typeof value === "object" && value !== null && value[RAW] === true;
+}
+__name(isRaw, "isRaw");
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+__name(escapeHtml, "escapeHtml");
+function renderValue(value) {
+  if (value === null || value === void 0 || value === false) return "";
+  if (isRaw(value)) return value.value;
+  if (Array.isArray(value)) return value.map(renderValue).join("");
+  return escapeHtml(String(value));
+}
+__name(renderValue, "renderValue");
+function html(strings, ...values) {
+  let out = strings[0] ?? "";
+  for (let i = 0; i < values.length; i++) {
+    out += renderValue(values[i]) + (strings[i + 1] ?? "");
+  }
+  return out;
+}
+__name(html, "html");
+function slug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+__name(slug, "slug");
+
+// src/markdown.ts
+function renderMarkdown(input) {
+  if (!input) return "";
+  const lines = input.replace(/\r\n/g, "\n").split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const fence = /^```(\w*)\s*$/.exec(line);
+    if (fence) {
+      const lang = fence[1] ?? "";
+      const buf2 = [];
+      i++;
+      while (i < lines.length && !/^```\s*$/.test(lines[i] ?? "")) {
+        buf2.push(lines[i] ?? "");
+        i++;
+      }
+      i++;
+      const langAttr = lang ? ` data-lang="${escapeHtml(lang)}"` : "";
+      out.push(`<pre class="ce-code"${langAttr}><code>${escapeHtml(buf2.join("\n"))}</code></pre>`);
+      continue;
+    }
+    const heading = /^(#{1,6})\s+(.+)$/.exec(line);
+    if (heading) {
+      const level = heading[1].length;
+      out.push(`<h${level}>${renderInline(heading[2])}</h${level}>`);
+      i++;
+      continue;
+    }
+    if (/^\s*[-*]\s+/.test(line)) {
+      const items = [];
+      while (i < lines.length && /^\s*[-*]\s+/.test(lines[i] ?? "")) {
+        items.push(renderInline((lines[i] ?? "").replace(/^\s*[-*]\s+/, "")));
+        i++;
+      }
+      out.push(`<ul>${items.map((t) => `<li>${t}</li>`).join("")}</ul>`);
+      continue;
+    }
+    if (/^\s*\d+\.\s+/.test(line)) {
+      const items = [];
+      while (i < lines.length && /^\s*\d+\.\s+/.test(lines[i] ?? "")) {
+        items.push(renderInline((lines[i] ?? "").replace(/^\s*\d+\.\s+/, "")));
+        i++;
+      }
+      out.push(`<ol>${items.map((t) => `<li>${t}</li>`).join("")}</ol>`);
+      continue;
+    }
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    const buf = [
+      line
+    ];
+    i++;
+    while (i < lines.length) {
+      const next = lines[i] ?? "";
+      if (next.trim() === "" || /^```/.test(next) || /^#{1,6}\s/.test(next) || /^\s*[-*]\s/.test(next) || /^\s*\d+\.\s/.test(next)) break;
+      buf.push(next);
+      i++;
+    }
+    out.push(`<p>${renderInline(buf.join(" "))}</p>`);
+  }
+  return out.join("\n");
+}
+__name(renderMarkdown, "renderMarkdown");
+function renderInline(text) {
+  let s = escapeHtml(text);
+  s = s.replace(/`([^`]+)`/g, (_m, code) => `<code>${code}</code>`);
+  s = s.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  s = s.replace(/(^|[^*])\*([^*\s][^*]*?)\*(?!\*)/g, (_m, before, body) => `${before}<em>${body}</em>`);
+  s = s.replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, (_m, label, url) => {
+    return `<a href="${url}" rel="noopener noreferrer">${label}</a>`;
+  });
+  return s;
+}
+__name(renderInline, "renderInline");
+
+// src/render-tryit.ts
+function renderTryIt(op, baseUrl) {
+  const id = operationAnchor(op);
+  const pathParams = extractParams(op.routeParams);
+  const queryParams = extractParams(op.op.query);
+  const headerParams = extractParams(op.op.headers);
+  const hasJsonBody = !!op.op.request?.bodies.some((b) => b.contentType === "application/json" || b.contentType.endsWith("+json"));
+  return `<details class="ce-tryit" data-tryit-id="${escapeHtml(id)}">
+        <summary>Try it</summary>
+        <form class="ce-tryit-form" onsubmit="return false;">
+            <label class="ce-tryit-row">
+                <span class="ce-tryit-label">Base URL</span>
+                <input type="text" name="baseUrl" value="${escapeHtml(baseUrl)}" placeholder="https://api.example.com" />
+            </label>
+            ${renderInputSection("Path params", "path", pathParams)}
+            ${renderInputSection("Query", "query", queryParams)}
+            ${renderInputSection("Headers", "header", headerParams)}
+            ${hasJsonBody ? `<label class="ce-tryit-row ce-tryit-col">
+                        <span class="ce-tryit-label">Body (JSON)</span>
+                        <textarea name="body" rows="6" placeholder="{}"></textarea>
+                    </label>` : ""}
+            <div class="ce-tryit-actions">
+                <button type="button" class="ce-tryit-send" data-tryit-action="send" data-tryit-target="${escapeHtml(id)}">
+                    Send ${escapeHtml(op.method.toUpperCase())} ${escapeHtml(op.routePath)}
+                </button>
+            </div>
+            <div class="ce-tryit-response" data-tryit-response="${escapeHtml(id)}"></div>
+        </form>
+    </details>`;
+}
+__name(renderTryIt, "renderTryIt");
+function extractParams(source) {
+  if (!source || source.kind !== "params") return [];
+  return source.nodes;
+}
+__name(extractParams, "extractParams");
+function renderInputSection(label, scope, params) {
+  if (params.length === 0) return "";
+  const rows = params.map((p) => `<label class="ce-tryit-row">
+                <span class="ce-tryit-label"><code>${escapeHtml(p.name)}</code>${p.optional ? "" : " *"}</span>
+                <input type="text"
+                    name="${scope}.${escapeHtml(p.name)}"
+                    placeholder="${escapeHtml(typeHint(p))}"
+                    ${p.default !== void 0 ? `value="${escapeHtml(String(p.default))}"` : ""} />
+            </label>`).join("");
+  return `<fieldset class="ce-tryit-section"><legend>${escapeHtml(label)}</legend>${rows}</fieldset>`;
+}
+__name(renderInputSection, "renderInputSection");
+function typeHint(p) {
+  if (p.type.kind === "scalar") return p.type.name;
+  return p.type.kind;
+}
+__name(typeHint, "typeHint");
+
+// src/constraints.ts
+function constraintSummary(scalar) {
+  const parts = [];
+  if (scalar.min !== void 0) parts.push(`min=${scalar.min}`);
+  if (scalar.max !== void 0) parts.push(`max=${scalar.max}`);
+  if (scalar.len !== void 0) parts.push(`len=${scalar.len}`);
+  if (scalar.regex !== void 0) parts.push(`regex=/${scalar.regex}/`);
+  if (scalar.format !== void 0) parts.push(`format=${scalar.format}`);
+  return parts.length > 0 ? `(${parts.join(", ")})` : "";
+}
+__name(constraintSummary, "constraintSummary");
+
+// src/render-model.ts
+function modelAnchor(name) {
+  return `model-${encodeURIComponent(name)}`;
+}
+__name(modelAnchor, "modelAnchor");
+function renderModel({ filePath, model }, ctx = {}) {
+  const badges = [];
+  if (model.deprecated) badges.push(badge("deprecated", "deprecated"));
+  if (model.mode) badges.push(badge(`mode=${model.mode}`, "mode"));
+  if (model.inputCase) badges.push(badge(`format(input=${model.inputCase})`, "format"));
+  if (model.outputCase) badges.push(badge(`format(output=${model.outputCase})`, "format"));
+  const fieldCtx = {
+    ...ctx,
+    visited: /* @__PURE__ */ new Set([
+      ...ctx.visited ?? [],
+      model.name
+    ])
+  };
+  const inheritance = model.bases && model.bases.length > 0 ? `<p class="ce-extends">extends ${model.bases.map((b) => `<a class="ce-ref" href="#model-${encodeURIComponent(b)}" data-open-model="${escapeHtml(b)}">${escapeHtml(b)}</a>`).join(", ")}</p>` : "";
+  const description = model.description ? `<div class="ce-description ce-markdown">${renderMarkdown(model.description)}</div>` : "";
+  const body = model.type ? `<div class="ce-type-alias">= ${renderType(model.type, fieldCtx)}</div>` : renderFieldRows(model.fields, fieldCtx);
+  return html`<section id="${raw(modelAnchor(model.name))}" class="ce-card ce-model-card">
+        <header class="ce-card-header">
+            <h2>
+                ${model.name}
+                ${raw(badges.join(""))}
+                <button
+                    class="ce-jump"
+                    data-jump-file="${filePath}"
+                    data-jump-line="${model.loc.line}"
+                    title="Open in editor"
+                    type="button"
+                >
+                    ↗
+                </button>
+            </h2>
+        </header>
+        ${raw(inheritance)}
+        ${raw(description)}
+        ${raw(body)}
+    </section>`;
+}
+__name(renderModel, "renderModel");
+function renderFieldRows(fields, ctx = {}) {
+  if (fields.length === 0) return `<p class="ce-empty">No fields.</p>`;
+  const rows = fields.map((f) => {
+    const modifiers = [];
+    if (f.optional) modifiers.push("optional");
+    if (f.nullable) modifiers.push("nullable");
+    if (f.visibility === "readonly") modifiers.push("readonly");
+    if (f.visibility === "writeonly") modifiers.push("writeonly");
+    if (f.deprecated) modifiers.push("deprecated");
+    if (f.override) modifiers.push("override");
+    const modifierHtml = modifiers.map((m) => badge(m, m)).join("");
+    const defaultHtml = f.default !== void 0 ? html`<code class="ce-default">= ${String(f.default)}</code>` : "";
+    const descHtml = f.description ? `<div class="ce-field-desc ce-markdown">${renderMarkdown(f.description)}</div>` : "";
+    return `<tr>
+            <td class="ce-field-name"><code>${escapeHtml(f.name)}</code>${modifierHtml}</td>
+            <td class="ce-field-type">${renderType(f.type, ctx)}${defaultHtml}${descHtml}</td>
+        </tr>`;
+  });
+  return `<table class="ce-fields"><tbody>${rows.join("")}</tbody></table>`;
+}
+__name(renderFieldRows, "renderFieldRows");
+function badge(label, kind) {
+  return `<span class="ce-badge ce-badge-${escapeHtml(kind)}">${escapeHtml(label)}</span>`;
+}
+__name(badge, "badge");
+
+// src/render-type.ts
+var DEFAULT_MAX_DEPTH = 4;
+function renderType(type, ctx = {}) {
+  switch (type.kind) {
+    case "scalar": {
+      const constraint = constraintSummary(type);
+      const constraintHtml = constraint ? `<span class="ce-type-constraint">${escapeHtml(constraint)}</span>` : "";
+      return `<span class="ce-type-scalar">${escapeHtml(type.name)}${constraintHtml}</span>`;
+    }
+    case "enum":
+      return `<span class="ce-type-enum">enum(${type.values.map(escapeHtml).join(", ")})</span>`;
+    case "literal":
+      return `<span class="ce-type-literal">${escapeHtml(typeof type.value === "string" ? `"${type.value}"` : String(type.value))}</span>`;
+    case "ref":
+      return renderRef(type.name, ctx);
+    case "array":
+      return `${tok("Array&lt;")}${renderType(type.item, ctx)}${tok("&gt;")}`;
+    case "tuple":
+      return `${tok("[")}${type.items.map((t) => renderType(t, ctx)).join(tok(", "))}${tok("]")}`;
+    case "record":
+      return `${tok("Record&lt;")}${renderType(type.key, ctx)}${tok(", ")}${renderType(type.value, ctx)}${tok("&gt;")}`;
+    case "union":
+      return type.members.map((m) => renderType(m, ctx)).join(tok(" | "));
+    case "discriminatedUnion":
+      return `${tok(`Union by ${escapeHtml(type.discriminator)}:`)} ` + type.members.map((m) => renderType(m, ctx)).join(tok(" | "));
+    case "intersection":
+      return type.members.map((m) => renderType(m, ctx)).join(tok(" &amp; "));
+    case "lazy":
+      return `${tok("Lazy&lt;")}${renderType(type.inner, ctx)}${tok("&gt;")}`;
+    case "inlineObject":
+      return `<details class="ce-inline-object"><summary>${tok("{ \u2026 }")}</summary>${renderFieldRows(type.fields, ctx)}</details>`;
+  }
+}
+__name(renderType, "renderType");
+function renderRef(name, ctx) {
+  const encName = encodeURIComponent(name);
+  const safeName = escapeHtml(name);
+  const entry = ctx.models?.get(name);
+  const visited = ctx.visited ?? /* @__PURE__ */ new Set();
+  const depth = ctx.depth ?? 0;
+  const maxDepth = ctx.maxDepth ?? DEFAULT_MAX_DEPTH;
+  if (!entry) {
+    return `<a class="ce-ref" href="#model-${encName}">${safeName}</a>`;
+  }
+  if (visited.has(name)) {
+    return `<span class="ce-ref ce-ref-cycle" title="recursive reference">${safeName} \u21BA</span>`;
+  }
+  const model = entry.model;
+  const jumpAttrs = `data-jump-file="${escapeHtml(entry.filePath)}" data-jump-line="${model.loc.line}"`;
+  if (depth >= maxDepth) {
+    return `<a class="ce-ref" href="#model-${encName}" ${jumpAttrs} title="Jump to source">${safeName}</a>`;
+  }
+  const nextCtx = {
+    models: ctx.models,
+    visited: /* @__PURE__ */ new Set([
+      ...visited,
+      name
+    ]),
+    maxDepth,
+    depth: depth + 1
+  };
+  const bases = model.bases && model.bases.length > 0 ? `<p class="ce-extends">extends ${model.bases.map((b) => renderRef(b, nextCtx)).join(", ")}</p>` : "";
+  const body = model.type ? `<div class="ce-type-alias">= ${renderType(model.type, nextCtx)}</div>` : renderFieldRows(model.fields, nextCtx);
+  const openButton = `<button class="ce-ref-open" type="button" ${jumpAttrs} title="Jump to source">\u2197</button>`;
+  return `<details class="ce-ref-expand">
+        <summary><span class="ce-ref-name">${safeName}</span>${openButton}</summary>
+        <div class="ce-ref-body">${bases}${body}</div>
+    </details>`;
+}
+__name(renderRef, "renderRef");
+function tok(text) {
+  return `<span class="ce-type-token">${text}</span>`;
+}
+__name(tok, "tok");
+
+// src/render-operation.ts
+function operationAnchor(op) {
+  const suffix = op.op.sdk ?? op.op.name ?? "";
+  const slug2 = `${op.method}-${op.routePath}-${suffix}`.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `op-${slug2}`;
+}
+__name(operationAnchor, "operationAnchor");
+function renderOperation(op, options = {}) {
+  const ctx = options.ctx ?? {};
+  const badges = [];
+  for (const m of op.effectiveModifiers) {
+    badges.push(badge2(m, m));
+  }
+  const securityBadge = renderSecurityBadge(op.effectiveSecurity);
+  if (securityBadge) badges.push(securityBadge);
+  const description = op.op.description ? `<div class="ce-description ce-markdown">${renderMarkdown(op.op.description)}</div>` : "";
+  const service = op.op.service ? html`<p class="ce-meta"><strong>service:</strong> <code>${op.op.service}</code></p>` : "";
+  const signature = op.op.signature ? html`<p class="ce-meta"><strong>signature:</strong> <code>${op.op.signature}</code>${op.op.signatureDescription ? raw(` \u2014 ${escapeHtml(op.op.signatureDescription)}`) : ""}</p>` : "";
+  const pathParams = renderParamSection("Path params", op.routeParams, ctx);
+  const queryParams = renderParamSection("Query", op.op.query, ctx);
+  const headerParams = renderParamSection("Headers", op.op.headers, ctx);
+  const requestBody = renderRequest(op.op.request, ctx);
+  const responses = renderResponses(op.op.responses, ctx);
+  const pluginExt = renderPluginExtensions(op.op.pluginExtensions);
+  const tryIt = options.tryItBaseUrl !== void 0 ? renderTryIt(op, options.tryItBaseUrl) : "";
+  return html`<section id="${raw(operationAnchor(op))}" class="ce-card ce-op-card">
+        <header class="ce-card-header">
+            <h2>
+                <span class="ce-method ce-method-${raw(op.method)}">${op.method.toUpperCase()}</span>
+                <code class="ce-path">${op.routePath}</code>
+                ${raw(badges.join(""))}
+                <button
+                    class="ce-jump"
+                    data-jump-file="${op.filePath}"
+                    data-jump-line="${op.op.loc.line}"
+                    title="Open in editor"
+                    type="button"
+                >
+                    ↗
+                </button>
+            </h2>
+            ${op.op.name ? raw(`<p class="ce-op-name">${escapeHtml(op.op.name)}</p>`) : ""}
+        </header>
+        ${raw(description)}
+        ${raw(service)}
+        ${raw(signature)}
+        ${raw(pathParams)}
+        ${raw(queryParams)}
+        ${raw(headerParams)}
+        ${raw(requestBody)}
+        ${raw(responses)}
+        ${raw(pluginExt)}
+        ${raw(tryIt)}
+    </section>`;
+}
+__name(renderOperation, "renderOperation");
+function renderSecurityBadge(security) {
+  if (!security) return "";
+  if (security === "none") return badge2("security: none", "security-none");
+  if (security.policy === false) return badge2("security: bypassed", "security-bypassed");
+  if (typeof security.policy === "string") return badge2(`policy: ${security.policy}`, "security-policy");
+  return "";
+}
+__name(renderSecurityBadge, "renderSecurityBadge");
+function renderParamSection(label, source, ctx) {
+  if (!source) return "";
+  if (source.kind === "params") {
+    if (source.nodes.length === 0) return "";
+    return html`<section class="ce-subsection">
+            <h3>${label}</h3>
+            ${raw(renderParamTable(source.nodes, ctx))}
+        </section>`;
+  }
+  if (source.kind === "ref") {
+    return html`<section class="ce-subsection">
+            <h3>${label}</h3>
+            <div>${raw(renderType({
+      kind: "ref",
+      name: source.name
+    }, ctx))}</div>
+        </section>`;
+  }
+  return html`<section class="ce-subsection">
+        <h3>${label}</h3>
+        <div>${raw(renderType(source.node, ctx))}</div>
+    </section>`;
+}
+__name(renderParamSection, "renderParamSection");
+function renderParamTable(params, ctx) {
+  const rows = params.map((p) => {
+    const modifiers = [];
+    if (p.optional) modifiers.push("optional");
+    if (p.nullable) modifiers.push("nullable");
+    const modifierHtml = modifiers.map((m) => badge2(m, m)).join("");
+    const defaultHtml = p.default !== void 0 ? html`<code class="ce-default">= ${String(p.default)}</code>` : "";
+    const descHtml = p.description ? `<div class="ce-field-desc ce-markdown">${renderMarkdown(p.description)}</div>` : "";
+    return `<tr>
+            <td class="ce-field-name"><code>${escapeHtml(p.name)}</code>${modifierHtml}</td>
+            <td class="ce-field-type">${renderType(p.type, ctx)}${defaultHtml}${descHtml}</td>
+        </tr>`;
+  });
+  return `<table class="ce-fields"><tbody>${rows.join("")}</tbody></table>`;
+}
+__name(renderParamTable, "renderParamTable");
+function renderRequest(request, ctx) {
+  if (!request || request.bodies.length === 0) return "";
+  const blocks = request.bodies.map((body) => {
+    return `<div class="ce-body-block">
+            <p class="ce-content-type"><code>${escapeHtml(body.contentType)}</code></p>
+            <div>${renderType(body.bodyType, ctx)}</div>
+        </div>`;
+  });
+  return `<section class="ce-subsection"><h3>Request body</h3>${blocks.join("")}</section>`;
+}
+__name(renderRequest, "renderRequest");
+function renderResponses(responses, ctx) {
+  if (responses.length === 0) return "";
+  const blocks = responses.map((r) => renderResponse(r, ctx));
+  return `<section class="ce-subsection"><h3>Responses</h3>${blocks.join("")}</section>`;
+}
+__name(renderResponses, "renderResponses");
+function renderResponse(response, ctx) {
+  const statusClass = `ce-status-${Math.floor(response.statusCode / 100)}xx`;
+  const contentTypeHtml = response.contentType ? `<p class="ce-content-type"><code>${escapeHtml(response.contentType)}</code></p>` : "";
+  const bodyHtml = response.bodyType ? `<div>${renderType(response.bodyType, ctx)}</div>` : '<p class="ce-empty">No body.</p>';
+  const headersHtml = renderResponseHeaders(response.headers, ctx);
+  return `<div class="ce-response-block">
+        <h4><span class="ce-status ${statusClass}">${response.statusCode}</span></h4>
+        ${contentTypeHtml}
+        ${bodyHtml}
+        ${headersHtml}
+    </div>`;
+}
+__name(renderResponse, "renderResponse");
+function renderResponseHeaders(headers, ctx) {
+  if (!headers || headers.length === 0) return "";
+  const rows = headers.map((h) => {
+    const optional = h.optional ? badge2("optional", "optional") : "";
+    const desc = h.description ? `<div class="ce-field-desc ce-markdown">${renderMarkdown(h.description)}</div>` : "";
+    return `<tr>
+            <td class="ce-field-name"><code>${escapeHtml(h.name)}</code>${optional}</td>
+            <td class="ce-field-type">${renderType(h.type, ctx)}${desc}</td>
+        </tr>`;
+  });
+  return `<h5>Headers</h5><table class="ce-fields"><tbody>${rows.join("")}</tbody></table>`;
+}
+__name(renderResponseHeaders, "renderResponseHeaders");
+function renderPluginExtensions(ext) {
+  if (!ext || Object.keys(ext).length === 0) return "";
+  const json = JSON.stringify(ext, null, 2);
+  return html`<section class="ce-subsection">
+        <h3>Plugin extensions</h3>
+        <details><summary>Show JSON</summary><pre class="ce-code">${json}</pre></details>
+    </section>`;
+}
+__name(renderPluginExtensions, "renderPluginExtensions");
+function badge2(label, kind) {
+  return `<span class="ce-badge ce-badge-${escapeHtml(kind)}">${escapeHtml(label)}</span>`;
+}
+__name(badge2, "badge");
+
+// src/render.ts
+var METHOD_ORDER = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete"
+];
+function renderApp(data) {
+  const warnings = renderWarnings(data.warnings);
+  const overview = renderOverview(data);
+  const sidebar = renderSidebar(data);
+  const operations = sortOperations(data.operations);
+  const opsHtml = operations.map((op) => renderOperation(op)).join("");
+  const modelsHtml = [
+    ...data.models
+  ].sort((a, b) => a.model.name.localeCompare(b.model.name)).map((m) => renderModel(m)).join("");
+  return html`<div class="ce-layout">
+        ${raw(sidebar)}
+        <main class="ce-detail">
+            ${raw(warnings)}
+            ${raw(overview)}
+            ${operations.length > 0 ? raw(`<section class="ce-section"><h1 id="endpoints">Endpoints</h1>${opsHtml}</section>`) : ""}
+            ${data.models.length > 0 ? raw(`<section class="ce-section"><h1 id="models">Models</h1>${modelsHtml}</section>`) : ""}
+        </main>
+    </div>`;
+}
+__name(renderApp, "renderApp");
+function renderOverview(data) {
+  const { configMeta } = data;
+  const description = configMeta.description ? html`<p class="ce-description">${configMeta.description}</p>` : "";
+  const servers = configMeta.servers && configMeta.servers.length > 0 ? `<section class="ce-subsection"><h3>Servers</h3><ul>${configMeta.servers.map((s) => `<li><code>${escapeHtml(s.url)}</code>${s.description ? ` \u2014 ${escapeHtml(s.description)}` : ""}</li>`).join("")}</ul></section>` : "";
+  return html`<section id="overview" class="ce-section ce-overview">
+        <h1>${configMeta.title}</h1>
+        <p class="ce-version">v${configMeta.version}</p>
+        ${raw(description)}
+        ${raw(servers)}
+    </section>`;
+}
+__name(renderOverview, "renderOverview");
+function renderSidebar(data) {
+  const operations = sortOperations(data.operations);
+  const groups = groupBy(operations, (op) => op.fileGroup);
+  const groupKeys = [
+    ...groups.keys()
+  ].sort();
+  const endpointGroups = groupKeys.map((key) => {
+    const items = groups.get(key).map((op) => `<li><a href="#${escapeHtml(operationAnchor(op))}">
+                            <span class="ce-method ce-method-${escapeHtml(op.method)}">${escapeHtml(op.method.toUpperCase())}</span>
+                            <span class="ce-sidebar-path">${escapeHtml(op.routePath)}</span>
+                        </a></li>`).join("");
+    return `<details open class="ce-sidebar-group">
+                <summary>${escapeHtml(key)}</summary>
+                <ul>${items}</ul>
+            </details>`;
+  }).join("");
+  const modelLinks = [
+    ...data.models
+  ].sort((a, b) => a.model.name.localeCompare(b.model.name)).map((m) => `<li><a href="#${escapeHtml(modelAnchor(m.model.name))}">${escapeHtml(m.model.name)}</a></li>`).join("");
+  return `<aside class="ce-sidebar">
+        <nav>
+            <section>
+                <h4><a href="#overview">Overview</a></h4>
+            </section>
+            ${operations.length > 0 ? `<section><h4><a href="#endpoints">Endpoints</a></h4>${endpointGroups}</section>` : ""}
+            ${data.models.length > 0 ? `<section><h4><a href="#models">Models</a></h4><ul class="ce-model-list">${modelLinks}</ul></section>` : ""}
+        </nav>
+    </aside>`;
+}
+__name(renderSidebar, "renderSidebar");
+function renderWarnings(warnings) {
+  if (warnings.length === 0) return "";
+  const items = warnings.map((w) => `<li>${escapeHtml(w.message)}${w.file ? ` <code>${escapeHtml(w.file)}${w.line ? `:${w.line}` : ""}</code>` : ""}</li>`).join("");
+  return `<div class="ce-warnings"><strong>${warnings.length} warning${warnings.length === 1 ? "" : "s"}</strong><ul>${items}</ul></div>`;
+}
+__name(renderWarnings, "renderWarnings");
+function sortOperations(operations) {
+  return [
+    ...operations
+  ].sort((a, b) => {
+    const groupCmp = a.fileGroup.localeCompare(b.fileGroup);
+    if (groupCmp !== 0) return groupCmp;
+    const pathCmp = a.routePath.localeCompare(b.routePath);
+    if (pathCmp !== 0) return pathCmp;
+    return METHOD_ORDER.indexOf(a.method) - METHOD_ORDER.indexOf(b.method);
+  });
+}
+__name(sortOperations, "sortOperations");
+function groupBy(items, keyFn) {
+  const out = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFn(item);
+    const arr = out.get(key);
+    if (arr) arr.push(item);
+    else out.set(key, [
+      item
+    ]);
+  }
+  return out;
+}
+__name(groupBy, "groupBy");
+
+// src/render-item.ts
+function renderItemPage(data, selection, options = {}) {
+  const body = renderBody(data, selection, options);
+  return html`<div class="ce-detail ce-detail-single">${raw(body)}</div>`;
+}
+__name(renderItemPage, "renderItemPage");
+function renderBody(data, selection, options) {
+  if (selection.kind === "overview") return renderOverviewPage(data);
+  const ctx = {
+    models: buildModelMap(data)
+  };
+  if (selection.kind === "operation") {
+    const op = data.operations.find((o) => operationAnchor(o) === selection.id);
+    if (!op) return renderMissing(`Operation \`${selection.id}\` is not in the current workspace.`);
+    return renderOperation(op, {
+      tryItBaseUrl: options.tryItBaseUrl,
+      ctx
+    });
+  }
+  const model = data.models.find((m) => m.model.name === selection.name);
+  if (!model) return renderMissing(`Model \`${selection.name}\` is not in the current workspace.`);
+  return renderModel(model, ctx);
+}
+__name(renderBody, "renderBody");
+function buildModelMap(data) {
+  const out = /* @__PURE__ */ new Map();
+  for (const entry of data.models) out.set(entry.model.name, entry);
+  return out;
+}
+__name(buildModelMap, "buildModelMap");
+function renderOverviewPage(data) {
+  const { configMeta } = data;
+  const description = configMeta.description ? `<div class="ce-description ce-markdown">${renderMarkdown(configMeta.description)}</div>` : "";
+  const servers = renderServersList(configMeta.servers);
+  const stats = `<dl class="ce-stats">
+        <dt>Endpoints</dt><dd>${data.operations.length}</dd>
+        <dt>Models</dt><dd>${data.models.length}</dd>
+    </dl>`;
+  return html`<section id="overview" class="ce-section ce-overview">
+        <h1>${configMeta.title}</h1>
+        <p class="ce-version">v${configMeta.version}</p>
+        ${raw(description)}
+        ${raw(stats)}
+        ${raw(servers)}
+        <p class="ce-hint">Pick an endpoint or model from the API Explorer in the sidebar to see details.</p>
+    </section>`;
+}
+__name(renderOverviewPage, "renderOverviewPage");
+function renderServersList(servers) {
+  if (!servers || servers.length === 0) return "";
+  const items = servers.map((s) => `<li><code>${escapeHtml(s.url)}</code>${s.description ? ` \u2014 ${escapeHtml(s.description)}` : ""}</li>`).join("");
+  return `<section class="ce-subsection"><h3>Servers</h3><ul>${items}</ul></section>`;
+}
+__name(renderServersList, "renderServersList");
+function renderMissing(message) {
+  return `<section class="ce-card ce-missing"><p class="ce-empty">${escapeHtml(message)}</p></section>`;
+}
+__name(renderMissing, "renderMissing");
+var operationId = operationAnchor;
+var modelId = /* @__PURE__ */ __name((name) => modelAnchor(name), "modelId");
+function listSelections(data) {
+  return [
+    ...data.operations.map((operation) => ({
+      kind: "operation",
+      id: operationId(operation),
+      operation
+    })),
+    ...data.models.map((model) => ({
+      kind: "model",
+      name: model.model.name,
+      model
+    }))
+  ];
+}
+__name(listSelections, "listSelections");
+export {
+  constraintSummary,
+  escapeHtml,
+  html,
+  listSelections,
+  modelAnchor,
+  modelId,
+  operationAnchor,
+  operationId,
+  raw,
+  renderApp,
+  renderFieldRows,
+  renderItemPage,
+  renderMarkdown,
+  renderModel,
+  renderOperation,
+  renderTryIt,
+  renderType,
+  slug
+};
+//# sourceMappingURL=index.js.map