@fgv/typedoc-compact-theme 1.0.0

package/lib/index.js

@@ -0,0 +1,1083 @@
+/**
+ * TypeDoc Compact Theme
+ *
+ * Renders API documentation in a compact HTML table format similar to api-documenter.
+ * Uses TypeDoc's project model directly, bypassing the theme partial system for
+ * complete control over output format.
+ *
+ * Properties table: Property | Modifiers | Type | Description (includes accessors)
+ * Methods table: Method | Modifiers | Description
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { Application, Converter, DeclarationReflection, ParameterType, ProjectReflection, ReflectionKind } from 'typedoc';
+/**
+ * Renders a class or interface to markdown.
+ */
+class CompactMarkdownRenderer {
+    _outputDir;
+    _options;
+    _urlMap = new Map();
+    _currentFilePath = '';
+    constructor(outputDir, options) {
+        this._outputDir = outputDir;
+        this._options = options;
+    }
+    /**
+     * Render the entire project.
+     */
+    renderProject(project) {
+        // Clear and recreate output directory to remove stale files
+        if (fs.existsSync(this._outputDir)) {
+            fs.rmSync(this._outputDir, { recursive: true });
+        }
+        fs.mkdirSync(this._outputDir, { recursive: true });
+        // First pass: build URL map for all types
+        this._buildUrlMap(project, '');
+        // Render index
+        this._renderIndex(project);
+        // Recursively render all declarations
+        this._renderChildren(project, '');
+    }
+    /**
+     * Build URL map for all documented types.
+     */
+    _buildUrlMap(parent, basePath) {
+        if (!(parent instanceof DeclarationReflection) && !(parent instanceof ProjectReflection)) {
+            return;
+        }
+        const children = parent.children ?? [];
+        for (const child of children) {
+            const name = child.name;
+            let subdir = '';
+            let shouldIndex = true;
+            if (child.kind === ReflectionKind.Class) {
+                subdir = 'classes';
+            }
+            else if (child.kind === ReflectionKind.Interface) {
+                subdir = 'interfaces';
+            }
+            else if (child.kind === ReflectionKind.Enum) {
+                subdir = 'enums';
+            }
+            else if (child.kind === ReflectionKind.TypeAlias) {
+                subdir = 'type-aliases';
+            }
+            else if (child.kind === ReflectionKind.Function) {
+                subdir = 'functions';
+            }
+            else if (child.kind === ReflectionKind.Variable) {
+                subdir = 'variables';
+            }
+            else if (child.kind === ReflectionKind.Namespace || child.kind === ReflectionKind.Module) {
+                // Recurse into namespaces
+                const nsPath = path.join(basePath, this._sanitizeName(child.name));
+                this._buildUrlMap(child, nsPath);
+                shouldIndex = false;
+            }
+            else {
+                shouldIndex = false;
+            }
+            if (shouldIndex && subdir) {
+                const url = path.join(basePath, subdir, `${this._sanitizeName(name)}.md`);
+                this._urlMap.set(name, { url, kind: child.kind });
+                // Also index with full path for namespaced types
+                if (basePath) {
+                    const fullName = basePath.replace(/\//g, '.') + '.' + name;
+                    this._urlMap.set(fullName, { url, kind: child.kind });
+                }
+            }
+            // Recurse into children for nested types
+            this._buildUrlMap(child, basePath);
+        }
+    }
+    _renderChildren(parent, basePath) {
+        if (!(parent instanceof DeclarationReflection) && !(parent instanceof ProjectReflection)) {
+            return;
+        }
+        const children = parent.children ?? [];
+        for (const child of children) {
+            if (child.kind === ReflectionKind.Class || child.kind === ReflectionKind.Interface) {
+                this._renderClassOrInterface(child, basePath);
+            }
+            else if (child.kind === ReflectionKind.Namespace || child.kind === ReflectionKind.Module) {
+                // Create subdirectory for namespace and render its index
+                const nsPath = path.join(basePath, this._sanitizeName(child.name));
+                this._renderNamespaceIndex(child, nsPath);
+                this._renderChildren(child, nsPath);
+            }
+            else if (child.kind === ReflectionKind.Enum) {
+                this._renderEnum(child, basePath);
+            }
+            else if (child.kind === ReflectionKind.TypeAlias) {
+                this._renderTypeAlias(child, basePath);
+            }
+            else if (child.kind === ReflectionKind.Function) {
+                this._renderFunction(child, basePath);
+            }
+            else if (child.kind === ReflectionKind.Variable) {
+                this._renderVariable(child, basePath);
+            }
+            // Recurse into children
+            this._renderChildren(child, basePath);
+        }
+    }
+    _renderIndex(project) {
+        this._setCurrentFile('README.md');
+        const lines = [];
+        lines.push(`# ${project.name}`);
+        lines.push('');
+        if (project.comment?.summary) {
+            lines.push(this._getCommentText(project.comment.summary));
+            lines.push('');
+        }
+        // Find namespaces/modules first
+        const namespaces = this._findByKind(project, ReflectionKind.Namespace);
+        const modules = this._findByKind(project, ReflectionKind.Module);
+        const allNamespaces = [...namespaces, ...modules];
+        if (allNamespaces.length > 0) {
+            lines.push('## Namespaces');
+            lines.push('');
+            lines.push(this._renderIndexTable(allNamespaces, (n) => `./${this._sanitizeName(n.name)}/README.md`));
+            lines.push('');
+        }
+        // List all top-level exports
+        const classes = this._findByKind(project, ReflectionKind.Class);
+        const interfaces = this._findByKind(project, ReflectionKind.Interface);
+        const enums = this._findByKind(project, ReflectionKind.Enum);
+        const typeAliases = this._findByKind(project, ReflectionKind.TypeAlias);
+        const functions = this._findByKind(project, ReflectionKind.Function);
+        const variables = this._findByKind(project, ReflectionKind.Variable);
+        if (classes.length > 0) {
+            lines.push('## Classes');
+            lines.push('');
+            lines.push(this._renderIndexTable(classes, (c) => `./classes/${this._sanitizeName(c.name)}.md`));
+            lines.push('');
+        }
+        if (interfaces.length > 0) {
+            lines.push('## Interfaces');
+            lines.push('');
+            lines.push(this._renderIndexTable(interfaces, (i) => `./interfaces/${this._sanitizeName(i.name)}.md`));
+            lines.push('');
+        }
+        if (enums.length > 0) {
+            lines.push('## Enums');
+            lines.push('');
+            lines.push(this._renderIndexTable(enums, (e) => `./enums/${this._sanitizeName(e.name)}.md`));
+            lines.push('');
+        }
+        if (typeAliases.length > 0) {
+            lines.push('## Type Aliases');
+            lines.push('');
+            lines.push(this._renderIndexTable(typeAliases, (t) => `./type-aliases/${this._sanitizeName(t.name)}.md`));
+            lines.push('');
+        }
+        if (functions.length > 0) {
+            lines.push('## Functions');
+            lines.push('');
+            lines.push(this._renderIndexTable(functions, (f) => `./functions/${this._sanitizeName(f.name)}.md`));
+            lines.push('');
+        }
+        if (variables.length > 0) {
+            lines.push('## Variables');
+            lines.push('');
+            lines.push(this._renderIndexTable(variables, (v) => `./variables/${this._sanitizeName(v.name)}.md`));
+            lines.push('');
+        }
+        const indexPath = path.join(this._outputDir, 'README.md');
+        fs.writeFileSync(indexPath, lines.join('\n'));
+    }
+    /**
+     * Render an index table for a list of declarations.
+     */
+    _renderIndexTable(items, urlFn) {
+        const lines = [];
+        lines.push('<table><thead><tr><th>');
+        lines.push('');
+        lines.push('Name');
+        lines.push('');
+        lines.push('</th><th>');
+        lines.push('');
+        lines.push('Description');
+        lines.push('');
+        lines.push('</th></tr></thead>');
+        lines.push('<tbody>');
+        for (const item of items) {
+            const url = urlFn(item);
+            const desc = this._getItemDescription(item);
+            lines.push('<tr><td>');
+            lines.push('');
+            lines.push(`[${item.name}](${url})`);
+            lines.push('');
+            lines.push('</td><td>');
+            lines.push('');
+            lines.push(desc);
+            lines.push('');
+            lines.push('</td></tr>');
+        }
+        lines.push('</tbody></table>');
+        return lines.join('\n');
+    }
+    /**
+     * Get description for an item (first line of comment or signature comment).
+     */
+    _getItemDescription(item) {
+        // Try item's own comment
+        if (item.comment?.summary) {
+            return this._getFirstLine(this._getCommentText(item.comment.summary));
+        }
+        // For functions, try signature comment
+        const sig = item.signatures?.[0];
+        if (sig?.comment?.summary) {
+            return this._getFirstLine(this._getCommentText(sig.comment.summary));
+        }
+        // For accessors, try getter/setter comment
+        if (item.getSignature?.comment?.summary) {
+            return this._getFirstLine(this._getCommentText(item.getSignature.comment.summary));
+        }
+        return '';
+    }
+    /**
+     * Get the first line/sentence of a description.
+     */
+    _getFirstLine(text) {
+        // Split on period followed by space or newline
+        const firstSentence = text.split(/\.\s|\.\n/)[0];
+        if (firstSentence && firstSentence !== text) {
+            return firstSentence + '.';
+        }
+        // If no period, take first line
+        const firstLine = text.split('\n')[0];
+        return firstLine.trim();
+    }
+    /**
+     * Render an index page for a namespace/module.
+     */
+    _renderNamespaceIndex(ns, nsPath) {
+        const filePath = path.join(nsPath, 'README.md');
+        this._setCurrentFile(filePath);
+        const lines = [];
+        const kindName = ns.kind === ReflectionKind.Namespace ? 'Namespace' : 'Module';
+        // Breadcrumb - nsPath includes this namespace, file is at nsPath/README.md
+        // We need to go up one level more than pathParts length to reach root
+        const pathParts = nsPath.split('/').filter((p) => p);
+        const depth = pathParts.length;
+        const homePrefix = '../'.repeat(depth);
+        const breadcrumbParts = [`[Home](${homePrefix}README.md)`];
+        // Add parent namespaces (all but the last one)
+        for (let i = 0; i < pathParts.length - 1; i++) {
+            const levelsUp = depth - (i + 1);
+            const nsPrefix = '../'.repeat(levelsUp);
+            breadcrumbParts.push(`[${pathParts[i]}](${nsPrefix}README.md)`);
+        }
+        // Current namespace (not linked)
+        breadcrumbParts.push(ns.name);
+        lines.push(breadcrumbParts.join(' > '));
+        lines.push('');
+        lines.push(`# ${kindName}: ${ns.name}`);
+        lines.push('');
+        if (ns.comment?.summary) {
+            lines.push(this._getCommentText(ns.comment.summary));
+            lines.push('');
+        }
+        // Collect children by kind
+        const children = ns.children ?? [];
+        const childNamespaces = children.filter((c) => c.kind === ReflectionKind.Namespace || c.kind === ReflectionKind.Module);
+        const classes = children.filter((c) => c.kind === ReflectionKind.Class);
+        const interfaces = children.filter((c) => c.kind === ReflectionKind.Interface);
+        const enums = children.filter((c) => c.kind === ReflectionKind.Enum);
+        const typeAliases = children.filter((c) => c.kind === ReflectionKind.TypeAlias);
+        const functions = children.filter((c) => c.kind === ReflectionKind.Function);
+        const variables = children.filter((c) => c.kind === ReflectionKind.Variable);
+        if (childNamespaces.length > 0) {
+            lines.push('## Namespaces');
+            lines.push('');
+            lines.push(this._renderIndexTable(childNamespaces, (n) => `./${this._sanitizeName(n.name)}/README.md`));
+            lines.push('');
+        }
+        if (classes.length > 0) {
+            lines.push('## Classes');
+            lines.push('');
+            lines.push(this._renderIndexTable(classes, (c) => `./classes/${this._sanitizeName(c.name)}.md`));
+            lines.push('');
+        }
+        if (interfaces.length > 0) {
+            lines.push('## Interfaces');
+            lines.push('');
+            lines.push(this._renderIndexTable(interfaces, (i) => `./interfaces/${this._sanitizeName(i.name)}.md`));
+            lines.push('');
+        }
+        if (enums.length > 0) {
+            lines.push('## Enums');
+            lines.push('');
+            lines.push(this._renderIndexTable(enums, (e) => `./enums/${this._sanitizeName(e.name)}.md`));
+            lines.push('');
+        }
+        if (typeAliases.length > 0) {
+            lines.push('## Type Aliases');
+            lines.push('');
+            lines.push(this._renderIndexTable(typeAliases, (t) => `./type-aliases/${this._sanitizeName(t.name)}.md`));
+            lines.push('');
+        }
+        if (functions.length > 0) {
+            lines.push('## Functions');
+            lines.push('');
+            lines.push(this._renderIndexTable(functions, (f) => `./functions/${this._sanitizeName(f.name)}.md`));
+            lines.push('');
+        }
+        if (variables.length > 0) {
+            lines.push('## Variables');
+            lines.push('');
+            lines.push(this._renderIndexTable(variables, (v) => `./variables/${this._sanitizeName(v.name)}.md`));
+            lines.push('');
+        }
+        // Ensure directory exists
+        const outDir = path.join(this._outputDir, nsPath);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        const outPath = path.join(this._outputDir, filePath);
+        fs.writeFileSync(outPath, lines.join('\n'));
+    }
+    _renderClassOrInterface(decl, basePath) {
+        const lines = [];
+        const kindName = decl.kind === ReflectionKind.Class ? 'Class' : 'Interface';
+        // Set current file for relative URL computation
+        const subdir = decl.kind === ReflectionKind.Class ? 'classes' : 'interfaces';
+        const filePath = path.join(basePath, subdir, `${this._sanitizeName(decl.name)}.md`);
+        this._setCurrentFile(filePath);
+        // Breadcrumb
+        lines.push(this._generateBreadcrumb(basePath, decl.name, subdir));
+        lines.push('');
+        // Header
+        lines.push(`# ${kindName}: ${decl.name}`);
+        lines.push('');
+        // Description
+        if (decl.comment?.summary) {
+            lines.push(this._getCommentText(decl.comment.summary));
+            lines.push('');
+        }
+        // Extends and Implements on single lines with links
+        if (decl.extendedTypes && decl.extendedTypes.length > 0) {
+            const extList = decl.extendedTypes.map((t) => this._linkTypeInline(t.toString())).join(', ');
+            lines.push(`**Extends:** ${extList}`);
+            lines.push('');
+        }
+        if (decl.implementedTypes && decl.implementedTypes.length > 0) {
+            const implList = decl.implementedTypes.map((t) => this._linkTypeInline(t.toString())).join(', ');
+            lines.push(`**Implements:** ${implList}`);
+            lines.push('');
+        }
+        // Collect members by category
+        const children = decl.children ?? [];
+        const constructors = children.filter((c) => c.kind === ReflectionKind.Constructor);
+        const properties = children.filter((c) => c.kind === ReflectionKind.Property);
+        const accessors = children.filter((c) => c.kind === ReflectionKind.Accessor);
+        const methods = children.filter((c) => c.kind === ReflectionKind.Method);
+        // Member detail pages base path
+        const memberBasePath = path.join(basePath, subdir);
+        // Render constructors
+        if (constructors.length > 0) {
+            lines.push('## Constructors');
+            lines.push('');
+            lines.push(this._renderConstructorsTable(constructors, decl.name, memberBasePath));
+            lines.push('');
+        }
+        // Render properties + accessors combined
+        const allProperties = [...properties, ...accessors];
+        if (allProperties.length > 0) {
+            lines.push('## Properties');
+            lines.push('');
+            lines.push(this._renderPropertiesTable(allProperties, decl.name, memberBasePath));
+            lines.push('');
+            // Render property detail pages (optionally skip inherited members)
+            for (const prop of allProperties) {
+                if (this._options.includeInheritedMemberPages || !prop.inheritedFrom) {
+                    this._renderPropertyDetailPage(prop, decl, memberBasePath);
+                }
+            }
+        }
+        // Render methods
+        if (methods.length > 0) {
+            lines.push('## Methods');
+            lines.push('');
+            lines.push(this._renderMethodsTable(methods, decl.name, memberBasePath));
+            lines.push('');
+            // Render method detail pages (optionally skip inherited members)
+            for (const method of methods) {
+                if (this._options.includeInheritedMemberPages || !method.inheritedFrom) {
+                    this._renderMethodDetailPage(method, decl, memberBasePath);
+                }
+            }
+        }
+        // Write file
+        const outDir = path.join(this._outputDir, basePath, subdir);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        const outPath = path.join(outDir, `${this._sanitizeName(decl.name)}.md`);
+        fs.writeFileSync(outPath, lines.join('\n'));
+    }
+    /**
+     * Render a detail page for a property or accessor.
+     */
+    _renderPropertyDetailPage(prop, parent, basePath) {
+        const fileName = `${this._sanitizeName(parent.name)}.${this._sanitizeName(prop.name)}.md`;
+        const filePath = path.join(basePath, fileName);
+        this._setCurrentFile(filePath);
+        const lines = [];
+        const kindLabel = prop.kind === ReflectionKind.Accessor ? 'property' : 'property';
+        // Breadcrumb: extract namespace path from basePath (which is like "Namespace/classes")
+        const pathParts = basePath.split('/').filter((p) => p);
+        const subdir = pathParts.pop(); // Remove "classes" or "interfaces"
+        const namespacePath = pathParts.join('/');
+        // Generate breadcrumb with linked parent class
+        const breadcrumbParts = [];
+        const depth = pathParts.length + 1; // +1 for subdir
+        breadcrumbParts.push(`[Home](${'../'.repeat(depth)}README.md)`);
+        // Add namespace parts
+        for (let i = 0; i < pathParts.length; i++) {
+            const levelsUp = depth - (i + 1);
+            breadcrumbParts.push(`[${pathParts[i]}](${'../'.repeat(levelsUp)}README.md)`);
+        }
+        // Add linked parent class
+        breadcrumbParts.push(`[${parent.name}](./${this._sanitizeName(parent.name)}.md)`);
+        // Add current property (unlinked)
+        breadcrumbParts.push(prop.name);
+        lines.push(breadcrumbParts.join(' > '));
+        lines.push('');
+        // Header
+        lines.push(`## ${parent.name}.${prop.name} ${kindLabel}`);
+        lines.push('');
+        // Description
+        let description = '';
+        if (prop.kind === ReflectionKind.Accessor) {
+            const getter = prop.getSignature;
+            const setter = prop.setSignature;
+            if (getter?.comment?.summary) {
+                description = this._getCommentText(getter.comment.summary);
+            }
+            else if (setter?.comment?.summary) {
+                description = this._getCommentText(setter.comment.summary);
+            }
+        }
+        else if (prop.comment?.summary) {
+            description = this._getCommentText(prop.comment.summary);
+        }
+        if (description) {
+            lines.push(description);
+            lines.push('');
+        }
+        // Signature
+        lines.push('**Signature:**');
+        lines.push('');
+        lines.push('```typescript');
+        lines.push(this._getPropertySignature(prop));
+        lines.push('```');
+        lines.push('');
+        // Write file
+        const outDir = path.join(this._outputDir, basePath);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        const outPath = path.join(this._outputDir, filePath);
+        fs.writeFileSync(outPath, lines.join('\n'));
+    }
+    /**
+     * Render a detail page for a method.
+     */
+    _renderMethodDetailPage(method, parent, basePath) {
+        const fileName = `${this._sanitizeName(parent.name)}.${this._sanitizeName(method.name)}.md`;
+        const filePath = path.join(basePath, fileName);
+        this._setCurrentFile(filePath);
+        const lines = [];
+        // Breadcrumb: extract namespace path from basePath (which is like "Namespace/classes")
+        const pathParts = basePath.split('/').filter((p) => p);
+        pathParts.pop(); // Remove "classes" or "interfaces"
+        // Generate breadcrumb with linked parent class
+        const breadcrumbParts = [];
+        const depth = pathParts.length + 1; // +1 for subdir
+        breadcrumbParts.push(`[Home](${'../'.repeat(depth)}README.md)`);
+        // Add namespace parts
+        for (let i = 0; i < pathParts.length; i++) {
+            const levelsUp = depth - (i + 1);
+            breadcrumbParts.push(`[${pathParts[i]}](${'../'.repeat(levelsUp)}README.md)`);
+        }
+        // Add linked parent class
+        breadcrumbParts.push(`[${parent.name}](./${this._sanitizeName(parent.name)}.md)`);
+        // Add current method (unlinked)
+        breadcrumbParts.push(method.name);
+        lines.push(breadcrumbParts.join(' > '));
+        lines.push('');
+        // Header
+        lines.push(`## ${parent.name}.${method.name}() method`);
+        lines.push('');
+        // Description from signature
+        const sig = method.signatures?.[0];
+        if (sig?.comment?.summary) {
+            lines.push(this._getCommentText(sig.comment.summary));
+            lines.push('');
+        }
+        // Signature
+        lines.push('**Signature:**');
+        lines.push('');
+        lines.push('```typescript');
+        lines.push(this._getMethodSignature(method));
+        lines.push('```');
+        lines.push('');
+        // Parameters
+        if (sig?.parameters && sig.parameters.length > 0) {
+            lines.push('**Parameters:**');
+            lines.push('');
+            lines.push('<table><thead><tr><th>Parameter</th><th>Type</th><th>Description</th></tr></thead>');
+            lines.push('<tbody>');
+            for (const param of sig.parameters) {
+                const paramType = param.type?.toString() ?? 'unknown';
+                const paramDesc = param.comment?.summary ? this._getCommentText(param.comment.summary) : '';
+                lines.push(`<tr><td>${param.name}</td><td>${this._escapeHtml(paramType)}</td><td>${paramDesc}</td></tr>`);
+            }
+            lines.push('</tbody></table>');
+            lines.push('');
+        }
+        // Returns
+        if (sig?.type) {
+            lines.push('**Returns:**');
+            lines.push('');
+            lines.push(`${this._linkType(sig.type.toString())}`);
+            if (sig.comment?.blockTags) {
+                const returnsTag = sig.comment.blockTags.find((t) => t.tag === '@returns');
+                if (returnsTag?.content) {
+                    lines.push('');
+                    lines.push(this._getCommentText(returnsTag.content));
+                }
+            }
+            lines.push('');
+        }
+        // Write file
+        const outDir = path.join(this._outputDir, basePath);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        const outPath = path.join(this._outputDir, filePath);
+        fs.writeFileSync(outPath, lines.join('\n'));
+    }
+    /**
+     * Get signature string for a property.
+     */
+    _getPropertySignature(prop) {
+        const modifiers = [];
+        if (prop.flags?.isReadonly)
+            modifiers.push('readonly');
+        if (prop.flags?.isStatic)
+            modifiers.push('static');
+        let typeStr = '';
+        if (prop.kind === ReflectionKind.Accessor) {
+            const getter = prop.getSignature;
+            const setter = prop.setSignature;
+            if (getter?.type) {
+                typeStr = getter.type.toString();
+            }
+            else if (setter?.parameters?.[0]?.type) {
+                typeStr = setter.parameters[0].type.toString();
+            }
+            if (getter && !setter)
+                modifiers.push('readonly');
+        }
+        else {
+            typeStr = prop.type?.toString() ?? 'unknown';
+        }
+        const modStr = modifiers.length > 0 ? modifiers.join(' ') + ' ' : '';
+        return `${modStr}${prop.name}: ${typeStr};`;
+    }
+    /**
+     * Get signature string for a method.
+     */
+    _getMethodSignature(method) {
+        const sig = method.signatures?.[0];
+        if (!sig)
+            return `${method.name}(): unknown;`;
+        const modifiers = [];
+        if (method.flags?.isStatic)
+            modifiers.push('static');
+        const params = sig.parameters
+            ?.map((p) => {
+            const optional = p.flags?.isOptional ? '?' : '';
+            return `${p.name}${optional}: ${p.type?.toString() ?? 'unknown'}`;
+        })
+            .join(', ') ?? '';
+        const returnType = sig.type?.toString() ?? 'void';
+        const modStr = modifiers.length > 0 ? modifiers.join(' ') + ' ' : '';
+        return `${modStr}${method.name}(${params}): ${returnType};`;
+    }
+    _renderEnum(decl, basePath) {
+        const lines = [];
+        // Breadcrumb
+        lines.push(this._generateBreadcrumb(basePath, decl.name, 'enums'));
+        lines.push('');
+        lines.push(`# Enum: ${decl.name}`);
+        lines.push('');
+        if (decl.comment?.summary) {
+            lines.push(this._getCommentText(decl.comment.summary));
+            lines.push('');
+        }
+        const members = decl.children ?? [];
+        if (members.length > 0) {
+            lines.push('## Members');
+            lines.push('');
+            lines.push('<table><thead><tr><th>');
+            lines.push('');
+            lines.push('Member');
+            lines.push('');
+            lines.push('</th><th>');
+            lines.push('');
+            lines.push('Value');
+            lines.push('');
+            lines.push('</th><th>');
+            lines.push('');
+            lines.push('Description');
+            lines.push('');
+            lines.push('</th></tr></thead>');
+            lines.push('<tbody>');
+            for (const member of members) {
+                const value = member.type?.toString() ?? '';
+                const desc = member.comment?.summary ? this._getCommentText(member.comment.summary) : '';
+                lines.push('<tr><td>');
+                lines.push('');
+                lines.push(`\`${member.name}\``);
+                lines.push('');
+                lines.push('</td><td>');
+                lines.push('');
+                lines.push(value);
+                lines.push('');
+                lines.push('</td><td>');
+                lines.push('');
+                lines.push(desc);
+                lines.push('');
+                lines.push('</td></tr>');
+            }
+            lines.push('</tbody></table>');
+            lines.push('');
+        }
+        const outDir = path.join(this._outputDir, basePath, 'enums');
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        const outPath = path.join(outDir, `${this._sanitizeName(decl.name)}.md`);
+        fs.writeFileSync(outPath, lines.join('\n'));
+    }
+    _renderTypeAlias(decl, basePath) {
+        const lines = [];
+        // Breadcrumb
+        lines.push(this._generateBreadcrumb(basePath, decl.name, 'type-aliases'));
+        lines.push('');
+        lines.push(`# Type Alias: ${decl.name}`);
+        lines.push('');
+        if (decl.comment?.summary) {
+            lines.push(this._getCommentText(decl.comment.summary));
+            lines.push('');
+        }
+        if (decl.type) {
+            lines.push('## Type');
+            lines.push('');
+            lines.push('```typescript');
+            lines.push(`type ${decl.name} = ${decl.type.toString()}`);
+            lines.push('```');
+            lines.push('');
+        }
+        const outDir = path.join(this._outputDir, basePath, 'type-aliases');
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        const outPath = path.join(outDir, `${this._sanitizeName(decl.name)}.md`);
+        fs.writeFileSync(outPath, lines.join('\n'));
+    }
+    _renderFunction(decl, basePath) {
+        const lines = [];
+        // Breadcrumb
+        lines.push(this._generateBreadcrumb(basePath, decl.name, 'functions'));
+        lines.push('');
+        lines.push(`# Function: ${decl.name}`);
+        lines.push('');
+        const sig = decl.signatures?.[0];
+        if (sig?.comment?.summary) {
+            lines.push(this._getCommentText(sig.comment.summary));
+            lines.push('');
+        }
+        if (sig) {
+            lines.push('## Signature');
+            lines.push('');
+            lines.push('```typescript');
+            lines.push(this._renderSignature(decl.name, sig));
+            lines.push('```');
+            lines.push('');
+        }
+        const outDir = path.join(this._outputDir, basePath, 'functions');
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        const outPath = path.join(outDir, `${this._sanitizeName(decl.name)}.md`);
+        fs.writeFileSync(outPath, lines.join('\n'));
+    }
+    _renderVariable(decl, basePath) {
+        const lines = [];
+        // Breadcrumb
+        lines.push(this._generateBreadcrumb(basePath, decl.name, 'variables'));
+        lines.push('');
+        lines.push(`# Variable: ${decl.name}`);
+        lines.push('');
+        if (decl.comment?.summary) {
+            lines.push(this._getCommentText(decl.comment.summary));
+            lines.push('');
+        }
+        if (decl.type) {
+            lines.push('## Type');
+            lines.push('');
+            lines.push(`\`${decl.type.toString()}\``);
+            lines.push('');
+        }
+        const outDir = path.join(this._outputDir, basePath, 'variables');
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        const outPath = path.join(outDir, `${this._sanitizeName(decl.name)}.md`);
+        fs.writeFileSync(outPath, lines.join('\n'));
+    }
+    _renderConstructorsTable(constructors, _parentName, _basePath) {
+        const lines = [];
+        lines.push('<table><thead><tr><th>');
+        lines.push('');
+        lines.push('Constructor');
+        lines.push('');
+        lines.push('</th><th>');
+        lines.push('');
+        lines.push('Modifiers');
+        lines.push('');
+        lines.push('</th><th>');
+        lines.push('');
+        lines.push('Description');
+        lines.push('');
+        lines.push('</th></tr></thead>');
+        lines.push('<tbody>');
+        for (const ctor of constructors) {
+            const sig = ctor.signatures?.[0];
+            const params = sig?.parameters?.map((p) => p.name).join(', ') ?? '';
+            const ctorSig = `constructor(${params})`;
+            const modifiers = [];
+            if (ctor.flags?.isProtected)
+                modifiers.push('protected');
+            if (ctor.flags?.isPrivate)
+                modifiers.push('private');
+            const desc = sig?.comment?.summary ? this._getCommentText(sig.comment.summary) : '';
+            lines.push('<tr><td>');
+            lines.push('');
+            lines.push(`\`${ctorSig}\``);
+            lines.push('');
+            lines.push('</td><td>');
+            lines.push('');
+            lines.push(modifiers.map((m) => `\`${m}\``).join(' '));
+            lines.push('');
+            lines.push('</td><td>');
+            lines.push('');
+            lines.push(desc);
+            lines.push('');
+            lines.push('</td></tr>');
+        }
+        lines.push('</tbody></table>');
+        return lines.join('\n');
+    }
+    _renderPropertiesTable(members, parentName, _basePath) {
+        const lines = [];
+        lines.push('<table><thead><tr><th>');
+        lines.push('');
+        lines.push('Property');
+        lines.push('');
+        lines.push('</th><th>');
+        lines.push('');
+        lines.push('Modifiers');
+        lines.push('');
+        lines.push('</th><th>');
+        lines.push('');
+        lines.push('Type');
+        lines.push('');
+        lines.push('</th><th>');
+        lines.push('');
+        lines.push('Description');
+        lines.push('');
+        lines.push('</th></tr></thead>');
+        lines.push('<tbody>');
+        for (const member of members) {
+            if (member.kind === ReflectionKind.Accessor) {
+                lines.push(this._renderAccessorRow(member, parentName));
+            }
+            else {
+                lines.push(this._renderPropertyRow(member, parentName));
+            }
+        }
+        lines.push('</tbody></table>');
+        return lines.join('\n');
+    }
+    _renderPropertyRow(prop, parentName) {
+        const typeStr = prop.type?.toString() ?? '';
+        const modifiers = [];
+        if (prop.flags?.isReadonly)
+            modifiers.push('readonly');
+        if (prop.flags?.isProtected)
+            modifiers.push('protected');
+        if (prop.flags?.isPrivate)
+            modifiers.push('private');
+        if (prop.flags?.isStatic)
+            modifiers.push('static');
+        const desc = prop.comment?.summary ? this._getFirstLine(this._getCommentText(prop.comment.summary)) : '';
+        // For inherited members, link to the defining class's detail page (unless includeInheritedMemberPages is true)
+        const definingClass = !this._options.includeInheritedMemberPages && prop.inheritedFrom
+            ? this._sanitizeName(prop.inheritedFrom.reflection?.parent?.name ?? parentName)
+            : parentName;
+        const detailUrl = `./${this._sanitizeName(definingClass)}.${this._sanitizeName(prop.name)}.md`;
+        return this._formatTableRow(prop.name, modifiers, typeStr, desc, detailUrl);
+    }
+    _renderAccessorRow(accessor, parentName) {
+        const getter = accessor.getSignature;
+        const setter = accessor.setSignature;
+        let typeStr = '';
+        if (getter?.type) {
+            typeStr = getter.type.toString();
+        }
+        else if (setter?.parameters?.[0]?.type) {
+            typeStr = setter.parameters[0].type.toString();
+        }
+        const modifiers = [];
+        if (getter && !setter)
+            modifiers.push('readonly');
+        if (accessor.flags?.isProtected)
+            modifiers.push('protected');
+        if (accessor.flags?.isPrivate)
+            modifiers.push('private');
+        if (accessor.flags?.isStatic)
+            modifiers.push('static');
+        let desc = '';
+        if (getter?.comment?.summary) {
+            desc = this._getFirstLine(this._getCommentText(getter.comment.summary));
+        }
+        else if (setter?.comment?.summary) {
+            desc = this._getFirstLine(this._getCommentText(setter.comment.summary));
+        }
+        // For inherited members, link to the defining class's detail page (unless includeInheritedMemberPages is true)
+        const definingClass = !this._options.includeInheritedMemberPages && accessor.inheritedFrom
+            ? this._sanitizeName(accessor.inheritedFrom.reflection?.parent?.name ?? parentName)
+            : parentName;
+        const detailUrl = `./${this._sanitizeName(definingClass)}.${this._sanitizeName(accessor.name)}.md`;
+        return this._formatTableRow(accessor.name, modifiers, typeStr, desc, detailUrl);
+    }
+    _formatTableRow(name, modifiers, type, description, detailUrl) {
+        const linkedType = this._linkType(type);
+        const modifierStr = modifiers.map((m) => `\`${m}\``).join(' ');
+        // Create linked name if detail URL provided
+        const nameDisplay = detailUrl ? `[${name}](${detailUrl})` : `\`${name}\``;
+        const lines = [];
+        lines.push('<tr><td>');
+        lines.push('');
+        lines.push(nameDisplay);
+        lines.push('');
+        lines.push('</td><td>');
+        lines.push('');
+        lines.push(modifierStr);
+        lines.push('');
+        lines.push('</td><td>');
+        lines.push('');
+        lines.push(linkedType);
+        lines.push('');
+        lines.push('</td><td>');
+        lines.push('');
+        lines.push(description);
+        lines.push('');
+        lines.push('</td></tr>');
+        return lines.join('\n');
+    }
+    _renderMethodsTable(methods, parentName, _basePath) {
+        const lines = [];
+        lines.push('<table><thead><tr><th>');
+        lines.push('');
+        lines.push('Method');
+        lines.push('');
+        lines.push('</th><th>');
+        lines.push('');
+        lines.push('Modifiers');
+        lines.push('');
+        lines.push('</th><th>');
+        lines.push('');
+        lines.push('Description');
+        lines.push('');
+        lines.push('</th></tr></thead>');
+        lines.push('<tbody>');
+        for (const method of methods) {
+            const sig = method.signatures?.[0];
+            const params = sig?.parameters?.map((p) => p.name).join(', ') ?? '';
+            const methodSig = `${method.name}(${params})`;
+            const modifiers = [];
+            if (method.flags?.isProtected)
+                modifiers.push('protected');
+            if (method.flags?.isPrivate)
+                modifiers.push('private');
+            if (method.flags?.isStatic)
+                modifiers.push('static');
+            const desc = sig?.comment?.summary ? this._getFirstLine(this._getCommentText(sig.comment.summary)) : '';
+            // For inherited members, link to the defining class's detail page (unless includeInheritedMemberPages is true)
+            const definingClass = !this._options.includeInheritedMemberPages && method.inheritedFrom
+                ? this._sanitizeName(method.inheritedFrom.reflection?.parent?.name ?? parentName)
+                : parentName;
+            const detailUrl = `./${this._sanitizeName(definingClass)}.${this._sanitizeName(method.name)}.md`;
+            lines.push('<tr><td>');
+            lines.push('');
+            lines.push(`[${methodSig}](${detailUrl})`);
+            lines.push('');
+            lines.push('</td><td>');
+            lines.push('');
+            lines.push(modifiers.map((m) => `\`${m}\``).join(' '));
+            lines.push('');
+            lines.push('</td><td>');
+            lines.push('');
+            lines.push(desc);
+            lines.push('');
+            lines.push('</td></tr>');
+        }
+        lines.push('</tbody></table>');
+        return lines.join('\n');
+    }
+    _renderSignature(name, sig) {
+        const params = sig.parameters?.map((p) => `${p.name}: ${p.type?.toString() ?? 'unknown'}`).join(', ') ?? '';
+        const returnType = sig.type?.toString() ?? 'void';
+        return `function ${name}(${params}): ${returnType}`;
+    }
+    /**
+     * Find direct children of a specific kind (no recursion into namespaces).
+     */
+    _findByKind(parent, kind) {
+        if (!(parent instanceof DeclarationReflection) && !(parent instanceof ProjectReflection)) {
+            return [];
+        }
+        return (parent.children ?? []).filter((child) => child.kind === kind);
+    }
+    _sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_-]/g, '_');
+    }
+    /**
+     * Generate breadcrumb navigation for a page.
+     * @param basePath - The namespace path (e.g., "LibraryRuntime/Indexers")
+     * @param currentName - The name of the current item
+     * @param subdir - The subdirectory within the namespace (e.g., "classes", "interfaces")
+     */
+    _generateBreadcrumb(basePath, currentName, subdir) {
+        const parts = [];
+        // Calculate how many levels deep we are
+        const pathParts = basePath ? basePath.split('/').filter((p) => p) : [];
+        const subdirDepth = subdir ? 1 : 0;
+        const totalDepth = pathParts.length + subdirDepth;
+        // Home link - go up the appropriate number of directories
+        const homePrefix = totalDepth > 0 ? '../'.repeat(totalDepth) : './';
+        parts.push(`[Home](${homePrefix}README.md)`);
+        // Namespace path components
+        let accumulatedPath = '';
+        for (let i = 0; i < pathParts.length; i++) {
+            const nsName = pathParts[i];
+            accumulatedPath += (accumulatedPath ? '/' : '') + nsName;
+            // Calculate relative path from current location to this namespace
+            const levelsUp = totalDepth - (i + 1);
+            const nsPrefix = levelsUp > 0 ? '../'.repeat(levelsUp) : './';
+            parts.push(`[${nsName}](${nsPrefix}README.md)`);
+        }
+        // Current item (not linked)
+        parts.push(currentName);
+        return parts.join(' > ');
+    }
+    _escapeHtml(str) {
+        return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    }
+    _getCommentText(summary) {
+        return summary.map((part) => part.text).join('');
+    }
+    /**
+     * Compute relative path from current file to target file.
+     */
+    _relativePath(from, to) {
+        const fromDir = path.dirname(from);
+        return path.relative(fromDir, to);
+    }
+    /**
+     * Convert a type string to a linked version where possible (for HTML table cells).
+     * Handles generic types like `Map<K, V>` by linking individual type names.
+     */
+    _linkType(typeStr) {
+        if (!typeStr)
+            return '';
+        // Parse type string and link known types
+        // This regex matches type names (identifiers) that might be linkable
+        const result = typeStr.replace(/\b([A-Z][a-zA-Z0-9_]*)\b/g, (match, typeName) => {
+            const urlInfo = this._urlMap.get(typeName);
+            if (urlInfo) {
+                const relativePath = this._relativePath(this._currentFilePath, urlInfo.url);
+                return `[${typeName}](${relativePath})`;
+            }
+            return match;
+        });
+        return this._escapeHtml(result);
+    }
+    /**
+     * Convert a type string to a linked version for inline markdown (not in HTML tables).
+     * Returns the type wrapped in backticks, with links if the type is documented.
+     */
+    _linkTypeInline(typeStr) {
+        if (!typeStr)
+            return '';
+        // Check if the whole type name (without generics) is linkable
+        const baseType = typeStr.split('<')[0].trim();
+        const urlInfo = this._urlMap.get(baseType);
+        if (urlInfo) {
+            const relativePath = this._relativePath(this._currentFilePath, urlInfo.url);
+            return `[\`${typeStr}\`](${relativePath})`;
+        }
+        return `\`${typeStr}\``;
+    }
+    /**
+     * Set the current file being rendered (for computing relative URLs).
+     */
+    _setCurrentFile(filePath) {
+        this._currentFilePath = filePath;
+    }
+}
+/**
+ * Plugin load function - entry point for TypeDoc.
+ */
+export function load(app) {
+    // Declare custom option for inherited member pages
+    app.options.addDeclaration({
+        name: 'includeInheritedMemberPages',
+        help: '[Compact Theme] Generate separate detail pages for inherited members instead of linking to parent class',
+        type: ParameterType.Boolean,
+        defaultValue: false
+    });
+    // Read options after bootstrap
+    let outputDir;
+    let includeInheritedMemberPages = false;
+    app.on(Application.EVENT_BOOTSTRAP_END, () => {
+        outputDir = app.options.getValue('out');
+        includeInheritedMemberPages = app.options.getValue('includeInheritedMemberPages');
+    });
+    // Render our markdown after conversion completes, before the renderer runs
+    app.converter.on(Converter.EVENT_RESOLVE_END, (context) => {
+        if (!outputDir) {
+            console.error('[compact-markdown] Output directory not set');
+            return;
+        }
+        // Render using our custom format
+        const options = {
+            includeInheritedMemberPages
+        };
+        const renderer = new CompactMarkdownRenderer(outputDir, options);
+        renderer.renderProject(context.project);
+        console.log(`[compact-markdown] Generated markdown documentation at ${outputDir}`);
+        // Exit before TypeDoc's HTML renderer runs
+        // This is the simplest way to prevent default output without intermediate files
+        process.exit(0);
+    });
+}
+//# sourceMappingURL=index.js.map