chore: wip

Author: chrisbbreuer

src/processor.ts

@@ -26,35 +26,36 @@ export function processDeclarations(
   const defaultExport: string[] = []
 
   for (const decl of exports) {
-    const lines = decl.text.split('\n').map(line => line.trim()).filter(line => line)
-
-    for (const line of lines) {
-      if (line.startsWith('export default')) {
-        defaultExport.push(line.endsWith(';') ? line : line + ';')
-      } else if (line.startsWith('export type {') || line.startsWith('export {')) {
-        // Extract exported items from the line
-        const match = line.match(/export\s+(?:type\s+)?\{\s*([^}]+)\s*\}/)
-        if (match) {
-          const items = match[1].split(',').map(item => item.trim())
-          for (const item of items) {
-            exportedItems.add(item)
-          }
-        }
-        const statement = line.endsWith(';') ? line : line + ';'
-        if (!exportStatements.includes(statement)) {
-          exportStatements.push(statement)
-        }
-      } else if (line.startsWith('export ')) {
-        const statement = line.endsWith(';') ? line : line + ';'
-        if (!exportStatements.includes(statement)) {
-          exportStatements.push(statement)
+    if (decl.text.startsWith('export default')) {
+      const statement = decl.text.endsWith(';') ? decl.text : decl.text + ';'
+      defaultExport.push(statement)
+    } else {
+      // Handle multi-line export statements properly
+      let exportText = decl.text.trim()
+
+      // Clean up the export text and ensure it ends with semicolon
+      if (!exportText.endsWith(';')) {
+        exportText += ';'
+      }
+
+      // Extract exported items for tracking
+      const match = exportText.match(/export\s+(?:type\s+)?\{\s*([^}]+)\s*\}/)
+      if (match) {
+        const items = match[1].split(',').map(item => item.trim())
+        for (const item of items) {
+          exportedItems.add(item)
         }
       }
+
+      if (!exportStatements.includes(exportText)) {
+        exportStatements.push(exportText)
+      }
     }
   }
 
   // Filter imports to only include those that are used in exports or declarations
   const usedImports = new Set<string>()
+  const usedImportItems = new Set<string>()
 
   // Check which imports are needed based on exported functions and types
   for (const func of functions) {
@@ -67,23 +68,59 @@ export function processDeclarations(
           const importedItems = importMatch[1].split(',').map(item => item.trim())
           for (const item of importedItems) {
             if (funcDeclaration.includes(item)) {
-              usedImports.add(imp.text)
+              usedImportItems.add(item)
             }
           }
         }
       }
     }
   }
 
-  // Check which imports are needed for interfaces and types (check all, not just exported)
+    // Check which imports are needed for exported variables
+  for (const variable of variables) {
+    if (variable.isExported) {
+      for (const imp of imports) {
+        // Handle mixed imports like: import { collect, type Collection } from 'module'
+        const importText = imp.text
+        const typeMatches = importText.match(/type\s+([A-Za-z_$][A-Za-z0-9_$]*)/g)
+        const valueMatches = importText.match(/import\s+\{([^}]+)\}/)
+
+        // Check type imports
+        if (typeMatches) {
+          for (const typeMatch of typeMatches) {
+            const typeName = typeMatch.replace('type ', '').trim()
+            if (variable.text.includes(typeName)) {
+              usedImportItems.add(typeName)
+            }
+          }
+        }
+
+        // Check value imports
+        if (valueMatches) {
+          const imports = valueMatches[1].split(',').map(item =>
+            item.replace(/type\s+/, '').trim()
+          )
+          for (const importName of imports) {
+            if (variable.text.includes(importName)) {
+              usedImportItems.add(importName)
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Check which imports are needed for interfaces and types (only exported ones)
   for (const iface of interfaces) {
-    for (const imp of imports) {
-      const importMatch = imp.text.match(/import\s+(?:type\s+)?\{?\s*([^}]+)\s*\}?\s+from/)
-      if (importMatch) {
-        const importedItems = importMatch[1].split(',').map(item => item.trim())
-        for (const item of importedItems) {
-          if (iface.text.includes(item)) {
-            usedImports.add(imp.text)
+    if (iface.isExported) {
+      for (const imp of imports) {
+        const importMatch = imp.text.match(/import\s+(?:type\s+)?\{?\s*([^}]+)\s*\}?\s+from/)
+        if (importMatch) {
+          const importedItems = importMatch[1].split(',').map(item => item.trim())
+          for (const item of importedItems) {
+            if (iface.text.includes(item)) {
+              usedImportItems.add(item)
+            }
           }
         }
       }
@@ -98,7 +135,7 @@ export function processDeclarations(
           const importedItems = importMatch[1].split(',').map(item => item.trim())
           for (const item of importedItems) {
             if (type.text.includes(item)) {
-              usedImports.add(imp.text)
+              usedImportItems.add(item)
             }
           }
         }
@@ -110,30 +147,58 @@ export function processDeclarations(
   for (const item of exportedItems) {
     for (const imp of imports) {
       if (imp.text.includes(item)) {
-        usedImports.add(imp.text)
+        // Extract the specific items from this import
+        const importMatch = imp.text.match(/import\s+(?:type\s+)?\{?\s*([^}]+)\s*\}?\s+from/)
+        if (importMatch) {
+          const importedItems = importMatch[1].split(',').map(item => item.trim())
+          for (const importedItem of importedItems) {
+            if (item === importedItem) {
+              usedImportItems.add(importedItem)
+            }
+          }
+        }
       }
     }
   }
 
   // Also check for value imports that are re-exported
   for (const exp of exports) {
-    if (exp.text.includes('export { generate }')) {
-      // Find the import for generate
-      for (const imp of imports) {
-        if (imp.text.includes('{ generate }')) {
-          usedImports.add(imp.text)
+    for (const imp of imports) {
+      const importMatch = imp.text.match(/import\s+(?:type\s+)?\{?\s*([^}]+)\s*\}?\s+from/)
+      if (importMatch) {
+        const importedItems = importMatch[1].split(',').map(item => item.trim())
+        for (const importedItem of importedItems) {
+          if (exp.text.includes(importedItem)) {
+            usedImportItems.add(importedItem)
+          }
         }
       }
     }
   }
 
-  // Process and add used imports first
+  // Create filtered imports based on actually used items
   const processedImports: string[] = []
   for (const imp of imports) {
-    if (usedImports.has(imp.text)) {
-      const processed = processImportDeclaration(imp)
-      if (processed && processed.trim()) {
-        processedImports.push(processed)
+    const importMatch = imp.text.match(/import\s+(?:type\s+)?\{?\s*([^}]+)\s*\}?\s+from\s+['"]([^'"]+)['"]/)
+    if (importMatch) {
+      const importedItems = importMatch[1].split(',').map(item => item.trim())
+      const usedItems = importedItems.filter(item => {
+        const cleanItem = item.replace(/^type\s+/, '').trim()
+        return usedImportItems.has(cleanItem)
+      })
+
+      if (usedItems.length > 0) {
+        const source = importMatch[2]
+        const hasTypeImports = usedItems.some(item => item.startsWith('type '))
+        const hasValueImports = usedItems.some(item => !item.startsWith('type '))
+
+        let importStatement = 'import '
+        if (hasTypeImports && !hasValueImports) {
+          importStatement += 'type '
+        }
+        importStatement += `{ ${usedItems.join(', ')} } from '${source}';`
+
+        processedImports.push(importStatement)
       }
     }
   }
@@ -983,4 +1048,4 @@ function inferFunctionType(value: string, inUnion: boolean = false): string {
 
   const funcType = '() => unknown'
   return inUnion ? `(${funcType})` : funcType
-}
+}

test/fixtures/input/example/0010.ts

@@ -12,7 +12,7 @@ export interface FormatPhoneOptions {
 
 export const DefaultPhoneRegion = 'US'
 
-const PHONE_PATTERNS: Record<string, number[]> = {
+export const PHONE_PATTERNS: Record<string, number[]> = {
   US: [3, 3, 4],
   GB: [4, 3, 3],
   FR: [2, 2, 2, 2, 2],
@@ -25,7 +25,7 @@ const PHONE_PATTERNS: Record<string, number[]> = {
   CA: [3, 3, 4],
 } as const
 
-const COUNTRY_CODES: Record<string, string> = {
+export const COUNTRY_CODES: Record<string, string> = {
   US: '+1',
   GB: '+44',
   FR: '+33',

test/fixtures/output/example/0004.d.ts

@@ -8,52 +8,46 @@ export declare interface DtsGenerationConfig {
   tsconfigPath: string
   verbose: boolean
 }
-export declare type DtsGenerationOption = Partial<DtsGenerationConfig>
-
-export type DtsGenerationOptions = DtsGenerationOption | DtsGenerationOption[]
-
-export interface RegexPatterns {
-  readonly typeImport: RegExp
-  readonly regularImport: RegExp
-  readonly bracketOpen: RegExp
-  readonly bracketClose: RegExp
-  readonly functionReturn: RegExp
-  readonly typeAnnotation: RegExp
-  readonly asyncFunction: RegExp
-  readonly genericParams: RegExp
-  readonly functionParams: RegExp
-  readonly functionReturnType: RegExp
-  readonly destructuredParams: RegExp
-  readonly typePattern: RegExp
-  readonly valueReference: RegExp
-  readonly typeReference: RegExp
-  readonly functionName: RegExp
-  readonly exportCleanup: RegExp
-  readonly defaultExport: RegExp
-  readonly complexType: RegExp
-  readonly unionIntersection: RegExp
-  readonly mappedType: RegExp
-  readonly conditionalType: RegExp
-  readonly genericConstraints: RegExp
-  readonly functionOverload: RegExp
-  readonly moduleDeclaration: RegExp
-  readonly moduleAugmentation: RegExp
+export declare interface RegexPatterns {
+  typeImport: RegExp
+  regularImport: RegExp
+  bracketOpen: RegExp
+  bracketClose: RegExp
+  functionReturn: RegExp
+  typeAnnotation: RegExp
+  asyncFunction: RegExp
+  genericParams: RegExp
+  functionParams: RegExp
+  functionReturnType: RegExp
+  destructuredParams: RegExp
+  typePattern: RegExp
+  valueReference: RegExp
+  typeReference: RegExp
+  functionName: RegExp
+  exportCleanup: RegExp
+  defaultExport: RegExp
+  complexType: RegExp
+  unionIntersection: RegExp
+  mappedType: RegExp
+  conditionalType: RegExp
+  genericConstraints: RegExp
+  functionOverload: RegExp
+  moduleDeclaration: RegExp
+  moduleAugmentation: RegExp
 }
-
-export interface ImportTrackingState {
-  typeImports: Map<string, Set<string>> 
-  valueImports: Map<string, Set<string>> 
-  usedTypes: Set<string> 
-  usedValues: Set<string> 
-  exportedTypes: Set<string> 
-  exportedValues: Set<string> 
-  valueAliases: Map<string, string> 
-  importSources: Map<string, string> 
-  typeExportSources: Map<string, string> 
-  defaultExportValue?: string 
+export declare interface ImportTrackingState {
+  typeImports: Map<string, Set<string>>
+  valueImports: Map<string, Set<string>>
+  usedTypes: Set<string>
+  usedValues: Set<string>
+  exportedTypes: Set<string>
+  exportedValues: Set<string>
+  valueAliases: Map<string, string>
+  importSources: Map<string, string>
+  typeExportSources: Map<string, string>
+  defaultExportValue?: string
 }
-
-export interface ProcessingState {
+export declare interface ProcessingState {
   dtsLines: string[]
   imports: string[]
   usedTypes: Set<string>
@@ -78,38 +72,35 @@ export interface ProcessingState {
   defaultExports: Set<string>
   currentScope: 'top' | 'function'
 }
-
-export interface MethodSignature {
+export declare interface MethodSignature {
   name: string
   async: boolean
   generics: string
   params: string
   returnType: string
 }
-
-export interface PropertyInfo {
+export declare interface PropertyInfo {
   key: string
   value: string
   type: string
   nested?: PropertyInfo[]
   method?: MethodSignature
 }
-
-export interface ImportInfo {
+export declare interface ImportInfo {
   kind: 'type' | 'value' | 'mixed'
   usedTypes: Set<string>
   usedValues: Set<string>
   source: string
 }
-
-export interface FunctionSignature {
+export declare interface FunctionSignature {
   name: string
   params: string
   returnType: string
   generics: string
 }
-
-export interface ProcessedMethod {
+export declare interface ProcessedMethod {
   name: string
   signature: string
-}
+}
+export type DtsGenerationOption = Partial<DtsGenerationConfig>
+export type DtsGenerationOptions = DtsGenerationOption | DtsGenerationOption[]