@mnaoumov/typescript-dev-toolkit 1.3.1 → 2.0.0

package/dist/lib/esm/docs-site/api-doc-page-generation.mjs

@@ -0,0 +1,548 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { getMandatoryNamedGroup } from "@mnaoumov/typescript-lib/reg-exp";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { EVENT_METHODS } from "./api-doc-constants.mjs";
+import {
+  linkBaseType,
+  markdownToHtml,
+  memberHref,
+  renderExampleMdx,
+  renderMdxProse,
+  renderTypeWithLinks,
+  resolveLinks,
+  toTypeFileSegment,
+  toTypeRouteSegment,
+  typeLink
+} from "./api-doc-link-rendering.mjs";
+import { getApiDocSettings } from "./api-doc-settings.mjs";
+import {
+  ensureDirectory,
+  escapeJsString,
+  escapeJsxAttribute,
+  escapeMarkdown,
+  escapeMdxAngleBrackets,
+  escapeMdxBraces,
+  escapeYaml,
+  getDisplayName,
+  getImportStatement,
+  getNamespaceDirectory,
+  memberRouteSegment,
+  memberSlug,
+  overloadRouteSegment,
+  overloadSlug,
+  stripMarkdown,
+  truncateSignature
+} from "./api-doc-text-utils.mjs";
+import { API_COMPONENTS_IMPORT_PREFIX } from "./docs-site-assets.mjs";
+const JSON_INDENT = 2;
+async function appendBacklinksAndWrite(pageContents, allTypes) {
+  const backlinks = buildBacklinksFromContent(pageContents, allTypes);
+  for (const [key, { content, filePath }] of pageContents) {
+    const typeBacklinks = backlinks.get(key) ?? [];
+    const lines = [content];
+    if (typeBacklinks.length > 0) {
+      const sortedBacklinks = [...typeBacklinks].sort((a, b) => a.localeCompare(b));
+      lines.push("", "---", "", "**Links to this page:**", "");
+      for (const blKey of sortedBacklinks) {
+        const blInfo = ensureNonNullable(allTypes.get(blKey));
+        const blNsDirectory = getNamespaceDirectory(blInfo.namespace);
+        lines.push(`- [${blInfo.name}](${getApiDocSettings().basePath}/api/${blNsDirectory}/${toTypeRouteSegment(blInfo.namespace, blInfo.name)}/)`);
+      }
+    }
+    await writeFile(filePath, lines.join("\n"), "utf-8");
+  }
+}
+function buildBacklinksFromContent(pageContents, allTypes) {
+  const backlinks = /* @__PURE__ */ new Map();
+  const routeKeyToTypeKey = /* @__PURE__ */ new Map();
+  for (const [typeKey, info] of allTypes) {
+    routeKeyToTypeKey.set(`${getNamespaceDirectory(info.namespace)}#${toTypeRouteSegment(info.namespace, info.name)}`, typeKey);
+  }
+  const escapedBase = getApiDocSettings().basePath.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+  const linkPattern = new RegExp(`${escapedBase}/api/(?<path>(?:[a-zA-Z0-9_@-]+/)+)`, "g");
+  for (const [sourceKey, { content }] of pageContents) {
+    const referenced = /* @__PURE__ */ new Set();
+    for (const match of content.matchAll(linkPattern)) {
+      const segments = getMandatoryNamedGroup(match, "path").split("/").filter(Boolean);
+      const typeName = ensureNonNullable(segments.at(-1));
+      const namespace = segments.slice(0, -1).join("/");
+      const routeKey = `${namespace}#${typeName}`;
+      const resolvedKey = routeKeyToTypeKey.get(routeKey);
+      if (resolvedKey !== void 0 && resolvedKey !== sourceKey) {
+        referenced.add(resolvedKey);
+      }
+    }
+    for (const reference of referenced) {
+      if (!backlinks.has(reference)) {
+        backlinks.set(reference, []);
+      }
+      backlinks.get(reference)?.push(sourceKey);
+    }
+  }
+  return backlinks;
+}
+function buildSidebarTree(types) {
+  const root = { children: /* @__PURE__ */ new Map(), types: [] };
+  for (const [, info] of types) {
+    const parts = info.namespace.split("/");
+    let node = root;
+    for (const part of parts) {
+      let child = node.children.get(part);
+      if (!child) {
+        child = { children: /* @__PURE__ */ new Map(), types: [] };
+        node.children.set(part, child);
+      }
+      node = child;
+    }
+    node.types.push(info);
+  }
+  return root;
+}
+function computeOverviewSignature(name, info) {
+  if (info.kind === "function") {
+    const $function = info.methods[0];
+    return $function ? `function ${$function.signature}: ${$function.returnType}` : void 0;
+  }
+  if (info.kind === "type") {
+    return `type ${getDisplayName(info.name, info)} = ${info.typeAliasText ?? "unknown"}`;
+  }
+  return info.kind === "variable" ? `${info.variableKeyword ?? "let"} ${name}: ${info.variableType ?? "unknown"}` : void 0;
+}
+async function generateMemberPages(name, info, allTypes) {
+  const nsDirectory = getNamespaceDirectory(info.namespace);
+  const typeFileDirectory = toTypeFileSegment(info.namespace, name);
+  const typeRouteDirectory = toTypeRouteSegment(info.namespace, name);
+  const componentImports = getComponentImports(["MemberDetail"]);
+  const properties = info.properties.filter((p) => !p.inheritedFrom);
+  for (const property of properties) {
+    const filePath = join(getApiDocSettings().outputDirectory, nsDirectory, typeFileDirectory, `${memberSlug(property.name)}.mdx`);
+    await ensureDirectory(filePath);
+    const propertyTitle = `${name}.${property.name}`;
+    const lines = renderFrontMatter({
+      description: property.description,
+      sidebarLabel: propertyTitle,
+      signature: `${property.signature}: ${property.type}`,
+      slug: `api/${nsDirectory}/${typeRouteDirectory}/${memberRouteSegment(property.name)}`,
+      title: propertyTitle
+    });
+    lines.push(
+      ...componentImports,
+      "",
+      // Breadcrumb
+      `[${name}](${getApiDocSettings().basePath}/api/${nsDirectory}/${typeRouteDirectory}/) \u203A ${property.name}`,
+      ""
+    );
+    const staticAttribute = property.isStatic ? " isStatic={true}" : "";
+    const typeAttribute = ` type="${escapeJsxAttribute(markdownToHtml(renderTypeWithLinks(property.type, allTypes, name, info.namespace)))}"`;
+    const descAttribute = property.description ? ` description="${escapeJsxAttribute(markdownToHtml(resolveLinks(property.description, allTypes, info.namespace)))}"` : "";
+    const remarksAttribute = property.remarks ? ` remarks="${escapeJsxAttribute(markdownToHtml(resolveLinks(property.remarks, allTypes, info.namespace)))}"` : "";
+    const sinceAttribute = property.since ? ` since="${escapeJsxAttribute(property.since)}"` : "";
+    const examplesAttribute = property.examples.length > 0 ? ` examples={${JSON.stringify(property.examples)}}` : "";
+    lines.push(`<MemberDetail${staticAttribute}${typeAttribute}${descAttribute}${remarksAttribute}${sinceAttribute}${examplesAttribute} />`, "");
+    await writeFile(filePath, lines.join("\n"), "utf-8");
+  }
+  const methods = info.methods.filter((m) => !m.inheritedFrom);
+  const overloadGroups = /* @__PURE__ */ new Map();
+  for (const method of methods) {
+    const key = method.overloadKey;
+    if (!overloadGroups.has(key)) {
+      overloadGroups.set(key, []);
+    }
+    overloadGroups.get(key)?.push(method);
+  }
+  for (const [overloadKey, overloads] of overloadGroups) {
+    const fileSlug = overloadSlug(overloadKey);
+    const filePath = join(getApiDocSettings().outputDirectory, nsDirectory, typeFileDirectory, `${fileSlug}.mdx`);
+    await ensureDirectory(filePath);
+    const displayName = `${name}.${overloadKey} method`;
+    const firstOverload = ensureNonNullable(overloads[0]);
+    const lines = renderFrontMatter({
+      description: firstOverload.description,
+      sidebarLabel: `${name}.${overloadKey}`,
+      signature: `${firstOverload.signature}: ${firstOverload.returnType}`,
+      slug: `api/${nsDirectory}/${typeRouteDirectory}/${overloadRouteSegment(overloadKey)}`,
+      title: displayName
+    });
+    lines.push(
+      ...componentImports,
+      "",
+      // Breadcrumb
+      `[${name}](${getApiDocSettings().basePath}/api/${nsDirectory}/${typeRouteDirectory}/) \u203A ${overloadKey}`,
+      ""
+    );
+    for (const overload of overloads) {
+      renderMethodOverloadMdx(lines, overload, name, info.namespace, allTypes);
+      if (overloads.length > 1) {
+        lines.push("---", "");
+      }
+    }
+    await writeFile(filePath, lines.join("\n"), "utf-8");
+  }
+}
+async function generateNamespaceIndexPages(types, allTypes, moduleOverviews) {
+  const namespaces = /* @__PURE__ */ new Map();
+  for (const [, info] of types) {
+    if (!namespaces.has(info.namespace)) {
+      namespaces.set(info.namespace, []);
+    }
+    namespaces.get(info.namespace)?.push(info);
+  }
+  for (const [namespace, nsTypes] of namespaces) {
+    const nsDirectory = getNamespaceDirectory(namespace);
+    const filePath = join(getApiDocSettings().outputDirectory, nsDirectory, "index.mdx");
+    await ensureDirectory(filePath);
+    const overview = moduleOverviews.get(namespace);
+    const lines = renderFrontMatter({
+      description: overview,
+      sidebarLabel: namespace,
+      slug: `api/${nsDirectory}`,
+      title: namespace
+    });
+    if (overview) {
+      lines.push(renderMdxProse(overview, allTypes, namespace), "");
+    }
+    renderNamespaceTable(lines, "Classes", "Class", nsTypes.filter((t) => t.kind === "class"), allTypes, namespace);
+    renderNamespaceTable(lines, "Interfaces", "Interface", nsTypes.filter((t) => t.kind === "interface"), allTypes, namespace);
+    renderNamespaceTable(lines, "Functions", "Function", nsTypes.filter((t) => t.kind === "function"), allTypes, namespace);
+    renderNamespaceTable(lines, "Types", "Type", nsTypes.filter((t) => t.kind === "type"), allTypes, namespace);
+    renderNamespaceTable(lines, "Enums", "Enum", nsTypes.filter((t) => t.kind === "enum"), allTypes, namespace);
+    renderNamespaceTable(lines, "Variables", "Variable", nsTypes.filter((t) => t.kind === "variable"), allTypes, namespace);
+    await writeFile(filePath, lines.join("\n"), "utf-8");
+  }
+  const sortedNamespaces = [...namespaces.keys()].sort((a, b) => a.localeCompare(b));
+  const apiIndexIntro = getApiIndexIntro(sortedNamespaces);
+  const rootLines = renderFrontMatter({
+    description: apiIndexIntro,
+    sidebarLabel: "Overview",
+    slug: "api",
+    title: "API reference"
+  });
+  rootLines.push(apiIndexIntro, "", "## Modules", "");
+  for (const namespace of sortedNamespaces) {
+    rootLines.push(`- [${namespace}](${getApiDocSettings().basePath}/api/${getNamespaceDirectory(namespace)}/)`);
+  }
+  rootLines.push("");
+  const rootFilePath = join(getApiDocSettings().outputDirectory, "index.mdx");
+  await ensureDirectory(rootFilePath);
+  await writeFile(rootFilePath, rootLines.join("\n"), "utf-8");
+}
+async function generateOverviewPage(name, info, allTypes) {
+  const nsDirectory = getNamespaceDirectory(info.namespace);
+  const typeFileSlug = toTypeFileSegment(info.namespace, name);
+  const typeRouteSlug = toTypeRouteSegment(info.namespace, name);
+  const filePath = join(getApiDocSettings().outputDirectory, nsDirectory, typeFileSlug, "index.mdx");
+  await ensureDirectory(filePath);
+  const displayName = getDisplayName(name, info);
+  const lines = renderFrontMatter({
+    description: info.description,
+    sidebarLabel: displayName,
+    signature: computeOverviewSignature(name, info),
+    slug: `api/${nsDirectory}/${typeRouteSlug}`,
+    title: displayName
+  });
+  lines.push(...getComponentImports(["ConstructorBlock", "ImportStatement", "MethodTable", "PropertyTable", "TypeSignature"]), "");
+  if (info.description) {
+    lines.push(renderMdxProse(info.description, allTypes, info.namespace), "");
+  }
+  if (info.remarks) {
+    const remarksBlock = renderMdxProse(info.remarks, allTypes, info.namespace);
+    lines.push(remarksBlock.split("\n").map((line) => line.length > 0 ? `> ${line}` : ">").join("\n"), "");
+  }
+  lines.push(`<ImportStatement text="${escapeJsxAttribute(getImportStatement(info))}" />`, "");
+  for (const example of info.examples) {
+    lines.push("**Example:**", "", renderExampleMdx(example, allTypes, info.namespace), "");
+  }
+  if (info.kind === "function") {
+    renderFunctionPage(lines, info, allTypes);
+    return { content: lines.join("\n"), filePath };
+  }
+  if (info.kind === "variable") {
+    renderVariablePage(lines, name, info, allTypes);
+    return { content: lines.join("\n"), filePath };
+  }
+  if (info.kind === "enum") {
+    renderEnumPage(lines, info, allTypes);
+    return { content: lines.join("\n"), filePath };
+  }
+  if (info.kind === "type") {
+    renderTypeAliasPage(lines, info, allTypes);
+    return { content: lines.join("\n"), filePath };
+  }
+  const typeParamsAttribute = info.typeParameters.length > 0 ? ` typeParams={${JSON.stringify(info.typeParameters)}}` : "";
+  const extendsAttribute = info.baseTypes.length > 0 ? ` extends={${JSON.stringify(info.baseTypes)}}` : "";
+  const implementsAttribute = info.implementsTypes.length > 0 ? ` implements={${JSON.stringify(info.implementsTypes)}}` : "";
+  lines.push(`<TypeSignature kind="${info.kind}" name="${name}"${typeParamsAttribute}${extendsAttribute}${implementsAttribute} />`, "");
+  if (info.baseTypes.length > 0) {
+    const linkedTypes = info.baseTypes.map((t) => linkBaseType(t, allTypes, info.namespace));
+    lines.push(`**Extends:** ${linkedTypes.join(", ")}`, "");
+  }
+  if (info.implementsTypes.length > 0) {
+    const linkedTypes = info.implementsTypes.map((t) => linkBaseType(t, allTypes, info.namespace));
+    lines.push(`**Implements:** ${linkedTypes.join(", ")}`, "");
+  }
+  renderConstructorMdx(lines, name, info, allTypes);
+  renderPropertyTableMdx(lines, info, allTypes);
+  renderMethodTableMdx(lines, info, allTypes);
+  return { content: lines.join("\n"), filePath };
+}
+async function generateSidebarJson(types) {
+  const root = buildSidebarTree(types);
+  const groups = [];
+  const topLevels = [...root.children].sort(([a], [b]) => a.localeCompare(b));
+  for (const [topLevel, child] of topLevels) {
+    groups.push(sidebarTreeToEntries(child, topLevel));
+  }
+  const wrappedSidebar = [{
+    collapsed: false,
+    items: groups,
+    label: "API reference"
+  }];
+  await writeFile(getApiDocSettings().sidebarFile, JSON.stringify(wrappedSidebar, null, JSON_INDENT), "utf-8");
+  console.warn(`Generated sidebar with ${String(groups.length)} top-level module groups`);
+}
+function renderConstructorMdx(lines, name, info, allTypes) {
+  const constructor = info.constructorInfo;
+  if (!constructor) {
+    return;
+  }
+  const ctorSig = `new ${name}${constructor.signature}`;
+  const ctorDesc = constructor.description ? ` description="${escapeJsxAttribute(markdownToHtml(resolveLinks(constructor.description, allTypes, info.namespace)))}"` : "";
+  lines.push(`<ConstructorBlock signature="${escapeJsxAttribute(ctorSig)}"${ctorDesc} />`, "");
+}
+function renderEnumPage(lines, info, allTypes) {
+  lines.push(`<TypeSignature kind="enum" name="${info.name}" />`, "");
+  if (info.enumMembers.length === 0) {
+    return;
+  }
+  lines.push("**Members:**", "", "| Member | Value | Description |", "| :-- | :-- | :-- |");
+  for (const member of info.enumMembers) {
+    const value = member.value ? `\`${escapeMarkdown(member.value)}\`` : "";
+    lines.push(`| \`${member.name}\` | ${value} | ${escapeMarkdown(resolveLinks(member.description, allTypes, info.namespace))} |`);
+  }
+  lines.push("");
+}
+function renderFrontMatter(frontMatter) {
+  return [
+    "---",
+    `title: "${escapeYaml(frontMatter.title)}"`,
+    `slug: "${frontMatter.slug}"`,
+    ...frontMatter.description ? [`description: "${escapeYaml(stripMarkdown(frontMatter.description))}"`] : [],
+    ...frontMatter.signature ? [`signature: "${escapeYaml(truncateSignature(frontMatter.signature))}"`] : [],
+    "editUrl: false",
+    "sidebar:",
+    `  label: "${escapeYaml(frontMatter.sidebarLabel)}"`,
+    "---",
+    ""
+  ];
+}
+function renderFunctionPage(lines, info, allTypes) {
+  const $function = info.methods[0];
+  if (!$function) {
+    return;
+  }
+  lines.push("**Signature:**", "", "```ts", `function ${$function.signature}: ${$function.returnType}`, "```", "");
+  if ($function.parameters.length > 0) {
+    lines.push("**Parameters:**", "", "| Parameter | Type | Description |", "| :-- | :-- | :-- |");
+    for (const parameter of $function.parameters) {
+      lines.push(
+        `| \`${parameter.name}\` | ${escapeMarkdown(escapeMdxAngleBrackets(renderTypeWithLinks(parameter.type, allTypes, info.name, info.namespace)))} | ${escapeMarkdown(resolveLinks(parameter.description, allTypes, info.namespace))} |`
+      );
+    }
+    lines.push("");
+  }
+  const returnDesc = $function.returnDescription ? ` \u2014 ${escapeMdxAngleBrackets(resolveLinks($function.returnDescription, allTypes, info.namespace))}` : "";
+  lines.push(`**Returns:** ${escapeMdxAngleBrackets(renderTypeWithLinks($function.returnType, allTypes, info.name, info.namespace))}${returnDesc}`, "");
+  for (const example of $function.examples) {
+    lines.push("**Example:**", "", renderExampleMdx(example, allTypes, info.namespace), "");
+  }
+}
+function renderMethodOverloadMdx(lines, overload, typeName, namespace, allTypes) {
+  const sig = `${overload.signature}: ${overload.returnType}`;
+  const staticAttribute = overload.isStatic ? " isStatic={true}" : "";
+  const descAttribute = overload.description ? ` description="${escapeJsxAttribute(markdownToHtml(resolveLinks(overload.description, allTypes, namespace)))}"` : "";
+  const remarksAttribute = overload.remarks ? ` remarks="${escapeJsxAttribute(markdownToHtml(resolveLinks(overload.remarks, allTypes, namespace)))}"` : "";
+  const sinceAttribute = overload.since ? ` since="${escapeJsxAttribute(overload.since)}"` : "";
+  const returnTypeAttribute = ` returnType="${escapeJsxAttribute(markdownToHtml(renderTypeWithLinks(overload.returnType, allTypes, typeName, namespace)))}"`;
+  const returnDescAttribute = overload.returnDescription ? ` returnDescription="${escapeJsxAttribute(markdownToHtml(resolveLinks(overload.returnDescription, allTypes, namespace)))}"` : "";
+  const examplesAttribute = overload.examples.length > 0 ? ` examples={${JSON.stringify(overload.examples)}}` : "";
+  const params = overload.parameters.map((p) => ({
+    description: markdownToHtml(p.description || (p.name.endsWith("?") ? "*(Optional)*" : "")),
+    name: p.name,
+    type: markdownToHtml(renderTypeWithLinks(p.type, allTypes, typeName, namespace))
+  }));
+  const paramsAttribute = params.length > 0 ? ` parameters={${JSON.stringify(params)}}` : "";
+  lines.push(
+    `<MemberDetail${staticAttribute} signature="${escapeJsxAttribute(sig)}"${descAttribute}${remarksAttribute}${sinceAttribute}${returnTypeAttribute}${returnDescAttribute}${paramsAttribute}${examplesAttribute} />`,
+    ""
+  );
+}
+function renderMethodTableMdx(lines, info, allTypes) {
+  const methods = [...info.methods].sort((a, b) => {
+    if (a.isStatic !== b.isStatic) {
+      return a.isStatic ? 1 : -1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+  if (methods.length === 0) {
+    return;
+  }
+  lines.push("<MethodTable rows={[");
+  for (const method of methods) {
+    const desc = escapeJsString(markdownToHtml(resolveLinks(method.description, allTypes, info.namespace)));
+    const staticPrefix = method.isStatic ? "static " : "";
+    const shortParams = method.parameters.map((p, index) => {
+      return index === 0 && EVENT_METHODS.has(method.name) && (p.type.startsWith('"') || p.type.startsWith("'")) ? p.type.replaceAll('"', "'") : p.name;
+    }).join(", ");
+    const shortSig = `${staticPrefix}${method.name}(${shortParams})`;
+    const sig = escapeJsString(shortSig);
+    const slug = overloadRouteSegment(method.overloadKey);
+    const returnType = markdownToHtml(renderTypeWithLinks(method.returnType, allTypes, info.name, info.namespace));
+    const inheritedAttribute = method.inheritedFrom ? `, inheritedFrom: "${escapeJsString(markdownToHtml(typeLink(method.inheritedFrom, allTypes, info.namespace)))}"` : "";
+    const href = memberHref(slug, method.inheritedFrom, allTypes, info.namespace);
+    lines.push(
+      `  { signature: "${sig}", href: "${escapeJsString(href)}", returns: "${escapeJsString(returnType)}", description: "${desc}"${inheritedAttribute} },`
+    );
+  }
+  lines.push("]} />", "");
+}
+function renderPropertyTableMdx(lines, info, allTypes) {
+  const properties = info.properties;
+  if (properties.length === 0) {
+    return;
+  }
+  lines.push("<PropertyTable rows={[");
+  for (const property of properties) {
+    const desc = escapeJsString(markdownToHtml(resolveLinks(property.description, allTypes, info.namespace)));
+    const type = markdownToHtml(renderTypeWithLinks(property.type, allTypes, info.name, info.namespace));
+    const inheritedAttribute = property.inheritedFrom ? `, inheritedFrom: "${escapeJsString(markdownToHtml(typeLink(property.inheritedFrom, allTypes, info.namespace)))}"` : "";
+    const href = memberHref(memberRouteSegment(property.name), property.inheritedFrom, allTypes, info.namespace);
+    lines.push(
+      `  { name: "${escapeJsString(property.name)}", href: "${escapeJsString(href)}", type: "${escapeJsString(type)}", description: "${desc}"${inheritedAttribute} },`
+    );
+  }
+  lines.push("]} />", "");
+}
+function renderTypeAliasPage(lines, info, allTypes) {
+  const typeParamsAttribute = info.typeParameters.length > 0 ? ` typeParams={${JSON.stringify(info.typeParameters)}}` : "";
+  lines.push(`<TypeSignature kind="type" name="${info.name}"${typeParamsAttribute} />`, "");
+  const rhs = info.typeAliasText ?? "unknown";
+  lines.push(
+    "**Signature:**",
+    "",
+    "```ts",
+    `type ${getDisplayName(info.name, info)} = ${rhs}`,
+    "```",
+    "",
+    `**Type:** ${escapeMdxBraces(escapeMdxAngleBrackets(renderTypeWithLinks(rhs, allTypes, info.name, info.namespace)))}`,
+    ""
+  );
+}
+function renderVariablePage(lines, name, info, allTypes) {
+  const keyword = info.variableKeyword ?? "let";
+  const variableType = info.variableType ?? "unknown";
+  lines.push(
+    "**Signature:**",
+    "",
+    "```ts",
+    `${keyword} ${name}: ${variableType}`,
+    "```",
+    "",
+    `**Type:** ${escapeMdxBraces(escapeMdxAngleBrackets(renderTypeWithLinks(variableType, allTypes, name, info.namespace)))}`,
+    ""
+  );
+}
+function sidebarTreeToEntries(node, label) {
+  const items = [];
+  const sortedChildren = [...node.children].sort(([a], [b]) => a.localeCompare(b));
+  for (const [childName, child] of sortedChildren) {
+    items.push(sidebarTreeToEntries(child, childName));
+  }
+  if (node.types.length > 0) {
+    const { namespace } = ensureNonNullable(node.types[0]);
+    items.push({ label: "Overview", link: `/api/${namespace}/` });
+    const sortedTypes = [...node.types].sort((a, b) => a.name.localeCompare(b.name));
+    for (const t of sortedTypes) {
+      items.push({ label: t.name, link: `/api/${t.namespace}/${toTypeRouteSegment(t.namespace, t.name)}/` });
+    }
+  }
+  return { collapsed: true, items, label };
+}
+function getApiIndexIntro(namespaces) {
+  const { packageName } = getApiDocSettings();
+  const [exampleNamespace = "module"] = namespaces;
+  return `The complete API reference for \`${packageName}\`, generated from its TSDoc. Each module below maps to an import subpath (e.g. the \`${exampleNamespace}\` module is \`${packageName}/${exampleNamespace}\`).`;
+}
+function getComponentImports(componentNames) {
+  return componentNames.map((componentName) => `import ${componentName} from "${API_COMPONENTS_IMPORT_PREFIX}/${componentName}.astro";`);
+}
+function renderNamespaceTable(lines, heading, columnLabel, entries, allTypes, namespace) {
+  if (entries.length === 0) {
+    return;
+  }
+  const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+  lines.push(`## ${heading}`, "", `| ${columnLabel} | Description |`, "| :-- | :-- |");
+  for (const entry of sorted) {
+    lines.push(`| [${entry.name}](./${toTypeRouteSegment(entry.namespace, entry.name)}/) | ${escapeMarkdown(resolveLinks(entry.description, allTypes, namespace))} |`);
+  }
+  lines.push("");
+}
+export {
+  appendBacklinksAndWrite,
+  buildBacklinksFromContent,
+  buildSidebarTree,
+  computeOverviewSignature,
+  generateMemberPages,
+  generateNamespaceIndexPages,
+  generateOverviewPage,
+  generateSidebarJson,
+  renderConstructorMdx,
+  renderEnumPage,
+  renderFrontMatter,
+  renderFunctionPage,
+  renderMethodOverloadMdx,
+  renderMethodTableMdx,
+  renderPropertyTableMdx,
+  renderTypeAliasPage,
+  renderVariablePage,
+  sidebarTreeToEntries
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/api-doc-page-generation.ts"],"sourcesContent":["/**\n * @file\n *\n * MDX page + sidebar emission: renders module index pages, per-type overview pages, per-member pages,\n * backlinks, and the Starlight sidebar JSON.\n */\n\nimport { getMandatoryNamedGroup } from '@mnaoumov/typescript-lib/reg-exp';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { writeFile } from 'node:fs/promises';\nimport { join } from 'node:path';\n\nimport type {\n  MemberInfo,\n  PageContent,\n  PageFrontMatter,\n  SidebarEntry,\n  SidebarLink,\n  SidebarTreeNode,\n  TypeInfo\n} from './api-doc-types.ts';\n\nimport { EVENT_METHODS } from './api-doc-constants.ts';\nimport {\n  linkBaseType,\n  markdownToHtml,\n  memberHref,\n  renderExampleMdx,\n  renderMdxProse,\n  renderTypeWithLinks,\n  resolveLinks,\n  toTypeFileSegment,\n  toTypeRouteSegment,\n  typeLink\n} from './api-doc-link-rendering.ts';\nimport { getApiDocSettings } from './api-doc-settings.ts';\nimport {\n  ensureDirectory,\n  escapeJsString,\n  escapeJsxAttribute,\n  escapeMarkdown,\n  escapeMdxAngleBrackets,\n  escapeMdxBraces,\n  escapeYaml,\n  getDisplayName,\n  getImportStatement,\n  getNamespaceDirectory,\n  memberRouteSegment,\n  memberSlug,\n  overloadRouteSegment,\n  overloadSlug,\n  stripMarkdown,\n  truncateSignature\n} from './api-doc-text-utils.ts';\nimport { API_COMPONENTS_IMPORT_PREFIX } from './docs-site-assets.ts';\n\nconst JSON_INDENT = 2;\n\n/**\n * Append backlinks to overview pages and write all files. Keyed by qualified `${namespace}#${name}`.\n *\n * @param pageContents - Every overview page's content and path, keyed by qualified id.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n */\nexport async function appendBacklinksAndWrite(\n  pageContents: Map<string, PageContent>,\n  allTypes: Map<string, TypeInfo>\n): Promise<void> {\n  const backlinks = buildBacklinksFromContent(pageContents, allTypes);\n\n  for (const [key, { content, filePath }] of pageContents) {\n    const typeBacklinks = backlinks.get(key) ?? [];\n    const lines = [content];\n    if (typeBacklinks.length > 0) {\n      const sortedBacklinks = [...typeBacklinks].sort((a, b) => a.localeCompare(b));\n      lines.push('', '---', '', '**Links to this page:**', '');\n      for (const blKey of sortedBacklinks) {\n        const blInfo = ensureNonNullable(allTypes.get(blKey));\n        const blNsDirectory = getNamespaceDirectory(blInfo.namespace);\n        lines.push(`- [${blInfo.name}](${getApiDocSettings().basePath}/api/${blNsDirectory}/${toTypeRouteSegment(blInfo.namespace, blInfo.name)}/)`);\n      }\n    }\n    await writeFile(filePath, lines.join('\\n'), 'utf-8');\n  }\n}\n\n/**\n * Build backlinks by scanning generated page content for internal API links. Keyed by qualified id.\n *\n * @param pageContents - Every overview page's content and path, keyed by qualified id.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n * @returns Each referenced type's qualified id mapped to the ids of the pages linking to it.\n */\nexport function buildBacklinksFromContent(\n  pageContents: Map<string, PageContent>,\n  allTypes: Map<string, TypeInfo>\n): Map<string, string[]> {\n  const backlinks = new Map<string, string[]>();\n  // Emitted URLs lowercase the type segment (see toRouteSegment), so map each lowercased route\n  // identity back to its original qualified type key.\n  const routeKeyToTypeKey = new Map<string, string>();\n  for (const [typeKey, info] of allTypes) {\n    routeKeyToTypeKey.set(`${getNamespaceDirectory(info.namespace)}#${toTypeRouteSegment(info.namespace, info.name)}`, typeKey);\n  }\n  const escapedBase = getApiDocSettings().basePath.replaceAll(/[.*+?^${}()|[\\]\\\\]/g, String.raw`\\$&`);\n  const linkPattern = new RegExp(`${escapedBase}/api/(?<path>(?:[a-zA-Z0-9_@-]+/)+)`, 'g');\n  for (const [sourceKey, { content }] of pageContents) {\n    const referenced = new Set<string>();\n\n    for (const match of content.matchAll(linkPattern)) {\n      // The pattern requires at least one segment.\n      const segments = getMandatoryNamedGroup(match, 'path').split('/').filter(Boolean);\n      const typeName = ensureNonNullable(segments.at(-1));\n      const namespace = segments.slice(0, -1).join('/');\n      const routeKey = `${namespace}#${typeName}`;\n      const resolvedKey = routeKeyToTypeKey.get(routeKey);\n      if (resolvedKey !== undefined && resolvedKey !== sourceKey) {\n        referenced.add(resolvedKey);\n      }\n    }\n\n    for (const reference of referenced) {\n      if (!backlinks.has(reference)) {\n        backlinks.set(reference, []);\n      }\n      backlinks.get(reference)?.push(sourceKey);\n    }\n  }\n\n  return backlinks;\n}\n\n/**\n * Builds the namespace tree the sidebar is generated from.\n *\n * @param types - The documented types, keyed by qualified id.\n * @returns The root of the tree.\n */\nexport function buildSidebarTree(types: Map<string, TypeInfo>): SidebarTreeNode {\n  const root: SidebarTreeNode = { children: new Map(), types: [] };\n  for (const [, info] of types) {\n    const parts = info.namespace.split('/');\n    let node = root;\n    for (const part of parts) {\n      let child = node.children.get(part);\n      if (!child) {\n        child = { children: new Map(), types: [] };\n        node.children.set(part, child);\n      }\n      node = child;\n    }\n    node.types.push(info);\n  }\n  return root;\n}\n\n/**\n * The raw code signature shown on a type-overview page's OG card, for the kinds that render a single\n * signature line (function / type alias / variable). Classes, interfaces and enums render member\n * tables instead, so they get no signature block.\n *\n * @param name - The type's name.\n * @param info - The documented type.\n * @returns The signature, or `undefined` for a kind that renders member tables instead.\n */\nexport function computeOverviewSignature(name: string, info: TypeInfo): string | undefined {\n  if (info.kind === 'function') {\n    const $function = info.methods[0];\n    return $function ? `function ${$function.signature}: ${$function.returnType}` : undefined;\n  }\n  if (info.kind === 'type') {\n    return `type ${getDisplayName(info.name, info)} = ${info.typeAliasText ?? 'unknown'}`;\n  }\n  return info.kind === 'variable' ? `${info.variableKeyword ?? 'let'} ${name}: ${info.variableType ?? 'unknown'}` : undefined;\n}\n\n/**\n * Writes one page per own property and per own method overload key of a class or interface.\n *\n * @param name - The type's name.\n * @param info - The documented type.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n */\nexport async function generateMemberPages(name: string, info: TypeInfo, allTypes: Map<string, TypeInfo>): Promise<void> {\n  const nsDirectory = getNamespaceDirectory(info.namespace);\n  const typeFileDirectory = toTypeFileSegment(info.namespace, name);\n  const typeRouteDirectory = toTypeRouteSegment(info.namespace, name);\n  const componentImports = getComponentImports(['MemberDetail']);\n\n  // Property pages (skip inherited — they live on the parent type)\n  const properties = info.properties.filter((p) => !p.inheritedFrom);\n  for (const property of properties) {\n    const filePath = join(getApiDocSettings().outputDirectory, nsDirectory, typeFileDirectory, `${memberSlug(property.name)}.mdx`);\n    await ensureDirectory(filePath);\n\n    const propertyTitle = `${name}.${property.name}`;\n    const lines: string[] = renderFrontMatter({\n      description: property.description,\n      sidebarLabel: propertyTitle,\n      signature: `${property.signature}: ${property.type}`,\n      slug: `api/${nsDirectory}/${typeRouteDirectory}/${memberRouteSegment(property.name)}`,\n      title: propertyTitle\n    });\n    lines.push(\n      ...componentImports,\n      '',\n      // Breadcrumb\n      `[${name}](${getApiDocSettings().basePath}/api/${nsDirectory}/${typeRouteDirectory}/) › ${property.name}`,\n      ''\n    );\n\n    const staticAttribute = property.isStatic ? ' isStatic={true}' : '';\n    const typeAttribute = ` type=\"${escapeJsxAttribute(markdownToHtml(renderTypeWithLinks(property.type, allTypes, name, info.namespace)))}\"`;\n    const descAttribute = property.description ? ` description=\"${escapeJsxAttribute(markdownToHtml(resolveLinks(property.description, allTypes, info.namespace)))}\"` : '';\n    const remarksAttribute = property.remarks ? ` remarks=\"${escapeJsxAttribute(markdownToHtml(resolveLinks(property.remarks, allTypes, info.namespace)))}\"` : '';\n    const sinceAttribute = property.since ? ` since=\"${escapeJsxAttribute(property.since)}\"` : '';\n    const examplesAttribute = property.examples.length > 0 ? ` examples={${JSON.stringify(property.examples)}}` : '';\n\n    lines.push(`<MemberDetail${staticAttribute}${typeAttribute}${descAttribute}${remarksAttribute}${sinceAttribute}${examplesAttribute} />`, '');\n\n    await writeFile(filePath, lines.join('\\n'), 'utf-8');\n  }\n\n  // Method pages — each overload key gets its own page (skip inherited)\n  const methods = info.methods.filter((m) => !m.inheritedFrom);\n  const overloadGroups = new Map<string, MemberInfo[]>();\n  for (const method of methods) {\n    const key = method.overloadKey;\n    if (!overloadGroups.has(key)) {\n      overloadGroups.set(key, []);\n    }\n    overloadGroups.get(key)?.push(method);\n  }\n\n  for (const [overloadKey, overloads] of overloadGroups) {\n    const fileSlug = overloadSlug(overloadKey);\n    const filePath = join(getApiDocSettings().outputDirectory, nsDirectory, typeFileDirectory, `${fileSlug}.mdx`);\n    await ensureDirectory(filePath);\n\n    const displayName = `${name}.${overloadKey} method`;\n    // A group is created by its first overload.\n    const firstOverload = ensureNonNullable(overloads[0]);\n\n    const lines: string[] = renderFrontMatter({\n      description: firstOverload.description,\n      sidebarLabel: `${name}.${overloadKey}`,\n      signature: `${firstOverload.signature}: ${firstOverload.returnType}`,\n      slug: `api/${nsDirectory}/${typeRouteDirectory}/${overloadRouteSegment(overloadKey)}`,\n      title: displayName\n    });\n    lines.push(\n      ...componentImports,\n      '',\n      // Breadcrumb\n      `[${name}](${getApiDocSettings().basePath}/api/${nsDirectory}/${typeRouteDirectory}/) › ${overloadKey}`,\n      ''\n    );\n\n    for (const overload of overloads) {\n      renderMethodOverloadMdx(lines, overload, name, info.namespace, allTypes);\n      if (overloads.length > 1) {\n        lines.push('---', '');\n      }\n    }\n\n    await writeFile(filePath, lines.join('\\n'), 'utf-8');\n  }\n}\n\n/**\n * Writes each module's index page and the root API index.\n *\n * @param types - The documented types, keyed by qualified id.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n * @param moduleOverviews - Each namespace's `@file` overview.\n */\nexport async function generateNamespaceIndexPages(\n  types: Map<string, TypeInfo>,\n  allTypes: Map<string, TypeInfo>,\n  moduleOverviews: Map<string, string>\n): Promise<void> {\n  const namespaces = new Map<string, TypeInfo[]>();\n  for (const [, info] of types) {\n    if (!namespaces.has(info.namespace)) {\n      namespaces.set(info.namespace, []);\n    }\n    namespaces.get(info.namespace)?.push(info);\n  }\n\n  for (const [namespace, nsTypes] of namespaces) {\n    const nsDirectory = getNamespaceDirectory(namespace);\n    const filePath = join(getApiDocSettings().outputDirectory, nsDirectory, 'index.mdx');\n    await ensureDirectory(filePath);\n\n    // The module's `@file` text doubles as its description.\n    // Without it the module card was title-only while every member card under it carried one.\n    const overview = moduleOverviews.get(namespace);\n    const lines: string[] = renderFrontMatter({\n      description: overview,\n      sidebarLabel: namespace,\n      slug: `api/${nsDirectory}`,\n      title: namespace\n    });\n\n    // Module @file overview text\n    if (overview) {\n      lines.push(renderMdxProse(overview, allTypes, namespace), '');\n    }\n\n    renderNamespaceTable(lines, 'Classes', 'Class', nsTypes.filter((t) => t.kind === 'class'), allTypes, namespace);\n    renderNamespaceTable(lines, 'Interfaces', 'Interface', nsTypes.filter((t) => t.kind === 'interface'), allTypes, namespace);\n    renderNamespaceTable(lines, 'Functions', 'Function', nsTypes.filter((t) => t.kind === 'function'), allTypes, namespace);\n    renderNamespaceTable(lines, 'Types', 'Type', nsTypes.filter((t) => t.kind === 'type'), allTypes, namespace);\n    renderNamespaceTable(lines, 'Enums', 'Enum', nsTypes.filter((t) => t.kind === 'enum'), allTypes, namespace);\n    renderNamespaceTable(lines, 'Variables', 'Variable', nsTypes.filter((t) => t.kind === 'variable'), allTypes, namespace);\n\n    await writeFile(filePath, lines.join('\\n'), 'utf-8');\n  }\n\n  // Root API index page listing every module.\n  const sortedNamespaces = [...namespaces.keys()].sort((a, b) => a.localeCompare(b));\n  const apiIndexIntro = getApiIndexIntro(sortedNamespaces);\n  const rootLines: string[] = renderFrontMatter({\n    description: apiIndexIntro,\n    sidebarLabel: 'Overview',\n    slug: 'api',\n    title: 'API reference'\n  });\n  rootLines.push(apiIndexIntro, '', '## Modules', '');\n  for (const namespace of sortedNamespaces) {\n    rootLines.push(`- [${namespace}](${getApiDocSettings().basePath}/api/${getNamespaceDirectory(namespace)}/)`);\n  }\n  rootLines.push('');\n  const rootFilePath = join(getApiDocSettings().outputDirectory, 'index.mdx');\n  await ensureDirectory(rootFilePath);\n  await writeFile(rootFilePath, rootLines.join('\\n'), 'utf-8');\n}\n\n/**\n * Renders a type's overview page.\n *\n * @param name - The type's name.\n * @param info - The documented type.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n * @returns The page's content, before backlinks, and the path it is written to.\n */\nexport async function generateOverviewPage(name: string, info: TypeInfo, allTypes: Map<string, TypeInfo>): Promise<PageContent> {\n  const nsDirectory = getNamespaceDirectory(info.namespace);\n  const typeFileSlug = toTypeFileSegment(info.namespace, name);\n  const typeRouteSlug = toTypeRouteSegment(info.namespace, name);\n  const filePath = join(getApiDocSettings().outputDirectory, nsDirectory, typeFileSlug, 'index.mdx');\n  await ensureDirectory(filePath);\n\n  // Frontmatter\n  const displayName = getDisplayName(name, info);\n  const lines: string[] = renderFrontMatter({\n    description: info.description,\n    sidebarLabel: displayName,\n    signature: computeOverviewSignature(name, info),\n    slug: `api/${nsDirectory}/${typeRouteSlug}`,\n    title: displayName\n  });\n\n  // Component imports — compute relative path from generated page to components\n  lines.push(...getComponentImports(['ConstructorBlock', 'ImportStatement', 'MethodTable', 'PropertyTable', 'TypeSignature']), '');\n\n  // Description\n  if (info.description) {\n    lines.push(renderMdxProse(info.description, allTypes, info.namespace), '');\n  }\n\n  // Remarks\n  if (info.remarks) {\n    const remarksBlock = renderMdxProse(info.remarks, allTypes, info.namespace);\n    lines.push(remarksBlock.split('\\n').map((line) => (line.length > 0 ? `> ${line}` : '>')).join('\\n'), '');\n  }\n\n  // Import statement\n  lines.push(`<ImportStatement text=\"${escapeJsxAttribute(getImportStatement(info))}\" />`, '');\n\n  // Examples\n  for (const example of info.examples) {\n    lines.push('**Example:**', '', renderExampleMdx(example, allTypes, info.namespace), '');\n  }\n\n  // Functions render like method detail pages — signature, params, returns\n  if (info.kind === 'function') {\n    renderFunctionPage(lines, info, allTypes);\n    return { content: lines.join('\\n'), filePath };\n  }\n\n  // Variables render with declaration keyword and type\n  if (info.kind === 'variable') {\n    renderVariablePage(lines, name, info, allTypes);\n    return { content: lines.join('\\n'), filePath };\n  }\n\n  // Enums render their members list\n  if (info.kind === 'enum') {\n    renderEnumPage(lines, info, allTypes);\n    return { content: lines.join('\\n'), filePath };\n  }\n\n  // Type aliases render their right-hand-side signature\n  if (info.kind === 'type') {\n    renderTypeAliasPage(lines, info, allTypes);\n    return { content: lines.join('\\n'), filePath };\n  }\n\n  // Classes / interfaces: signature + extends/implements + constructor + member tables\n  const typeParamsAttribute = info.typeParameters.length > 0 ? ` typeParams={${JSON.stringify(info.typeParameters)}}` : '';\n  const extendsAttribute = info.baseTypes.length > 0 ? ` extends={${JSON.stringify(info.baseTypes)}}` : '';\n  const implementsAttribute = info.implementsTypes.length > 0 ? ` implements={${JSON.stringify(info.implementsTypes)}}` : '';\n  lines.push(`<TypeSignature kind=\"${info.kind}\" name=\"${name}\"${typeParamsAttribute}${extendsAttribute}${implementsAttribute} />`, '');\n\n  if (info.baseTypes.length > 0) {\n    const linkedTypes = info.baseTypes.map((t) => linkBaseType(t, allTypes, info.namespace));\n    lines.push(`**Extends:** ${linkedTypes.join(', ')}`, '');\n  }\n\n  if (info.implementsTypes.length > 0) {\n    const linkedTypes = info.implementsTypes.map((t) => linkBaseType(t, allTypes, info.namespace));\n    lines.push(`**Implements:** ${linkedTypes.join(', ')}`, '');\n  }\n\n  renderConstructorMdx(lines, name, info, allTypes);\n  renderPropertyTableMdx(lines, info, allTypes);\n  renderMethodTableMdx(lines, info, allTypes);\n\n  return { content: lines.join('\\n'), filePath };\n}\n\n/**\n * Writes the Starlight sidebar of the API reference.\n *\n * @param types - The documented types, keyed by qualified id.\n */\nexport async function generateSidebarJson(types: Map<string, TypeInfo>): Promise<void> {\n  const root = buildSidebarTree(types);\n\n  const groups: SidebarEntry[] = [];\n  const topLevels = [...root.children].sort(([a], [b]) => a.localeCompare(b));\n  for (const [topLevel, child] of topLevels) {\n    groups.push(sidebarTreeToEntries(child, topLevel));\n  }\n\n  const wrappedSidebar: SidebarEntry[] = [{\n    collapsed: false,\n    items: groups,\n    label: 'API reference'\n  }];\n\n  await writeFile(getApiDocSettings().sidebarFile, JSON.stringify(wrappedSidebar, null, JSON_INDENT), 'utf-8');\n  console.warn(`Generated sidebar with ${String(groups.length)} top-level module groups`);\n}\n\n/**\n * Renders a class's constructor block.\n *\n * @param lines - The page lines to append to.\n * @param name - The type's name.\n * @param info - The documented type.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n */\nexport function renderConstructorMdx(lines: string[], name: string, info: TypeInfo, allTypes: Map<string, TypeInfo>): void {\n  const constructor = info.constructorInfo;\n  if (!constructor) {\n    return;\n  }\n  const ctorSig = `new ${name}${constructor.signature}`;\n  const ctorDesc = constructor.description\n    ? ` description=\"${escapeJsxAttribute(markdownToHtml(resolveLinks(constructor.description, allTypes, info.namespace)))}\"`\n    : '';\n  lines.push(`<ConstructorBlock signature=\"${escapeJsxAttribute(ctorSig)}\"${ctorDesc} />`, '');\n}\n\n/**\n * Renders an enum's members.\n *\n * @param lines - The page lines to append to.\n * @param info - The documented type.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n */\nexport function renderEnumPage(lines: string[], info: TypeInfo, allTypes: Map<string, TypeInfo>): void {\n  lines.push(`<TypeSignature kind=\"enum\" name=\"${info.name}\" />`, '');\n\n  if (info.enumMembers.length === 0) {\n    return;\n  }\n\n  lines.push('**Members:**', '', '| Member | Value | Description |', '| :-- | :-- | :-- |');\n  for (const member of info.enumMembers) {\n    const value = member.value ? `\\`${escapeMarkdown(member.value)}\\`` : '';\n    lines.push(`| \\`${member.name}\\` | ${value} | ${escapeMarkdown(resolveLinks(member.description, allTypes, info.namespace))} |`);\n  }\n  lines.push('');\n}\n\n/**\n * Render the Starlight frontmatter block (through the closing `---` and its blank line) shared by every\n * generated page kind: module index, type overview, property, and method.\n *\n * Every page kind goes through here so no field can be emitted on some kinds and silently dropped on\n * others. `description` in particular is not just SEO metadata — it is the line the OG card renders under\n * the title, so a page kind that skipped it produced a title-only card next to fully populated ones.\n *\n * @param frontMatter - The page's frontmatter fields.\n * @returns The frontmatter lines, through the closing `---` and its blank line.\n */\nexport function renderFrontMatter(frontMatter: PageFrontMatter): string[] {\n  return [\n    '---',\n    `title: \"${escapeYaml(frontMatter.title)}\"`,\n    `slug: \"${frontMatter.slug}\"`,\n    ...(frontMatter.description ? [`description: \"${escapeYaml(stripMarkdown(frontMatter.description))}\"`] : []),\n    ...(frontMatter.signature ? [`signature: \"${escapeYaml(truncateSignature(frontMatter.signature))}\"`] : []),\n    'editUrl: false',\n    'sidebar:',\n    `  label: \"${escapeYaml(frontMatter.sidebarLabel)}\"`,\n    '---',\n    ''\n  ];\n}\n\n/**\n * Renders a function's signature, parameters, return value and examples.\n *\n * @param lines - The page lines to append to.\n * @param info - The documented type.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n */\nexport function renderFunctionPage(lines: string[], info: TypeInfo, allTypes: Map<string, TypeInfo>): void {\n  const $function = info.methods[0];\n  if (!$function) {\n    return;\n  }\n\n  lines.push('**Signature:**', '', '```ts', `function ${$function.signature}: ${$function.returnType}`, '```', '');\n\n  if ($function.parameters.length > 0) {\n    lines.push('**Parameters:**', '', '| Parameter | Type | Description |', '| :-- | :-- | :-- |');\n    for (const parameter of $function.parameters) {\n      lines.push(\n        `| \\`${parameter.name}\\` | ${escapeMarkdown(escapeMdxAngleBrackets(renderTypeWithLinks(parameter.type, allTypes, info.name, info.namespace)))} | ${escapeMarkdown(resolveLinks(parameter.description, allTypes, info.namespace))} |`\n      );\n    }\n    lines.push('');\n  }\n\n  const returnDesc = $function.returnDescription ? ` — ${escapeMdxAngleBrackets(resolveLinks($function.returnDescription, allTypes, info.namespace))}` : '';\n  lines.push(`**Returns:** ${escapeMdxAngleBrackets(renderTypeWithLinks($function.returnType, allTypes, info.name, info.namespace))}${returnDesc}`, '');\n\n  for (const example of $function.examples) {\n    lines.push('**Example:**', '', renderExampleMdx(example, allTypes, info.namespace), '');\n  }\n}\n\n/**\n * Renders one method overload.\n *\n * @param lines - The page lines to append to.\n * @param overload - The overload.\n * @param typeName - The name of the type the method belongs to.\n * @param namespace - The namespace of the type the method belongs to.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n */\nexport function renderMethodOverloadMdx(lines: string[], overload: MemberInfo, typeName: string, namespace: string, allTypes: Map<string, TypeInfo>): void {\n  const sig = `${overload.signature}: ${overload.returnType}`;\n  const staticAttribute = overload.isStatic ? ' isStatic={true}' : '';\n  const descAttribute = overload.description ? ` description=\"${escapeJsxAttribute(markdownToHtml(resolveLinks(overload.description, allTypes, namespace)))}\"` : '';\n  const remarksAttribute = overload.remarks ? ` remarks=\"${escapeJsxAttribute(markdownToHtml(resolveLinks(overload.remarks, allTypes, namespace)))}\"` : '';\n  const sinceAttribute = overload.since ? ` since=\"${escapeJsxAttribute(overload.since)}\"` : '';\n  const returnTypeAttribute = ` returnType=\"${escapeJsxAttribute(markdownToHtml(renderTypeWithLinks(overload.returnType, allTypes, typeName, namespace)))}\"`;\n  const returnDescAttribute = overload.returnDescription\n    ? ` returnDescription=\"${escapeJsxAttribute(markdownToHtml(resolveLinks(overload.returnDescription, allTypes, namespace)))}\"`\n    : '';\n  const examplesAttribute = overload.examples.length > 0 ? ` examples={${JSON.stringify(overload.examples)}}` : '';\n\n  const params = overload.parameters.map((p) => ({\n    description: markdownToHtml(p.description || (p.name.endsWith('?') ? '*(Optional)*' : '')),\n    name: p.name,\n    type: markdownToHtml(renderTypeWithLinks(p.type, allTypes, typeName, namespace))\n  }));\n  const paramsAttribute = params.length > 0 ? ` parameters={${JSON.stringify(params)}}` : '';\n\n  lines.push(\n    `<MemberDetail${staticAttribute} signature=\"${escapeJsxAttribute(sig)}\"${descAttribute}${remarksAttribute}${sinceAttribute}${returnTypeAttribute}${returnDescAttribute}${paramsAttribute}${examplesAttribute} />`,\n    ''\n  );\n}\n\n/**\n * Renders a type's method table.\n *\n * @param lines - The page lines to append to.\n * @param info - The documented type.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n */\nexport function renderMethodTableMdx(lines: string[], info: TypeInfo, allTypes: Map<string, TypeInfo>): void {\n  const methods = [...info.methods].sort((a, b) => {\n    if (a.isStatic !== b.isStatic) {\n      return a.isStatic ? 1 : -1;\n    }\n    return a.name.localeCompare(b.name);\n  });\n  if (methods.length === 0) {\n    return;\n  }\n  lines.push('<MethodTable rows={[');\n  for (const method of methods) {\n    const desc = escapeJsString(markdownToHtml(resolveLinks(method.description, allTypes, info.namespace)));\n    const staticPrefix = method.isStatic ? 'static ' : '';\n    const shortParams = method.parameters.map((p, index) => {\n      return index === 0 && EVENT_METHODS.has(method.name) && (p.type.startsWith('\"') || p.type.startsWith('\\'')) ? p.type.replaceAll('\"', '\\'') : p.name;\n    }).join(', ');\n    const shortSig = `${staticPrefix}${method.name}(${shortParams})`;\n    const sig = escapeJsString(shortSig);\n    const slug = overloadRouteSegment(method.overloadKey);\n    const returnType = markdownToHtml(renderTypeWithLinks(method.returnType, allTypes, info.name, info.namespace));\n    const inheritedAttribute = method.inheritedFrom\n      ? `, inheritedFrom: \"${escapeJsString(markdownToHtml(typeLink(method.inheritedFrom, allTypes, info.namespace)))}\"`\n      : '';\n    const href = memberHref(slug, method.inheritedFrom, allTypes, info.namespace);\n    lines.push(\n      `  { signature: \"${sig}\", href: \"${escapeJsString(href)}\", returns: \"${escapeJsString(returnType)}\", description: \"${desc}\"${inheritedAttribute} },`\n    );\n  }\n  lines.push(']} />', '');\n}\n\n/**\n * Renders a type's property table.\n *\n * @param lines - The page lines to append to.\n * @param info - The documented type.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n */\nexport function renderPropertyTableMdx(lines: string[], info: TypeInfo, allTypes: Map<string, TypeInfo>): void {\n  const properties = info.properties;\n  if (properties.length === 0) {\n    return;\n  }\n  lines.push('<PropertyTable rows={[');\n  for (const property of properties) {\n    const desc = escapeJsString(markdownToHtml(resolveLinks(property.description, allTypes, info.namespace)));\n    const type = markdownToHtml(renderTypeWithLinks(property.type, allTypes, info.name, info.namespace));\n    const inheritedAttribute = property.inheritedFrom\n      ? `, inheritedFrom: \"${escapeJsString(markdownToHtml(typeLink(property.inheritedFrom, allTypes, info.namespace)))}\"`\n      : '';\n    const href = memberHref(memberRouteSegment(property.name), property.inheritedFrom, allTypes, info.namespace);\n    lines.push(\n      `  { name: \"${escapeJsString(property.name)}\", href: \"${escapeJsString(href)}\", type: \"${escapeJsString(type)}\", description: \"${desc}\"${inheritedAttribute} },`\n    );\n  }\n  lines.push(']} />', '');\n}\n\n/**\n * Renders a type alias's signature.\n *\n * @param lines - The page lines to append to.\n * @param info - The documented type.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n */\nexport function renderTypeAliasPage(lines: string[], info: TypeInfo, allTypes: Map<string, TypeInfo>): void {\n  const typeParamsAttribute = info.typeParameters.length > 0 ? ` typeParams={${JSON.stringify(info.typeParameters)}}` : '';\n  lines.push(`<TypeSignature kind=\"type\" name=\"${info.name}\"${typeParamsAttribute} />`, '');\n\n  const rhs = info.typeAliasText ?? 'unknown';\n  lines.push(\n    '**Signature:**',\n    '',\n    '```ts',\n    `type ${getDisplayName(info.name, info)} = ${rhs}`,\n    '```',\n    '',\n    `**Type:** ${escapeMdxBraces(escapeMdxAngleBrackets(renderTypeWithLinks(rhs, allTypes, info.name, info.namespace)))}`,\n    ''\n  );\n}\n\n/**\n * Renders a variable's declaration and type.\n *\n * @param lines - The page lines to append to.\n * @param name - The type's name.\n * @param info - The documented type.\n * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.\n */\nexport function renderVariablePage(lines: string[], name: string, info: TypeInfo, allTypes: Map<string, TypeInfo>): void {\n  const keyword = info.variableKeyword ?? 'let';\n  const variableType = info.variableType ?? 'unknown';\n  lines.push(\n    '**Signature:**',\n    '',\n    '```ts',\n    `${keyword} ${name}: ${variableType}`,\n    '```',\n    '',\n    `**Type:** ${escapeMdxBraces(escapeMdxAngleBrackets(renderTypeWithLinks(variableType, allTypes, name, info.namespace)))}`,\n    ''\n  );\n}\n\n/**\n * Converts a namespace tree node into a sidebar group.\n *\n * @param node - The node.\n * @param label - The group's label.\n * @returns The sidebar group.\n */\nexport function sidebarTreeToEntries(node: SidebarTreeNode, label: string): SidebarEntry {\n  const items: (SidebarEntry | SidebarLink)[] = [];\n\n  // Child directory groups first (before this module's own pages)\n  const sortedChildren = [...node.children].sort(([a], [b]) => a.localeCompare(b));\n  for (const [childName, child] of sortedChildren) {\n    items.push(sidebarTreeToEntries(child, childName));\n  }\n\n  // This module's own overview page + type/function pages (individual members are not listed).\n  // Sidebar `link` fields must NOT embed BASE_PATH: Starlight prepends the config `base` to every\n  // sidebar link itself, so including it here would double the base (e.g. `/base/base/api/...` → 404).\n  // This differs from in-content links, which are raw anchors that Starlight does not base-prepend.\n  if (node.types.length > 0) {\n    const { namespace } = ensureNonNullable(node.types[0]);\n    items.push({ label: 'Overview', link: `/api/${namespace}/` });\n    const sortedTypes = [...node.types].sort((a, b) => a.name.localeCompare(b.name));\n    for (const t of sortedTypes) {\n      items.push({ label: t.name, link: `/api/${t.namespace}/${toTypeRouteSegment(t.namespace, t.name)}/` });\n    }\n  }\n\n  return { collapsed: true, items, label };\n}\n\n// Serves both as the root API page's prose and (stripped) as its `description` frontmatter.\n// Sharing one function keeps the page and its OG card from drifting apart.\nfunction getApiIndexIntro(namespaces: readonly string[]): string {\n  const { packageName } = getApiDocSettings();\n  const [exampleNamespace = 'module'] = namespaces;\n  return `The complete API reference for \\`${packageName}\\`, generated from its TSDoc. `\n    + `Each module below maps to an import subpath (e.g. the \\`${exampleNamespace}\\` module is \\`${packageName}/${exampleNamespace}\\`).`;\n}\n\nfunction getComponentImports(componentNames: readonly string[]): string[] {\n  return componentNames.map((componentName) => `import ${componentName} from \"${API_COMPONENTS_IMPORT_PREFIX}/${componentName}.astro\";`);\n}\n\nfunction renderNamespaceTable(\n  lines: string[],\n  heading: string,\n  columnLabel: string,\n  entries: TypeInfo[],\n  allTypes: Map<string, TypeInfo>,\n  namespace: string\n): void {\n  if (entries.length === 0) {\n    return;\n  }\n  const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));\n  lines.push(`## ${heading}`, '', `| ${columnLabel} | Description |`, '| :-- | :-- |');\n  for (const entry of sorted) {\n    lines.push(`| [${entry.name}](./${toTypeRouteSegment(entry.namespace, entry.name)}/) | ${escapeMarkdown(resolveLinks(entry.description, allTypes, namespace))} |`);\n  }\n  lines.push('');\n}\n"],"mappings":"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","names":[]}