@davidwells/extract-deps 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davidwells/extract-deps",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Get imports and requires from a codebase without AST",
   "main": "src/index.js",
   "types": "types/index.d.ts",

package/src/get-cjs-exports.js

@@ -1,6 +1,6 @@
 // Extracts CommonJS module.exports and exports patterns from JavaScript code
 
-const { getNames } = require('./utils')
+const { getNames, extractExportName } = require('./utils')
 
 // Matches: module.exports = ... or exports = module.exports = ...
 // https://regex101.com/r/example/cjs-1
@@ -54,33 +54,6 @@ function getCjsExports(code) {
   return allExports.sort((a, b) => a.index - b.index)
 }
 
-function extractExportDefName(exportValue) {
-  // Handle function declarations
-  if (exportValue.includes('function') && !exportValue.includes('=>')) {
-    const match = exportValue.match(/function\s+([\w$]+)/)
-    return match ? match[1] : 'anonymous'
-  }
-
-  // Handle class declarations
-  if (exportValue.includes('class')) {
-    const match = exportValue.match(/class\s+([\w$]+)/)
-    return match ? match[1] : 'anonymous'
-  }
-
-  // Handle arrow functions
-  if (exportValue.includes('=>')) {
-    return 'anonymous'
-  }
-
-  // Handle object/array literals
-  if (exportValue.startsWith('{') || exportValue.startsWith('[')) {
-    return 'literal'
-  }
-
-  // Handle simple values
-  return exportValue.trim()
-}
-
 function extractCompleteValue(text, startIndex) {
   const firstChar = text[startIndex]
 
@@ -176,7 +149,7 @@ function getModuleExportsAssignment(originalText = '', sanitizedText = originalT
       }
     }
 
-    const exportDefName = extractExportDefName(sanitizedCompleteValue)
+    const exportDefName = extractExportName(sanitizedCompleteValue)
 
     // Determine export type based on sanitized patterns
     let exportType = 'default'
@@ -203,7 +176,7 @@ function getModuleExportsAssignment(originalText = '', sanitizedText = originalT
       const definitions = getNames(sanitizedCompleteValue, 'definition')
       if (definitions) {
         exportStatement.definitions = definitions
-        exportStatement.keys = definitions.destructuredParameters.map(param => param.name)
+        exportStatement.keys = definitions.destructuredParameters.map(param => param.name.replace(/,+$/, ''))
       }
     }
 

package/src/get-exports.js

@@ -1,7 +1,7 @@
-const { getNames } = require('./utils')
+const { getNames, extractExportName } = require('./utils')
 
 // https://regex101.com/r/example/1
-const EXPORT_DEFAULT_REGEX = /export\s+default\s+(?:function\s+([\w$]+)|class\s+([\w$]+)|([\w$]+|\([^)]*\)\s*=>|{[\s\S]*?}|\[[\s\S]*?\]|[\w$]+(?:\s*[+\-*/%]\s*[\w$]+)*))/gm
+const EXPORT_DEFAULT_REGEX = /export\s+default\s+(?:(?:async\s+)?function\s+([\w$]+)|class\s+([\w$]+)|([\w$]+|\([^)]*\)\s*=>|{[\s\S]*?}|\[[\s\S]*?\]|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*`|[\w$]+(?:\s*[+\-*/%]\s*[\w$]+)*))/gm
 // https://regex101.com/r/example/2
 const EXPORT_NAMED_REGEX = /export\s+(?:const|let|var|function|class|async\s+function)\s+([\w$]+)/gm
 // https://regex101.com/r/example/3
@@ -53,27 +53,52 @@ function getDefaultExports(targetText = '') {
   var result
   while((result = EXPORT_DEFAULT_REGEX.exec(targetText)) !== null) {
     const [ line, functionName, className, otherValue ] = result
-    let exportName, exportValue
-    
+    let exportName, exportValue, exportDefinitionName, completeLine
+
     if (functionName) {
-      exportName = functionName
-      exportValue = `function ${functionName}`
+      exportName = ''
+      exportDefinitionName = functionName
+      // Extract complete line from original text (including parameters)
+      const lineStart = result.index
+      const lineEnd = targetText.indexOf('\n', lineStart)
+      completeLine = targetText.substring(lineStart, lineEnd === -1 ? targetText.length : lineEnd).trim()
+      exportValue = completeLine.replace(/^export\s+default\s+/, '')
     } else if (className) {
-      exportName = className
-      exportValue = `class ${className}`
+      exportName = ''
+      exportDefinitionName = className
+      // Extract complete line from original text
+      const lineStart = result.index
+      const lineEnd = targetText.indexOf('\n', lineStart)
+      completeLine = targetText.substring(lineStart, lineEnd === -1 ? targetText.length : lineEnd).trim()
+      exportValue = completeLine.replace(/^export\s+default\s+/, '')
     } else {
-      exportName = extractExportName(otherValue)
+      exportDefinitionName = extractExportName(otherValue)
+      exportName = ''
       exportValue = otherValue
+      completeLine = line
     }
-    
-    exportStatements.push({
-      line: line.trim(),
+
+    const exportStatement = {
+      line: completeLine.trim(),
       exportType: 'default',
       exportName,
+      exportDefinitionName,
       exportValue: exportValue.trim(),
       index: result.index,
       isExport: true
-    })
+    }
+
+    // Parse object literals to extract definitions and keys
+    const trimmedValue = exportValue.trim()
+    if (trimmedValue.startsWith('{') && trimmedValue.endsWith('}')) {
+      const definitions = getNames(trimmedValue, 'definition')
+      if (definitions) {
+        exportStatement.definitions = definitions
+        exportStatement.keys = definitions.destructuredParameters.map(param => param.name.replace(/,+$/, ''))
+      }
+    }
+
+    exportStatements.push(exportStatement)
   }
   return exportStatements
 }
@@ -200,33 +225,6 @@ function getAssertionExports(targetText = '') {
   return exportStatements
 }
 
-function extractExportName(exportValue) {
-  // Handle function declarations
-  if (exportValue.includes('function') && !exportValue.includes('=>')) {
-    const match = exportValue.match(/function\s+([\w$]+)/)
-    return match ? match[1] : 'anonymous'
-  }
-  
-  // Handle class declarations
-  if (exportValue.includes('class')) {
-    const match = exportValue.match(/class\s+([\w$]+)/)
-    return match ? match[1] : 'anonymous'
-  }
-  
-  // Handle arrow functions
-  if (exportValue.includes('=>')) {
-    return 'anonymous'
-  }
-  
-  // Handle object/array literals
-  if (exportValue.startsWith('{') || exportValue.startsWith('[')) {
-    return 'literal'
-  }
-  
-  // Handle simple values
-  return exportValue.trim()
-}
-
 function parseExportsList(exportsList) {
   const exports = []
   const items = exportsList.split(',').map(item => item.trim())

package/src/index.js

@@ -1,6 +1,7 @@
 const { getImports, getStaticImports, getDynamicImports } = require('./get-imports')
 const { getRequires, getStaticRequires, getDynamicRequires } = require('./get-requires')
 const { getCjsExports } = require('./get-cjs-exports')
+const { detectSyntax, hasESMSyntax, hasCJSSyntax } = require('./detect-syntax')
 const { 
   getExports, 
   getDefaultExports, 
@@ -80,6 +81,10 @@ const { execSync, spawnSync } = require('child_process')
 
 module.exports = {
   extractDeps,
+  /* syntax detection */
+  hasESMSyntax,
+  hasCJSSyntax,
+  detectSyntax,
   /* Requires */
   getRequires,
   getDynamicRequires,

package/src/utils.js

@@ -155,8 +155,48 @@ function getNames(names, aliasKey = 'alias') {
 }
 
 
+function extractExportName(exportValue) {
+  // Handle function declarations
+  if (exportValue.includes('function') && !exportValue.includes('=>')) {
+    const match = exportValue.match(/function\s+([\w$]+)/)
+    return match ? match[1] : 'anonymous'
+  }
+
+  // Handle class declarations
+  if (exportValue.includes('class')) {
+    const match = exportValue.match(/class\s+([\w$]+)/)
+    return match ? match[1] : 'anonymous'
+  }
+
+  // Handle arrow functions
+  if (exportValue.includes('=>')) {
+    return 'anonymous'
+  }
+
+  // Handle object/array literals
+  if (exportValue.startsWith('{')) {
+    return 'literal-object'
+  }
+
+  if (exportValue.startsWith('[')) {
+    return 'literal-array'
+  }
+
+  if (exportValue.match(/^\d+$/)) {
+    return 'literal-number'
+  }
+
+  if (exportValue.match(/^['"]/)) {
+    return 'literal-string'
+  }
+
+  // Handle simple values
+  return exportValue.trim()
+}
+
 module.exports = {
   isRelativeImport,
   isRelativeImportWithQuotes,
-  getNames
+  getNames,
+  extractExportName
 }

package/tests/get-cjs-exports.test.js

@@ -36,7 +36,7 @@ module.exports = () => {}
   assert.equal(classExport.exportValue, 'class MyClass {}')
 
   // Check object literal
-  const objectExport = foundExports.find(exp => exp.exportDefinitionName === 'literal')
+  const objectExport = foundExports.find(exp => exp.exportDefinitionName === 'literal-object')
   assert.ok(objectExport, 'Should find object literal export')
   assert.equal(objectExport.exportValue, "{ foo: 'bar' }")
 
@@ -536,4 +536,56 @@ module.exports = {
   assert.ok(foundExports[0].keys.includes('environment'), 'Keys should include environment')
 })
 
+
+test('lambda function default object', () => {
+  const code = `
+const handler = async event => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify(
+      {
+        message: 'yo function',
+        input: event,
+      },
+      null,
+      2
+    ),
+  };
+};
+
+module.exports = {
+  handler,
+}
+  `
+
+  const foundExports = getCjsExports(code)
+  console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.ok(foundExports[0].keys, 'Should have keys array')
+  assert.equal(foundExports[0].keys.length, 1, 'Should have 1 key')
+  assert.equal(foundExports[0].keys[0], 'handler', 'Key should be "handler" without trailing comma')
+})
+
+test('lambda function default function inline', () => {
+  const code = `
+module.exports = async function handler(event) {
+  return {
+    statusCode: 200,
+    body: JSON.stringify({
+      message: 'yo function',
+      input: event,
+    }, null, 2),
+  }
+}
+  `
+
+  const foundExports = getCjsExports(code)
+  console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.equal(foundExports[0].exportType, 'default', 'exportType should be default')
+  assert.equal(foundExports[0].exportName, '', 'exportName should empty because it default function')
+})
+
 test.run()

package/tests/get-exports.test.js

@@ -23,40 +23,51 @@ export default () => {}
   `
   
   const foundExports = getDefaultExports(code)
+  console.log('foundExports', foundExports)
 
-  assert.ok(foundExports.length === 6, 'Should find 6 default exports')
+  assert.ok(foundExports.length === 7, 'Should find 7 default exports')
 
   // Check function export
-  const functionExport = foundExports.find(exp => exp.exportName === 'myFunction')
+  const functionExport = foundExports.find(exp => exp.exportDefinitionName === 'myFunction')
   assert.ok(functionExport, 'Should find function export')
   assert.equal(functionExport.exportType, 'default')
-  assert.equal(functionExport.exportValue, 'function myFunction')
+  assert.equal(functionExport.exportValue, 'function myFunction() {}')
 
   // Check class export
-  const classExport = foundExports.find(exp => exp.exportName === 'MyClass')
+  const classExport = foundExports.find(exp => exp.exportDefinitionName === 'MyClass')
   assert.ok(classExport, 'Should find class export')
   assert.equal(classExport.exportType, 'default')
-  assert.equal(classExport.exportValue, 'class MyClass')
+  assert.equal(classExport.exportValue, 'class MyClass {}')
 
   // Check object literal
-  const objectExport = foundExports.find(exp => exp.exportName === 'literal')
+  const objectExport = foundExports.find(exp => exp.exportDefinitionName === 'literal-object')
   assert.ok(objectExport, 'Should find object literal export')
   assert.equal(objectExport.exportValue, "{ foo: 'bar' }")
+  assert.equal(objectExport.exportName, '')
+
+  // Check string literal
+  const stringExport = foundExports.find(exp => exp.exportDefinitionName === 'literal-string')
+  assert.ok(stringExport, 'Should find string literal export')
+  assert.equal(stringExport.exportValue, "'hello'", 'exportValue should be "hello"')
+  assert.equal(stringExport.exportName, '', 'exportName should be empty')
 
   // Check array literal
   const arrayExport = foundExports.find(exp => exp.exportValue === '[1, 2, 3]')
   assert.ok(arrayExport, 'Should find array literal export')
-  assert.equal(arrayExport.exportName, 'literal')
+  assert.equal(arrayExport.exportDefinitionName, 'literal-array')
+  assert.equal(arrayExport.exportName, '')
 
   // Check number literal
   const numberExport = foundExports.find(exp => exp.exportValue === '42')
   assert.ok(numberExport, 'Should find number literal export')
-  assert.equal(numberExport.exportName, '42')
+  assert.equal(numberExport.exportDefinitionName, 'literal-number')
+  assert.equal(numberExport.exportName, '')
 
   // Check arrow function
   const arrowExport = foundExports.find(exp => exp.exportValue === '() =>')
   assert.ok(arrowExport, 'Should find arrow function export')
-  assert.equal(arrowExport.exportName, 'anonymous')
+  assert.equal(arrowExport.exportDefinitionName, 'anonymous')
+  assert.equal(arrowExport.exportName, '')
 })
 
 test('should extract named exports', () => {
@@ -318,7 +329,7 @@ export {
   assert.ok(foundExports.length > 0, 'Should find exports in complex code')
 
   // Should handle anonymous functions and classes
-  const anonymousExports = foundExports.filter(exp => exp.exportName === 'anonymous')
+  const anonymousExports = foundExports.filter(exp => exp.exportDefinitionName === 'anonymous')
   assert.ok(anonymousExports.length >= 2, 'Should find anonymous function and class exports')
 
   // Should handle complex named declaration exports
@@ -380,4 +391,145 @@ export { MyComponent, Button, Input }
   assert.ok(thirdExport.exportType === 'named', 'Should find named export')
 })
 
+
+test('lambda function default function', () => {
+  const code = `
+const handler = async event => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify(
+      {
+        message: 'yo function',
+        input: event,
+      },
+      null,
+      2
+    ),
+  };
+};
+export default handler
+  `
+
+  const foundExports = getExports(code)
+  console.log('foundExports', foundExports)
+
+  // TODO add assertions
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.ok(foundExports[0].exportType, 'Should have exportType array')
+  assert.equal(foundExports[0].exportType, 'default', 'exportType should be default')
+  assert.equal(foundExports[0].exportName, '', 'exportName should empty because it default function')
+})
+
+
+test('lambda function default function inline', () => {
+  const code = `
+export default async function handler(event) {
+  return {
+    statusCode: 200,
+    body: JSON.stringify({
+      message: 'yo function',
+      input: event,
+    }, null, 2),
+  }
+}
+  `
+
+  const foundExports = getExports(code)
+  console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.ok(foundExports[0].exportType, 'Should have keys array')
+  assert.equal(foundExports[0].exportType, 'default', 'exportType should be default')
+  assert.equal(foundExports[0].exportName, '', 'exportName should empty because it default function')
+})
+
+test('lambda function default object', () => {
+  const code = `
+const handler = async event => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify(
+      {
+        message: 'yo function',
+        input: event,
+      },
+      null,
+      2
+    ),
+  };
+};
+export default {
+  handler,
+}
+  `
+
+  const foundExports = getExports(code)
+  console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.ok(foundExports[0].keys, 'Should have keys array')
+  assert.equal(foundExports[0].keys.length, 1, 'Should have 1 key')
+  assert.equal(foundExports[0].keys[0], 'handler', 'Key should be "handler" without trailing comma')
+})
+
+
+test('lambda function named object', () => {
+  const code = `
+const handler = async event => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify(
+      {
+        message: 'yo function',
+        input: event,
+      },
+      null,
+      2
+    ),
+  };
+};
+export {
+  handler,
+}
+  `
+
+  const foundExports = getExports(code)
+  console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.ok(foundExports[0].exportType, 'Should have keys array')
+  assert.equal(foundExports[0].exportType, 'named', 'exportType should be named')
+  assert.equal(foundExports[0].exportName, 'handler', 'exportName should be "handler" without trailing comma')
+})
+
+test('lambda function named object with alias', () => {
+  const code = `
+const handler = async event => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify(
+      {
+        message: 'yo function',
+        input: event,
+      },
+      null,
+      2
+    ),
+  };
+};
+export {
+  handler as myHandler
+}
+  `
+
+  const foundExports = getExports(code)
+  console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.ok(foundExports[0].exportType, 'Should have keys array')
+  assert.equal(foundExports[0].exportType, 'named', 'exportType should be named')
+  assert.equal(foundExports[0].exportName, 'handler', 'exportName should be "handler" without trailing comma')
+  assert.equal(foundExports[0].exportAlias, 'myHandler', 'exportAlias should be "myHandler" without trailing comma')
+})
+
 test.run()