@stacksjs/dtsx 0.2.0

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+import type { DtsGenerationConfig } from './types'
+
+export declare const config: DtsGenerationConfig

package/dist/extract.d.ts

@@ -0,0 +1,59 @@
+export declare function extractTypeFromSource(filePath: string): Promise<string>
+
+exportStatement = exportLines[i]
+      i++
+      while (i < exportLines.length && !exportLines[i].trim().startsWith('export') && !exportLines[i].trim().startsWith('/**')) {
+
+exportStatement += `\n${exportLines[i]}`
+        i++
+      }
+    }
+
+    if (exportStatement) {
+      const formattedComment = comment ? formatComment(comment.trim()) : ''
+      let formattedExport = exportStatement.trim()
+
+      if (formattedExport.startsWith('export function') || formattedExport.startsWith('export async function')) {
+        formattedExport = formattedExport.replace(/^export\s+(async\s+)?function/, 'export declare function')
+        const functionSignature = formattedExport.match(/^.*?\)/)
+        if (functionSignature) {
+          let params = functionSignature[0].slice(functionSignature[0].indexOf('(') + 1, -1)
+          params = params.replace(/\s*=[^,)]+/g, '') // Remove default values
+          const returnType = formattedExport.match(/\):\s*([^{]+)/)
+          formattedExport = `export declare function ${formattedExport.split('function')[1].split('(')[0].trim()}(${params})${returnType ? `: ${returnType[1].trim()}` : ''};`
+        }
+      }
+      else if (formattedExport.startsWith('export const') || formattedExport.startsWith('export let') || formattedExport.startsWith('export var')) {
+        formattedExport = formattedExport.replace(/^export\s+(const|let|var)/, 'export declare $1')
+        formattedExport = `${formattedExport.split('=')[0].trim()};`
+      }
+
+      declarations += `${formattedComment}\n${formattedExport}\n\n`
+
+      // Add types used in the export to usedTypes
+      const typeRegex = /\b([A-Z]\w+)(?:<[^>]*>)?/g
+      const types = Array.from(formattedExport.matchAll(typeRegex))
+      types.forEach(([, type]) => usedTypes.add(type))
+    }
+
+    if (!exportStatement && !comment) {
+      i++
+    }
+  }
+
+  // Generate import statements for used types
+  let importDeclarations = ''
+  importMap.forEach((types, path) => {
+    const usedTypesFromPath = [...types].filter(type => usedTypes.has(type))
+    if (usedTypesFromPath.length > 0) {
+      importDeclarations += `import type { ${usedTypesFromPath.join(', ')} } from '${path}'\n`
+    }
+  })
+
+  if (importDeclarations) {
+    declarations = `${importDeclarations}\n${declarations}`
+  }
+
+  // Apply final formatting
+  return formatDeclarations(declarations)
+}

package/dist/generate.d.ts

@@ -0,0 +1,5 @@
+import type { DtsGenerationConfig, DtsGenerationOption } from './types'
+
+export declare function generateDeclarationsFromFiles(options?: DtsGenerationConfig): Promise<void>
+
+export declare function generate(options?: DtsGenerationOption): Promise<void>

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { config } from './config'
+export * from './extract'
+export * from './generate'
+export * from './types'
+export * from './utils'
+
+export { config } from './config'
+
+export * from './extract'
+
+export * from './generate'
+
+export * from './types'
+
+export * from './utils'