@mnaoumov/typescript-dev-toolkit 1.3.1 → 2.0.0

package/dist/lib/cjs/docs-site/api-doc-page-generation.d.cts

@@ -0,0 +1,159 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * MDX page + sidebar emission: renders module index pages, per-type overview pages, per-member pages,
+ * backlinks, and the Starlight sidebar JSON.
+ */
+import type { MemberInfo, PageContent, PageFrontMatter, SidebarEntry, SidebarTreeNode, TypeInfo } from './api-doc-types.cjs';
+/**
+ * Append backlinks to overview pages and write all files. Keyed by qualified `${namespace}#${name}`.
+ *
+ * @param pageContents - Every overview page's content and path, keyed by qualified id.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ */
+export declare function appendBacklinksAndWrite(pageContents: Map<string, PageContent>, allTypes: Map<string, TypeInfo>): Promise<void>;
+/**
+ * Build backlinks by scanning generated page content for internal API links. Keyed by qualified id.
+ *
+ * @param pageContents - Every overview page's content and path, keyed by qualified id.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ * @returns Each referenced type's qualified id mapped to the ids of the pages linking to it.
+ */
+export declare function buildBacklinksFromContent(pageContents: Map<string, PageContent>, allTypes: Map<string, TypeInfo>): Map<string, string[]>;
+/**
+ * Builds the namespace tree the sidebar is generated from.
+ *
+ * @param types - The documented types, keyed by qualified id.
+ * @returns The root of the tree.
+ */
+export declare function buildSidebarTree(types: Map<string, TypeInfo>): SidebarTreeNode;
+/**
+ * The raw code signature shown on a type-overview page's OG card, for the kinds that render a single
+ * signature line (function / type alias / variable). Classes, interfaces and enums render member
+ * tables instead, so they get no signature block.
+ *
+ * @param name - The type's name.
+ * @param info - The documented type.
+ * @returns The signature, or `undefined` for a kind that renders member tables instead.
+ */
+export declare function computeOverviewSignature(name: string, info: TypeInfo): string | undefined;
+/**
+ * Writes one page per own property and per own method overload key of a class or interface.
+ *
+ * @param name - The type's name.
+ * @param info - The documented type.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ */
+export declare function generateMemberPages(name: string, info: TypeInfo, allTypes: Map<string, TypeInfo>): Promise<void>;
+/**
+ * Writes each module's index page and the root API index.
+ *
+ * @param types - The documented types, keyed by qualified id.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ * @param moduleOverviews - Each namespace's `@file` overview.
+ */
+export declare function generateNamespaceIndexPages(types: Map<string, TypeInfo>, allTypes: Map<string, TypeInfo>, moduleOverviews: Map<string, string>): Promise<void>;
+/**
+ * Renders a type's overview page.
+ *
+ * @param name - The type's name.
+ * @param info - The documented type.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ * @returns The page's content, before backlinks, and the path it is written to.
+ */
+export declare function generateOverviewPage(name: string, info: TypeInfo, allTypes: Map<string, TypeInfo>): Promise<PageContent>;
+/**
+ * Writes the Starlight sidebar of the API reference.
+ *
+ * @param types - The documented types, keyed by qualified id.
+ */
+export declare function generateSidebarJson(types: Map<string, TypeInfo>): Promise<void>;
+/**
+ * Renders a class's constructor block.
+ *
+ * @param lines - The page lines to append to.
+ * @param name - The type's name.
+ * @param info - The documented type.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ */
+export declare function renderConstructorMdx(lines: string[], name: string, info: TypeInfo, allTypes: Map<string, TypeInfo>): void;
+/**
+ * Renders an enum's members.
+ *
+ * @param lines - The page lines to append to.
+ * @param info - The documented type.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ */
+export declare function renderEnumPage(lines: string[], info: TypeInfo, allTypes: Map<string, TypeInfo>): void;
+/**
+ * Render the Starlight frontmatter block (through the closing `---` and its blank line) shared by every
+ * generated page kind: module index, type overview, property, and method.
+ *
+ * Every page kind goes through here so no field can be emitted on some kinds and silently dropped on
+ * others. `description` in particular is not just SEO metadata — it is the line the OG card renders under
+ * the title, so a page kind that skipped it produced a title-only card next to fully populated ones.
+ *
+ * @param frontMatter - The page's frontmatter fields.
+ * @returns The frontmatter lines, through the closing `---` and its blank line.
+ */
+export declare function renderFrontMatter(frontMatter: PageFrontMatter): string[];
+/**
+ * Renders a function's signature, parameters, return value and examples.
+ *
+ * @param lines - The page lines to append to.
+ * @param info - The documented type.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ */
+export declare function renderFunctionPage(lines: string[], info: TypeInfo, allTypes: Map<string, TypeInfo>): void;
+/**
+ * Renders one method overload.
+ *
+ * @param lines - The page lines to append to.
+ * @param overload - The overload.
+ * @param typeName - The name of the type the method belongs to.
+ * @param namespace - The namespace of the type the method belongs to.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ */
+export declare function renderMethodOverloadMdx(lines: string[], overload: MemberInfo, typeName: string, namespace: string, allTypes: Map<string, TypeInfo>): void;
+/**
+ * Renders a type's method table.
+ *
+ * @param lines - The page lines to append to.
+ * @param info - The documented type.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ */
+export declare function renderMethodTableMdx(lines: string[], info: TypeInfo, allTypes: Map<string, TypeInfo>): void;
+/**
+ * Renders a type's property table.
+ *
+ * @param lines - The page lines to append to.
+ * @param info - The documented type.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ */
+export declare function renderPropertyTableMdx(lines: string[], info: TypeInfo, allTypes: Map<string, TypeInfo>): void;
+/**
+ * Renders a type alias's signature.
+ *
+ * @param lines - The page lines to append to.
+ * @param info - The documented type.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ */
+export declare function renderTypeAliasPage(lines: string[], info: TypeInfo, allTypes: Map<string, TypeInfo>): void;
+/**
+ * Renders a variable's declaration and type.
+ *
+ * @param lines - The page lines to append to.
+ * @param name - The type's name.
+ * @param info - The documented type.
+ * @param allTypes - Every documented type, keyed by `${namespace}#${name}`.
+ */
+export declare function renderVariablePage(lines: string[], name: string, info: TypeInfo, allTypes: Map<string, TypeInfo>): void;
+/**
+ * Converts a namespace tree node into a sidebar group.
+ *
+ * @param node - The node.
+ * @param label - The group's label.
+ * @returns The sidebar group.
+ */
+export declare function sidebarTreeToEntries(node: SidebarTreeNode, label: string): SidebarEntry;

package/dist/lib/cjs/docs-site/api-doc-route-segments.cjs

@@ -0,0 +1,42 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_doc_route_segments_exports = {};
+__export(api_doc_route_segments_exports, {
+  toRouteSegment: () => toRouteSegment,
+  toRouteSegmentPreserveCase: () => toRouteSegmentPreserveCase
+});
+module.exports = __toCommonJS(api_doc_route_segments_exports);
+function toRouteSegment(segment) {
+  return segment.toLowerCase();
+}
+function toRouteSegmentPreserveCase(segment) {
+  const cleaned = segment.replaceAll(/[^a-zA-Z0-9]+/g, "-").replaceAll(/^-|-$/g, "");
+  return cleaned || "unnamed";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toRouteSegment,
+  toRouteSegmentPreserveCase
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/docs-site/api-doc-route-segments.d.cts

@@ -0,0 +1,25 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * The slug rules for a type's page: the lowercased segment its file is written under, and the case-preserved one its
+ * URL uses. Every site is generated with these rules, so a link into another package's site is built with them too.
+ */
+/**
+ * Lowercase a path segment for use in an ON-DISK file/dir name. The routes themselves are case-preserved via an
+ * explicit `slug:` frontmatter (see {@link toRouteSegmentPreserveCase}), but the files stay lowercase (and numerically
+ * disambiguated) so two type names differing only by case cannot collide on Windows' case-insensitive filesystem.
+ *
+ * @param segment - The segment.
+ * @returns The lowercased segment.
+ */
+export declare function toRouteSegment(segment: string): string;
+/**
+ * Slugify a path segment (type name) for a URL/route while PRESERVING case: collapse runs of non-alphanumeric
+ * characters to `-` and trim. Used for the case-preserved `slug:` frontmatter and the internal links that point at it,
+ * so URLs read as pretty PascalCase (e.g. `/api/.../TypeName/`).
+ *
+ * @param segment - The segment.
+ * @returns The slug, or `unnamed` when nothing alphanumeric is left.
+ */
+export declare function toRouteSegmentPreserveCase(segment: string): string;

package/dist/lib/cjs/docs-site/api-doc-settings.cjs

@@ -0,0 +1,47 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_doc_settings_exports = {};
+__export(api_doc_settings_exports, {
+  configureApiDocs: () => configureApiDocs,
+  getApiDocSettings: () => getApiDocSettings
+});
+module.exports = __toCommonJS(api_doc_settings_exports);
+const moduleState = {
+  settings: void 0
+};
+function configureApiDocs(settings) {
+  moduleState.settings = settings;
+}
+function getApiDocSettings() {
+  if (moduleState.settings === void 0) {
+    throw new Error("The API documentation generator is not configured: call configureApiDocs() first.");
+  }
+  return moduleState.settings;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configureApiDocs,
+  getApiDocSettings
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/docs-site/api-doc-settings.d.cts

@@ -0,0 +1,53 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @file
+ *
+ * The per-site settings of the API documentation generator: where it writes, which package it documents, the base
+ * path its links carry, and the external links a site adds to the generic ones.
+ */
+/**
+ * The settings the API documentation generator reads while it renders pages and links.
+ */
+export interface ApiDocSettings {
+    /**
+     * The site's base path, with a leading slash and no trailing one, e.g. `/typescript-lib`. Every in-content link
+     * the generator emits starts with it.
+     */
+    readonly basePath: string;
+    /**
+     * Type names mapped to the URL their references link to, for types neither this package nor a {@link packageSites}
+     * package declares, e.g. an ecosystem's own API reference. Consulted before the generic TypeScript, JavaScript and
+     * Web API links, so an entry here wins over them.
+     */
+    readonly externalTypeLinks: ReadonlyMap<string, string>;
+    /**
+     * The folder the generated API pages are written to, normally `<docs>/src/content/docs/api`.
+     */
+    readonly outputDirectory: string;
+    /**
+     * The documented package's name, e.g. `@mnaoumov/typescript-lib`. Import statements are built from it.
+     */
+    readonly packageName: string;
+    /**
+     * Package names mapped to the root URL of their documentation site, with a trailing slash. A type whose
+     * declaration resolves into one of these packages links to its page on that site.
+     */
+    readonly packageSites: ReadonlyMap<string, string>;
+    /**
+     * The JSON file the generated Starlight sidebar is written to.
+     */
+    readonly sidebarFile: string;
+}
+/**
+ * Sets the settings every later page and link reads.
+ *
+ * @param settings - The settings.
+ */
+export declare function configureApiDocs(settings: ApiDocSettings): void;
+/**
+ * Gets the settings set by {@link configureApiDocs}.
+ *
+ * @returns The settings.
+ * @throws If {@link configureApiDocs} has not been called.
+ */
+export declare function getApiDocSettings(): ApiDocSettings;

package/dist/lib/cjs/docs-site/api-doc-source-processing.cjs

@@ -0,0 +1,288 @@
+/*
+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();
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_doc_source_processing_exports = {};
+__export(api_doc_source_processing_exports, {
+  collectFunctions: () => collectFunctions,
+  collectPackageDeclarations: () => collectPackageDeclarations,
+  collectVariables: () => collectVariables,
+  computeCacheHash: () => computeCacheHash,
+  computeNamespace: () => computeNamespace,
+  findEntryFiles: () => findEntryFiles,
+  processSourceFile: () => processSourceFile,
+  registerGenericTypeParams: () => registerGenericTypeParams
+});
+module.exports = __toCommonJS(api_doc_source_processing_exports);
+var import_node_crypto = require('node:crypto');
+var import_node_fs = require('node:fs');
+var import_node_path = require('node:path');
+var import_ts_morph = require('ts-morph');
+var import_api_doc_constants = require('./api-doc-constants.cjs');
+var import_api_doc_jsdoc = require('./api-doc-jsdoc.cjs');
+var import_api_doc_package_sites = require('./api-doc-package-sites.cjs');
+var import_api_doc_settings = require('./api-doc-settings.cjs');
+var import_api_doc_text_utils = require('./api-doc-text-utils.cjs');
+const EXCLUDED_DIR_SEGMENTS = /* @__PURE__ */ new Set(["@types", "styles", "test-helpers"]);
+function collectFunctions(src, types, namespace) {
+  for (const $function of src.getFunctions()) {
+    if (!$function.isExported()) {
+      continue;
+    }
+    const name = $function.getName();
+    if (!name) {
+      continue;
+    }
+    const key = qualifiedKey(namespace, name);
+    if (types.has(key)) {
+      continue;
+    }
+    const parameterDescriptions = (0, import_api_doc_jsdoc.getParameterDescriptions)($function);
+    const params = $function.getParameters().map((p) => ({
+      description: parameterDescriptions.get(p.getName()) ?? "",
+      name: p.getName(),
+      type: (0, import_api_doc_text_utils.simplifyType)(p.getType().getText())
+    }));
+    const parameterString = params.map((p) => `${p.name}: ${p.type}`).join(", ");
+    const returnType = (0, import_api_doc_text_utils.simplifyType)($function.getReturnType().getText());
+    const signature = `${name}(${parameterString})`;
+    types.set(key, {
+      baseTypes: [],
+      description: (0, import_api_doc_jsdoc.getDescription)($function),
+      enumMembers: [],
+      examples: (0, import_api_doc_jsdoc.getExamples)($function),
+      implementsTypes: [],
+      kind: "function",
+      methods: [{
+        description: (0, import_api_doc_jsdoc.getDescription)($function),
+        examples: (0, import_api_doc_jsdoc.getExamples)($function),
+        inheritedFrom: "",
+        isStatic: false,
+        name,
+        overloadKey: name,
+        parameters: params,
+        remarks: (0, import_api_doc_jsdoc.getRemarks)($function),
+        returnDescription: (0, import_api_doc_jsdoc.getReturnDescription)($function),
+        returnType,
+        signature,
+        since: (0, import_api_doc_jsdoc.getSince)($function),
+        type: ""
+      }],
+      name,
+      namespace,
+      properties: [],
+      remarks: (0, import_api_doc_jsdoc.getRemarks)($function),
+      typeParameters: $function.getTypeParameters().map((tp) => tp.getText())
+    });
+  }
+}
+function collectPackageDeclarations(src) {
+  for (const importDeclaration of src.getImportDeclarations()) {
+    for (const namedImport of importDeclaration.getNamedImports()) {
+      const localNameNode = namedImport.getAliasNode() ?? namedImport.getNameNode();
+      const declarations = localNameNode.getSymbolOrThrow().getAliasedSymbolOrThrow().getDeclarations();
+      for (const declaration of declarations) {
+        if (isTypeDeclaration(declaration)) {
+          (0, import_api_doc_package_sites.registerPackageDeclaration)(namedImport.getName(), declaration.getSourceFile().getFilePath());
+        }
+      }
+    }
+  }
+}
+function collectVariables(src, types, namespace) {
+  for (const variableStatement of src.getVariableStatements()) {
+    if (!variableStatement.isExported()) {
+      continue;
+    }
+    const declarationKind = variableStatement.getDeclarationKind();
+    for (const declaration of variableStatement.getDeclarations()) {
+      const name = declaration.getName();
+      const key = qualifiedKey(namespace, name);
+      if (types.has(key)) {
+        continue;
+      }
+      types.set(key, {
+        baseTypes: [],
+        description: (0, import_api_doc_jsdoc.getDescription)(variableStatement),
+        enumMembers: [],
+        examples: (0, import_api_doc_jsdoc.getExamples)(variableStatement),
+        implementsTypes: [],
+        kind: "variable",
+        methods: [],
+        name,
+        namespace,
+        properties: [],
+        remarks: (0, import_api_doc_jsdoc.getRemarks)(variableStatement),
+        typeParameters: [],
+        variableKeyword: declarationKind,
+        variableType: (0, import_api_doc_text_utils.simplifyType)(declaration.getType().getText())
+      });
+    }
+  }
+}
+function computeCacheHash(entryFiles, generatorDirectory) {
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  const generatorFiles = (0, import_node_fs.readdirSync)(generatorDirectory).filter((name) => !name.endsWith(".test.ts")).sort();
+  for (const generatorFile of generatorFiles) {
+    hash.update(generatorFile);
+    hash.update((0, import_node_fs.readFileSync)((0, import_node_path.join)(generatorDirectory, generatorFile), "utf-8"));
+  }
+  const settings = (0, import_api_doc_settings.getApiDocSettings)();
+  hash.update(JSON.stringify({
+    ...settings,
+    externalTypeLinks: [...settings.externalTypeLinks],
+    packageSites: [...settings.packageSites]
+  }));
+  for (const filePath of [...entryFiles].sort()) {
+    hash.update(filePath);
+    hash.update((0, import_node_fs.readFileSync)(filePath, "utf-8"));
+  }
+  return hash.digest("hex");
+}
+function computeNamespace(srcDirectory, filePath) {
+  return (0, import_node_path.relative)(srcDirectory, filePath).replaceAll("\\", "/").replace(/\.ts$/, "");
+}
+function findEntryFiles(directory) {
+  const results = [];
+  for (const entry of (0, import_node_fs.readdirSync)(directory, { withFileTypes: true })) {
+    const fullPath = (0, import_node_path.join)(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (EXCLUDED_DIR_SEGMENTS.has(entry.name)) {
+        continue;
+      }
+      results.push(...findEntryFiles(fullPath));
+    } else if (isEntryFile(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function processSourceFile(src, types, namespace) {
+  for (const alias of src.getTypeAliases()) {
+    if (!alias.isExported()) {
+      continue;
+    }
+    const key = qualifiedKey(namespace, alias.getName());
+    if (!types.has(key)) {
+      types.set(key, (0, import_api_doc_jsdoc.extractTypeAliasInfo)(alias, namespace));
+    }
+  }
+  for (const enumDeclaration of src.getEnums()) {
+    if (!enumDeclaration.isExported()) {
+      continue;
+    }
+    const key = qualifiedKey(namespace, enumDeclaration.getName());
+    if (!types.has(key)) {
+      types.set(key, (0, import_api_doc_jsdoc.extractEnumInfo)(enumDeclaration, namespace));
+    }
+  }
+  for (const iface of src.getInterfaces()) {
+    if (!iface.isExported()) {
+      continue;
+    }
+    const key = qualifiedKey(namespace, iface.getName());
+    if (!types.has(key)) {
+      types.set(key, (0, import_api_doc_jsdoc.extractInterfaceInfo)(iface, namespace));
+    }
+  }
+  for (const cls of src.getClasses()) {
+    if (!cls.isExported()) {
+      continue;
+    }
+    const name = cls.getName();
+    if (!name) {
+      continue;
+    }
+    const key = qualifiedKey(namespace, name);
+    if (!types.has(key)) {
+      types.set(key, (0, import_api_doc_jsdoc.extractClassInfo)(cls, namespace));
+    }
+  }
+}
+function registerGenericTypeParams(types) {
+  const knownNames = /* @__PURE__ */ new Set();
+  for (const [, info] of types) {
+    knownNames.add(info.name);
+  }
+  for (const [, info] of types) {
+    for (const tp of info.typeParameters) {
+      const bareParameter = tp.replace(/\s+extends\s+.*$/, "");
+      if (!knownNames.has(bareParameter)) {
+        import_api_doc_constants.GENERIC_TYPE_PARAMS.add(bareParameter);
+      }
+    }
+  }
+}
+function isEntryFile(name) {
+  return !(!name.endsWith(".ts") || name.endsWith(".d.ts") || ["__merged.ts", "index.ts", "setup.ts"].includes(name) || name.endsWith("-setup.ts") || name.endsWith(".test.ts"));
+}
+function isTypeDeclaration(declaration) {
+  return import_ts_morph.Node.isClassDeclaration(declaration) || import_ts_morph.Node.isInterfaceDeclaration(declaration) || import_ts_morph.Node.isTypeAliasDeclaration(declaration) || import_ts_morph.Node.isEnumDeclaration(declaration);
+}
+function qualifiedKey(namespace, name) {
+  return `${namespace}#${name}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectFunctions,
+  collectPackageDeclarations,
+  collectVariables,
+  computeCacheHash,
+  computeNamespace,
+  findEntryFiles,
+  processSourceFile,
+  registerGenericTypeParams
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/docs-site/api-doc-source-processing.ts"],"sourcesContent":["/**\n * @file\n *\n * Source discovery + extraction: walks `src`, filters to documentable entry files, and turns each\n * file's exported declarations into `TypeInfo` entries keyed by a qualified `${namespace}#${name}`.\n */\n\nimport type { SourceFile } from 'ts-morph';\n\nimport { createHash } from 'node:crypto';\nimport {\n  readdirSync,\n  readFileSync\n} from 'node:fs';\nimport {\n  join,\n  relative\n} from 'node:path';\nimport { Node } from 'ts-morph';\n\nimport type { TypeInfo } from './api-doc-types.ts';\n\nimport { GENERIC_TYPE_PARAMS } from './api-doc-constants.ts';\nimport {\n  extractClassInfo,\n  extractEnumInfo,\n  extractInterfaceInfo,\n  extractTypeAliasInfo,\n  getDescription,\n  getExamples,\n  getParameterDescriptions,\n  getRemarks,\n  getReturnDescription,\n  getSince\n} from './api-doc-jsdoc.ts';\nimport { registerPackageDeclaration } from './api-doc-package-sites.ts';\nimport { getApiDocSettings } from './api-doc-settings.ts';\nimport { simplifyType } from './api-doc-text-utils.ts';\n\n/**\nDirectory names whose entire subtree is excluded from documentation.\n */\nconst EXCLUDED_DIR_SEGMENTS = new Set(['@types', 'styles', 'test-helpers']);\n\n/**\n * Collect top-level exported functions.\n *\n * @param src - The source file.\n * @param types - The documented types, keyed by qualified id.\n * @param namespace - The type's namespace.\n */\nexport function collectFunctions(src: SourceFile, types: Map<string, TypeInfo>, namespace: string): void {\n  for (const $function of src.getFunctions()) {\n    if (!$function.isExported()) {\n      continue;\n    }\n    const name = $function.getName();\n    if (!name) {\n      continue;\n    }\n    const key = qualifiedKey(namespace, name);\n    if (types.has(key)) {\n      continue;\n    }\n    const parameterDescriptions = getParameterDescriptions($function);\n    const params = $function.getParameters().map((p) => ({\n      description: parameterDescriptions.get(p.getName()) ?? '',\n      name: p.getName(),\n      type: simplifyType(p.getType().getText())\n    }));\n    const parameterString = params.map((p) => `${p.name}: ${p.type}`).join(', ');\n    const returnType = simplifyType($function.getReturnType().getText());\n    const signature = `${name}(${parameterString})`;\n    types.set(key, {\n      baseTypes: [],\n      description: getDescription($function),\n      enumMembers: [],\n      examples: getExamples($function),\n      implementsTypes: [],\n      kind: 'function',\n      methods: [{\n        description: getDescription($function),\n        examples: getExamples($function),\n        inheritedFrom: '',\n        isStatic: false,\n        name,\n        overloadKey: name,\n        parameters: params,\n        remarks: getRemarks($function),\n        returnDescription: getReturnDescription($function),\n        returnType,\n        signature,\n        since: getSince($function),\n        type: ''\n      }],\n      name,\n      namespace,\n      properties: [],\n      remarks: getRemarks($function),\n      typeParameters: $function.getTypeParameters().map((tp) => tp.getText())\n    });\n  }\n}\n\n/**\n * Records where every symbol a source file imports is declared, so a type another documented package declares\n * links to that package's site.\n *\n * @param src - The source file.\n */\nexport function collectPackageDeclarations(src: SourceFile): void {\n  for (const importDeclaration of src.getImportDeclarations()) {\n    for (const namedImport of importDeclaration.getNamedImports()) {\n      // An unresolved import aliases the checker's unknown symbol, which has no declarations.\n      // A renamed import carries its symbol on the local name.\n      const localNameNode = namedImport.getAliasNode() ?? namedImport.getNameNode();\n      const declarations = localNameNode.getSymbolOrThrow().getAliasedSymbolOrThrow().getDeclarations();\n      for (const declaration of declarations) {\n        // Only a type is linked from type text; a function's name also matches words that are not references to it.\n        if (isTypeDeclaration(declaration)) {\n          registerPackageDeclaration(namedImport.getName(), declaration.getSourceFile().getFilePath());\n        }\n      }\n    }\n  }\n}\n\n/**\n * Collect top-level exported variable declarations (e.g. `export const EMPTY = ''`).\n *\n * @param src - The source file.\n * @param types - The documented types, keyed by qualified id.\n * @param namespace - The type's namespace.\n */\nexport function collectVariables(src: SourceFile, types: Map<string, TypeInfo>, namespace: string): void {\n  for (const variableStatement of src.getVariableStatements()) {\n    if (!variableStatement.isExported()) {\n      continue;\n    }\n    const declarationKind = variableStatement.getDeclarationKind();\n    for (const declaration of variableStatement.getDeclarations()) {\n      const name = declaration.getName();\n      const key = qualifiedKey(namespace, name);\n      if (types.has(key)) {\n        continue;\n      }\n      types.set(key, {\n        baseTypes: [],\n        description: getDescription(variableStatement),\n        enumMembers: [],\n        examples: getExamples(variableStatement),\n        implementsTypes: [],\n        kind: 'variable',\n        methods: [],\n        name,\n        namespace,\n        properties: [],\n        remarks: getRemarks(variableStatement),\n        typeParameters: [],\n        variableKeyword: declarationKind,\n        variableType: simplifyType(declaration.getType().getText())\n      });\n    }\n  }\n}\n\n/**\n * Compute a hash of every input that decides the generated pages: the generator's own modules, the settings and\n * the entry source files. An unchanged hash lets a run skip the generation.\n *\n * @param entryFiles - The entry source files.\n * @param generatorDirectory - The folder holding the generator's modules.\n * @returns The hash, as hex.\n */\nexport function computeCacheHash(entryFiles: string[], generatorDirectory: string): string {\n  const hash = createHash('sha256');\n\n  // The generator itself\n  const generatorFiles = readdirSync(generatorDirectory).filter((name) => !name.endsWith('.test.ts')).sort();\n  for (const generatorFile of generatorFiles) {\n    hash.update(generatorFile);\n    hash.update(readFileSync(join(generatorDirectory, generatorFile), 'utf-8'));\n  }\n\n  // The settings, which every link and path depends on\n  const settings = getApiDocSettings();\n  hash.update(JSON.stringify({\n    ...settings,\n    externalTypeLinks: [...settings.externalTypeLinks],\n    packageSites: [...settings.packageSites]\n  }));\n\n  // Hash all entry source files\n  for (const filePath of [...entryFiles].sort()) {\n    hash.update(filePath);\n    hash.update(readFileSync(filePath, 'utf-8'));\n  }\n\n  return hash.digest('hex');\n}\n\n/**\n * Compute the namespace (POSIX path relative to `src`, no extension) for a source file.\n *\n * @param srcDirectory - The source folder the namespace is relative to.\n * @param filePath - The file's path.\n * @returns The namespace.\n */\nexport function computeNamespace(srcDirectory: string, filePath: string): string {\n  return relative(srcDirectory, filePath).replaceAll('\\\\', '/').replace(/\\.ts$/, '');\n}\n\n/**\n * Recursively find all documentable `*.ts` entry files under `src`.\n *\n * Excludes: `*.test.ts` (incl. `*.browser.test.ts` / `*.integration.test.ts`), `*.d.ts`,\n * `index.ts`, `__merged.ts`, `setup.ts`, `*-setup.ts`, and any subtree under a `@types`,\n * `styles`, or `test-helpers` directory.\n *\n * @param directory - The folder to search.\n * @returns The entry files' paths.\n */\nexport function findEntryFiles(directory: string): string[] {\n  const results: string[] = [];\n  for (const entry of readdirSync(directory, { withFileTypes: true })) {\n    const fullPath = join(directory, entry.name);\n    if (entry.isDirectory()) {\n      if (EXCLUDED_DIR_SEGMENTS.has(entry.name)) {\n        continue;\n      }\n      results.push(...findEntryFiles(fullPath));\n    } else if (isEntryFile(entry.name)) {\n      results.push(fullPath);\n    }\n  }\n  return results;\n}\n\n/**\n * Collects a source file's exported type aliases, enums, interfaces and classes.\n *\n * @param src - The source file.\n * @param types - The documented types, keyed by qualified id.\n * @param namespace - The type's namespace.\n */\nexport function processSourceFile(src: SourceFile, types: Map<string, TypeInfo>, namespace: string): void {\n  for (const alias of src.getTypeAliases()) {\n    if (!alias.isExported()) {\n      continue;\n    }\n    const key = qualifiedKey(namespace, alias.getName());\n    if (!types.has(key)) {\n      types.set(key, extractTypeAliasInfo(alias, namespace));\n    }\n  }\n\n  for (const enumDeclaration of src.getEnums()) {\n    if (!enumDeclaration.isExported()) {\n      continue;\n    }\n    const key = qualifiedKey(namespace, enumDeclaration.getName());\n    if (!types.has(key)) {\n      types.set(key, extractEnumInfo(enumDeclaration, namespace));\n    }\n  }\n\n  for (const iface of src.getInterfaces()) {\n    if (!iface.isExported()) {\n      continue;\n    }\n    const key = qualifiedKey(namespace, iface.getName());\n    if (!types.has(key)) {\n      types.set(key, extractInterfaceInfo(iface, namespace));\n    }\n  }\n\n  for (const cls of src.getClasses()) {\n    if (!cls.isExported()) {\n      continue;\n    }\n    const name = cls.getName();\n    if (!name) {\n      continue;\n    }\n    const key = qualifiedKey(namespace, name);\n    if (!types.has(key)) {\n      types.set(key, extractClassInfo(cls, namespace));\n    }\n  }\n}\n\n/**\n * Register all type parameter names so renderTypeWithLinks won't hyperlink them.\n * Skip names that are also known types — those should still be linkable.\n *\n * @param types - The documented types, keyed by qualified id.\n */\nexport function registerGenericTypeParams(types: Map<string, TypeInfo>): void {\n  const knownNames = new Set<string>();\n  for (const [, info] of types) {\n    knownNames.add(info.name);\n  }\n  for (const [, info] of types) {\n    for (const tp of info.typeParameters) {\n      const bareParameter = tp.replace(/\\s+extends\\s+.*$/, '');\n      if (!knownNames.has(bareParameter)) {\n        GENERIC_TYPE_PARAMS.add(bareParameter);\n      }\n    }\n  }\n}\n\nfunction isEntryFile(name: string): boolean {\n  // The `.test.ts` clause covers *.test.ts, *.browser.test.ts, *.integration.test.ts\n  return !(!name.endsWith('.ts') || name.endsWith('.d.ts') || ['__merged.ts', 'index.ts', 'setup.ts'].includes(name) || name.endsWith('-setup.ts') || name.endsWith('.test.ts'));\n}\n\nfunction isTypeDeclaration(declaration: Node): boolean {\n  return Node.isClassDeclaration(declaration) || Node.isInterfaceDeclaration(declaration) || Node.isTypeAliasDeclaration(declaration) || Node.isEnumDeclaration(declaration);\n}\n\nfunction qualifiedKey(namespace: string, name: string): string {\n  return `${namespace}#${name}`;\n}\n"],"mappings":"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","names":[]}