@mnaoumov/typescript-dev-toolkit 1.3.0 → 2.0.0

package/dist/lib/esm/docs-site/api-doc-route-segments.d.mts

@@ -0,0 +1,25 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @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/esm/docs-site/api-doc-route-segments.mjs

@@ -0,0 +1,17 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+function toRouteSegment(segment) {
+  return segment.toLowerCase();
+}
+function toRouteSegmentPreserveCase(segment) {
+  const cleaned = segment.replaceAll(/[^a-zA-Z0-9]+/g, "-").replaceAll(/^-|-$/g, "");
+  return cleaned || "unnamed";
+}
+export {
+  toRouteSegment,
+  toRouteSegmentPreserveCase
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/docs-site/api-doc-settings.d.mts

@@ -0,0 +1,53 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @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/esm/docs-site/api-doc-settings.mjs

@@ -0,0 +1,22 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+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;
+}
+export {
+  configureApiDocs,
+  getApiDocSettings
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/docs-site/api-doc-source-processing.d.mts

@@ -0,0 +1,75 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Source discovery + extraction: walks `src`, filters to documentable entry files, and turns each
+ * file's exported declarations into `TypeInfo` entries keyed by a qualified `${namespace}#${name}`.
+ */
+import type { SourceFile } from 'ts-morph';
+import type { TypeInfo } from './api-doc-types.mjs';
+/**
+ * Collect top-level exported functions.
+ *
+ * @param src - The source file.
+ * @param types - The documented types, keyed by qualified id.
+ * @param namespace - The type's namespace.
+ */
+export declare function collectFunctions(src: SourceFile, types: Map<string, TypeInfo>, namespace: string): void;
+/**
+ * Records where every symbol a source file imports is declared, so a type another documented package declares
+ * links to that package's site.
+ *
+ * @param src - The source file.
+ */
+export declare function collectPackageDeclarations(src: SourceFile): void;
+/**
+ * Collect top-level exported variable declarations (e.g. `export const EMPTY = ''`).
+ *
+ * @param src - The source file.
+ * @param types - The documented types, keyed by qualified id.
+ * @param namespace - The type's namespace.
+ */
+export declare function collectVariables(src: SourceFile, types: Map<string, TypeInfo>, namespace: string): void;
+/**
+ * Compute a hash of every input that decides the generated pages: the generator's own modules, the settings and
+ * the entry source files. An unchanged hash lets a run skip the generation.
+ *
+ * @param entryFiles - The entry source files.
+ * @param generatorDirectory - The folder holding the generator's modules.
+ * @returns The hash, as hex.
+ */
+export declare function computeCacheHash(entryFiles: string[], generatorDirectory: string): string;
+/**
+ * Compute the namespace (POSIX path relative to `src`, no extension) for a source file.
+ *
+ * @param srcDirectory - The source folder the namespace is relative to.
+ * @param filePath - The file's path.
+ * @returns The namespace.
+ */
+export declare function computeNamespace(srcDirectory: string, filePath: string): string;
+/**
+ * Recursively find all documentable `*.ts` entry files under `src`.
+ *
+ * Excludes: `*.test.ts` (incl. `*.browser.test.ts` / `*.integration.test.ts`), `*.d.ts`,
+ * `index.ts`, `__merged.ts`, `setup.ts`, `*-setup.ts`, and any subtree under a `@types`,
+ * `styles`, or `test-helpers` directory.
+ *
+ * @param directory - The folder to search.
+ * @returns The entry files' paths.
+ */
+export declare function findEntryFiles(directory: string): string[];
+/**
+ * Collects a source file's exported type aliases, enums, interfaces and classes.
+ *
+ * @param src - The source file.
+ * @param types - The documented types, keyed by qualified id.
+ * @param namespace - The type's namespace.
+ */
+export declare function processSourceFile(src: SourceFile, types: Map<string, TypeInfo>, namespace: string): void;
+/**
+ * Register all type parameter names so renderTypeWithLinks won't hyperlink them.
+ * Skip names that are also known types — those should still be linkable.
+ *
+ * @param types - The documented types, keyed by qualified id.
+ */
+export declare function registerGenericTypeParams(types: Map<string, TypeInfo>): void;

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

@@ -0,0 +1,274 @@
+/*
+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 { createHash } from "node:crypto";
+import {
+  readdirSync,
+  readFileSync
+} from "node:fs";
+import {
+  join,
+  relative
+} from "node:path";
+import { Node } from "ts-morph";
+import { GENERIC_TYPE_PARAMS } from "./api-doc-constants.mjs";
+import {
+  extractClassInfo,
+  extractEnumInfo,
+  extractInterfaceInfo,
+  extractTypeAliasInfo,
+  getDescription,
+  getExamples,
+  getParameterDescriptions,
+  getRemarks,
+  getReturnDescription,
+  getSince
+} from "./api-doc-jsdoc.mjs";
+import { registerPackageDeclaration } from "./api-doc-package-sites.mjs";
+import { getApiDocSettings } from "./api-doc-settings.mjs";
+import { simplifyType } from "./api-doc-text-utils.mjs";
+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 = getParameterDescriptions($function);
+    const params = $function.getParameters().map((p) => ({
+      description: parameterDescriptions.get(p.getName()) ?? "",
+      name: p.getName(),
+      type: simplifyType(p.getType().getText())
+    }));
+    const parameterString = params.map((p) => `${p.name}: ${p.type}`).join(", ");
+    const returnType = simplifyType($function.getReturnType().getText());
+    const signature = `${name}(${parameterString})`;
+    types.set(key, {
+      baseTypes: [],
+      description: getDescription($function),
+      enumMembers: [],
+      examples: getExamples($function),
+      implementsTypes: [],
+      kind: "function",
+      methods: [{
+        description: getDescription($function),
+        examples: getExamples($function),
+        inheritedFrom: "",
+        isStatic: false,
+        name,
+        overloadKey: name,
+        parameters: params,
+        remarks: getRemarks($function),
+        returnDescription: getReturnDescription($function),
+        returnType,
+        signature,
+        since: getSince($function),
+        type: ""
+      }],
+      name,
+      namespace,
+      properties: [],
+      remarks: 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)) {
+          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: getDescription(variableStatement),
+        enumMembers: [],
+        examples: getExamples(variableStatement),
+        implementsTypes: [],
+        kind: "variable",
+        methods: [],
+        name,
+        namespace,
+        properties: [],
+        remarks: getRemarks(variableStatement),
+        typeParameters: [],
+        variableKeyword: declarationKind,
+        variableType: simplifyType(declaration.getType().getText())
+      });
+    }
+  }
+}
+function computeCacheHash(entryFiles, generatorDirectory) {
+  const hash = createHash("sha256");
+  const generatorFiles = readdirSync(generatorDirectory).filter((name) => !name.endsWith(".test.ts")).sort();
+  for (const generatorFile of generatorFiles) {
+    hash.update(generatorFile);
+    hash.update(readFileSync(join(generatorDirectory, generatorFile), "utf-8"));
+  }
+  const settings = getApiDocSettings();
+  hash.update(JSON.stringify({
+    ...settings,
+    externalTypeLinks: [...settings.externalTypeLinks],
+    packageSites: [...settings.packageSites]
+  }));
+  for (const filePath of [...entryFiles].sort()) {
+    hash.update(filePath);
+    hash.update(readFileSync(filePath, "utf-8"));
+  }
+  return hash.digest("hex");
+}
+function computeNamespace(srcDirectory, filePath) {
+  return relative(srcDirectory, filePath).replaceAll("\\", "/").replace(/\.ts$/, "");
+}
+function findEntryFiles(directory) {
+  const results = [];
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const fullPath = 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, 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, 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, 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, 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)) {
+        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 Node.isClassDeclaration(declaration) || Node.isInterfaceDeclaration(declaration) || Node.isTypeAliasDeclaration(declaration) || Node.isEnumDeclaration(declaration);
+}
+function qualifiedKey(namespace, name) {
+  return `${namespace}#${name}`;
+}
+export {
+  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":[]}