chore: wip

Author: glennmichael123

packages/dtsx/src/extractor.ts

@@ -4,13 +4,62 @@ import type { Declaration } from './types'
 import { createSourceFile, forEachChild, isArrayBindingPattern, isBindingElement, isCallSignatureDeclaration, isConstructorDeclaration, isConstructSignatureDeclaration, isEnumDeclaration, isEnumMember, isExportAssignment, isFunctionDeclaration, isIdentifier, isInterfaceDeclaration, isMethodDeclaration, isMethodSignature, isModuleBlock, isModuleDeclaration, isObjectBindingPattern, isPropertyDeclaration, isPropertySignature, isStringLiteral, isTypeAliasDeclaration, isVariableStatement, NodeFlags, ScriptKind, ScriptTarget, SyntaxKind } from 'typescript'
 
 /**
- * Extract only public API declarations from TypeScript source code
- * This focuses on what should be in .d.ts files, not implementation details
+ * Cache for parsed SourceFile objects to avoid re-parsing
+ * Key: filePath, Value: { sourceFile, contentHash, lastAccess }
  */
-export function extractDeclarations(sourceCode: string, filePath: string, keepComments: boolean = true): Declaration[] {
-  const declarations: Declaration[] = []
+const sourceFileCache = new Map<string, { sourceFile: SourceFile, contentHash: number, lastAccess: number }>()
+
+/**
+ * Maximum number of cached SourceFiles to prevent memory bloat
+ */
+const MAX_CACHE_SIZE = 100
+
+/**
+ * Simple hash function for content comparison
+ */
+function hashContent(content: string): number {
+  let hash = 0
+  for (let i = 0; i < content.length; i++) {
+    const char = content.charCodeAt(i)
+    hash = ((hash << 5) - hash) + char
+    hash = hash & hash // Convert to 32-bit integer
+  }
+  return hash
+}
+
+/**
+ * Evict oldest entries if cache exceeds max size
+ */
+function evictOldestEntries(): void {
+  if (sourceFileCache.size <= MAX_CACHE_SIZE) {
+    return
+  }
+
+  // Sort by last access time and remove oldest entries
+  const entries = Array.from(sourceFileCache.entries())
+    .sort((a, b) => a[1].lastAccess - b[1].lastAccess)
+
+  const toRemove = entries.slice(0, entries.length - MAX_CACHE_SIZE)
+  for (const [key] of toRemove) {
+    sourceFileCache.delete(key)
+  }
+}
+
+/**
+ * Get or create a cached SourceFile
+ */
+function getSourceFile(filePath: string, sourceCode: string): SourceFile {
+  const contentHash = hashContent(sourceCode)
+  const cached = sourceFileCache.get(filePath)
+  const now = Date.now()
+
+  if (cached && cached.contentHash === contentHash) {
+    // Update last access time
+    cached.lastAccess = now
+    return cached.sourceFile
+  }
 
-  // Create TypeScript source file
+  // Create new SourceFile and cache it
   const sourceFile = createSourceFile(
     filePath,
     sourceCode,
@@ -19,6 +68,38 @@ export function extractDeclarations(sourceCode: string, filePath: string, keepCo
     ScriptKind.TS,
   )
 
+  sourceFileCache.set(filePath, { sourceFile, contentHash, lastAccess: now })
+
+  // Evict old entries if needed
+  evictOldestEntries()
+
+  return sourceFile
+}
+
+/**
+ * Clear the SourceFile cache (useful for testing or memory management)
+ */
+export function clearSourceFileCache(): void {
+  sourceFileCache.clear()
+}
+
+/**
+ * Get the current cache size (useful for debugging)
+ */
+export function getSourceFileCacheSize(): number {
+  return sourceFileCache.size
+}
+
+/**
+ * Extract only public API declarations from TypeScript source code
+ * This focuses on what should be in .d.ts files, not implementation details
+ */
+export function extractDeclarations(sourceCode: string, filePath: string, keepComments: boolean = true): Declaration[] {
+  const declarations: Declaration[] = []
+
+  // Get or create cached TypeScript source file
+  const sourceFile = getSourceFile(filePath, sourceCode)
+
   // Visit only top-level declarations
   function visitTopLevel(node: Node) {
     // Only process top-level declarations, skip function bodies and implementation details

packages/dtsx/src/parser.ts

@@ -1,10 +1,40 @@
-/* eslint-disable regexp/no-super-linear-backtracking */
-
 /**
  * Remove leading comments from a declaration
  */
 export function removeLeadingComments(text: string): string {
-  return text.replace(/^(\s*\/\*[\s\S]*?\*\/\s*|\s*\/\/.*\n)*/g, '').trim()
+  let result = text
+  let changed = true
+
+  // Iteratively remove leading comments to avoid regex backtracking
+  while (changed) {
+    changed = false
+    const trimmed = result.trimStart()
+
+    // Remove block comments /* ... */
+    if (trimmed.startsWith('/*')) {
+      const endIndex = trimmed.indexOf('*/', 2)
+      if (endIndex !== -1) {
+        result = trimmed.slice(endIndex + 2)
+        changed = true
+        continue
+      }
+    }
+
+    // Remove single-line comments // ...
+    if (trimmed.startsWith('//')) {
+      const newlineIndex = trimmed.indexOf('\n')
+      if (newlineIndex !== -1) {
+        result = trimmed.slice(newlineIndex + 1)
+        changed = true
+      }
+      else {
+        result = ''
+        changed = true
+      }
+    }
+  }
+
+  return result.trim()
 }
 
 /**
@@ -184,9 +214,9 @@ export interface FunctionSignature {
 export function parseFunctionDeclaration(text: string): FunctionSignature | null {
   const clean = removeLeadingComments(text).trim()
 
-  // Match function pattern
+  // Match function pattern (use \s+ after 'function' to avoid backtracking with optional \s*)
   const functionMatch = clean.match(
-    /^(export\s+)?(async\s+)?function\s*(\*?)\s*([a-zA-Z_$][\w$]*)/,
+    /^(export\s+)?(async\s+)?function\s*(\*?)([a-zA-Z_$][\w$]*)/,
   )
 
   if (!functionMatch)