@davidwells/extract-deps 0.0.3 → 0.0.5

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/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/dep-graph.test.js

@@ -0,0 +1,213 @@
+// Build and verify dependency graph
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const path = require('path')
+const { depGraph, resolveDepPaths } = require('../src/dep-graph.js')
+
+const CJS_FIXTURE_PATH = path.resolve(__dirname, './fixtures/cjs-example/index.js')
+const ESM_FIXTURE_PATH = path.resolve(__dirname, './fixtures/esm-fixture/index.js')
+const CJS_DEEP_FIXTURE_PATH = path.resolve(__dirname, './fixtures/cjs-deep-example/index.js')
+
+test('should build graph by default', () => {
+  const graph = depGraph(CJS_FIXTURE_PATH)
+  assert.ok(graph instanceof Map, 'Should return a Map by default')
+  assert.ok(graph.size > 0, 'Graph should not be empty')
+})
+
+test('should verify by default', () => {
+  assert.not.throws(() => {
+    depGraph(CJS_FIXTURE_PATH)
+  }, 'Should verify imports by default')
+})
+
+test('should build graph for valid CJS fixture', () => {
+  const graph = depGraph(CJS_FIXTURE_PATH)
+
+  assert.ok(graph instanceof Map, 'Should return a Map')
+  assert.ok(graph.size > 0, 'Graph should not be empty')
+
+  const entries = Array.from(graph.keys())
+  const hasIndexFile = entries.some(key => key.includes('cjs-example/index.js'))
+  assert.ok(hasIndexFile, 'Graph should include the index.js file')
+})
+
+test('should build graph for valid ESM fixture', () => {
+  const graph = depGraph(ESM_FIXTURE_PATH)
+
+  assert.ok(graph instanceof Map, 'Should return a Map')
+  assert.ok(graph.size > 0, 'Graph should not be empty')
+
+  const entries = Array.from(graph.keys())
+  const hasIndexFile = entries.some(key => key.includes('esm-fixture/index.js'))
+  assert.ok(hasIndexFile, 'Graph should include the index.js file')
+})
+
+test('should return undefined when buildGraph is false', () => {
+  const result = depGraph(CJS_FIXTURE_PATH, { buildGraph: false })
+  assert.is(result, undefined, 'Should return undefined when buildGraph is false')
+})
+
+test('should build correct dependency graph for CJS fixture', () => {
+  const graph = depGraph(CJS_FIXTURE_PATH)
+
+  const indexPath = Array.from(graph.keys()).find(key => key.includes('cjs-example/index.js'))
+  assert.ok(indexPath, 'Should have index.js in graph')
+
+  const indexDeps = graph.get(indexPath)
+  assert.ok(Array.isArray(indexDeps), 'Dependencies should be an array')
+  assert.is(indexDeps.length, 1, 'index.js should have 1 dependency')
+
+  const hasOneDep = indexDeps.some(dep => dep.includes('one.js'))
+  assert.ok(hasOneDep, 'index.js should depend on one.js')
+})
+
+test('should build correct dependency graph for ESM fixture', () => {
+  const graph = depGraph(ESM_FIXTURE_PATH)
+
+  const indexPath = Array.from(graph.keys()).find(key => key.includes('esm-fixture/index.js'))
+  assert.ok(indexPath, 'Should have index.js in graph')
+
+  const indexDeps = graph.get(indexPath)
+  assert.ok(Array.isArray(indexDeps), 'Dependencies should be an array')
+  assert.is(indexDeps.length, 1, 'index.js should have 1 dependency')
+
+  const hasOneDep = indexDeps.some(dep => dep.includes('one.js'))
+  assert.ok(hasOneDep, 'index.js should depend on one.js')
+})
+
+test('should include all files in graph', () => {
+  const graph = depGraph(CJS_FIXTURE_PATH)
+
+  const filePaths = Array.from(graph.keys())
+
+  // Should have index, one, two, three
+  assert.ok(filePaths.some(p => p.includes('index.js')), 'Should include index.js')
+  assert.ok(filePaths.some(p => p.includes('one.js')), 'Should include one.js')
+  assert.ok(filePaths.some(p => p.includes('two.js')), 'Should include two.js')
+  assert.ok(filePaths.some(p => p.includes('three.js')), 'Should include three.js')
+})
+
+test('should handle files with no dependencies', () => {
+  const graph = depGraph(CJS_FIXTURE_PATH)
+
+  const threePath = Array.from(graph.keys()).find(key => key.includes('three.js'))
+  assert.ok(threePath, 'Should have three.js in graph')
+
+  const threeDeps = graph.get(threePath)
+  assert.ok(Array.isArray(threeDeps), 'Dependencies should be an array')
+  assert.is(threeDeps.length, 0, 'three.js should have no dependencies')
+})
+
+test('should skip verification when verifyGraph is false', () => {
+  const graph = depGraph(CJS_FIXTURE_PATH, { verifyGraph: false })
+
+  assert.ok(graph instanceof Map, 'Should return a Map')
+  assert.ok(graph.size > 0, 'Graph should not be empty')
+})
+
+test('should work with all options combined', () => {
+  const graph = depGraph(CJS_FIXTURE_PATH, {
+    buildGraph: true,
+    verifyGraph: false,
+    throwOnFirstError: false
+  })
+
+  assert.ok(graph instanceof Map, 'Should return a Map')
+  assert.ok(graph.size > 0, 'Graph should not be empty')
+})
+
+// resolveDepPaths tests
+test('resolveDepPaths should return an array', () => {
+  const deps = resolveDepPaths(CJS_FIXTURE_PATH)
+  assert.ok(Array.isArray(deps), 'Should return an array')
+})
+
+test('resolveDepPaths should return deduplicated paths', () => {
+  const deps = resolveDepPaths(CJS_DEEP_FIXTURE_PATH)
+  const uniqueDeps = [...new Set(deps)]
+
+  assert.is(deps.length, uniqueDeps.length, 'Should not have duplicate paths')
+})
+
+test('resolveDepPaths should include all files from graph', () => {
+  const graph = depGraph(CJS_FIXTURE_PATH)
+  const deps = resolveDepPaths(CJS_FIXTURE_PATH)
+
+  assert.is(deps.length, graph.size, 'Should have same number of files as graph')
+
+  // All graph keys should be in deps
+  for (const key of graph.keys()) {
+    assert.ok(deps.includes(key), `Should include ${path.basename(key)}`)
+  }
+})
+
+test('resolveDepPaths should return paths in topological order (dependencies first)', () => {
+  const deps = resolveDepPaths(CJS_FIXTURE_PATH)
+
+  // Find indices
+  const threeIdx = deps.findIndex(p => p.includes('three.js'))
+  const twoIdx = deps.findIndex(p => p.includes('two.js'))
+  const oneIdx = deps.findIndex(p => p.includes('one.js'))
+  const indexIdx = deps.findIndex(p => p.includes('index.js'))
+
+  // three.js has no dependencies, should come first
+  assert.ok(threeIdx < twoIdx, 'three.js should come before two.js')
+  assert.ok(twoIdx < oneIdx, 'two.js should come before one.js')
+  assert.ok(oneIdx < indexIdx, 'one.js should come before index.js')
+})
+
+test('resolveDepPaths should work with ESM fixtures', () => {
+  const deps = resolveDepPaths(ESM_FIXTURE_PATH)
+
+  assert.ok(Array.isArray(deps), 'Should return an array')
+  assert.ok(deps.length > 0, 'Should have dependencies')
+
+  // Check files are included
+  assert.ok(deps.some(p => p.includes('index.js')), 'Should include index.js')
+  assert.ok(deps.some(p => p.includes('one.js')), 'Should include one.js')
+  assert.ok(deps.some(p => p.includes('two.js')), 'Should include two.js')
+  assert.ok(deps.some(p => p.includes('three.js')), 'Should include three.js')
+})
+
+test('resolveDepPaths should have entry point last', () => {
+  const deps = resolveDepPaths(CJS_FIXTURE_PATH)
+  const lastFile = deps[deps.length - 1]
+
+  assert.ok(lastFile.includes('index.js'), 'Entry point (index.js) should be last')
+})
+
+test('resolveDepPaths should have leaf nodes first', () => {
+  const deps = resolveDepPaths(CJS_FIXTURE_PATH)
+  const firstFile = deps[0]
+
+  // three.js has no dependencies - it's a leaf node
+  assert.ok(firstFile.includes('three.js'), 'Leaf node (three.js) should be first')
+})
+
+test('resolveDepPaths should handle complex graphs with shared dependencies', () => {
+  const deps = resolveDepPaths(CJS_DEEP_FIXTURE_PATH)
+
+  // Should be deduplicated
+  const uniqueDeps = [...new Set(deps)]
+  assert.is(deps.length, uniqueDeps.length, 'Should deduplicate shared dependencies')
+
+  // Find d-three.js which is shared by d-two.js, d-two-a.js, d-two-b.js
+  const threeIdx = deps.findIndex(p => p.includes('d-three.js'))
+  const twoIdx = deps.findIndex(p => p.includes('d-two.js'))
+  const twoAIdx = deps.findIndex(p => p.includes('d-two-a.js'))
+  const twoBIdx = deps.findIndex(p => p.includes('d-two-b.js'))
+
+  // d-three.js should come before all files that depend on it
+  assert.ok(threeIdx < twoIdx, 'd-three.js should come before d-two.js')
+  assert.ok(threeIdx < twoAIdx, 'd-three.js should come before d-two-a.js')
+  assert.ok(threeIdx < twoBIdx, 'd-three.js should come before d-two-b.js')
+})
+
+test('resolveDepPaths should pass options to depGraph', () => {
+  const deps = resolveDepPaths(CJS_FIXTURE_PATH, { verifyGraph: false })
+
+  assert.ok(Array.isArray(deps), 'Should work with options')
+  assert.ok(deps.length > 0, 'Should return dependencies')
+})
+
+test.run()

package/tests/fixtures/cjs-deep-example/d-one.js

@@ -0,0 +1,10 @@
+const { two, three } = require('./d-sub-folder/d-two')
+const { twoA } = require('./d-sub-folder/d-two-a')
+const { twoB } = require('./d-sub-folder/d-two-b')
+const one = 'one'
+
+module.exports = {
+  one,
+  two,
+  three
+}

package/tests/fixtures/cjs-deep-example/d-sub-folder/d-sub-sub-folder/d-three.js

@@ -0,0 +1,7 @@
+const { parent } = require('../../../cjs-parent')
+
+const three = 'three'
+
+module.exports = {
+  three
+}

package/tests/fixtures/cjs-deep-example/d-sub-folder/d-two-a.js

@@ -0,0 +1,8 @@
+const { three } = require('./d-sub-sub-folder/d-three')
+
+const twoA = 'twoA'
+
+module.exports = {
+  twoA,
+  three
+}

package/tests/fixtures/cjs-deep-example/d-sub-folder/d-two-b.js

@@ -0,0 +1,8 @@
+const { three } = require('./d-sub-sub-folder/d-three')
+
+const twoB = 'twoB'
+
+module.exports = {
+  twoB,
+  three
+}

package/tests/fixtures/cjs-deep-example/d-sub-folder/d-two.js

@@ -0,0 +1,8 @@
+const { three } = require('./d-sub-sub-folder/d-three')
+
+const two = 'twoB'
+
+module.exports = {
+  two,
+  three
+}

package/tests/fixtures/cjs-deep-example/index.js

@@ -0,0 +1,8 @@
+const lodash = require('lodash')
+const { one, two, three } = require('./d-one')
+
+module.exports = {
+  one,
+  two,
+  three
+}

package/tests/fixtures/cjs-example/index.js

@@ -0,0 +1,8 @@
+const lodash = require('lodash')
+const { one, two, three } = require('./one')
+
+module.exports = {
+  one,
+  two,
+  three
+}

package/tests/fixtures/cjs-example/one.js

@@ -0,0 +1,9 @@
+const { two, three } = require('./sub-folder/two')
+
+const one = 'one'
+
+module.exports = {
+  one,
+  two,
+  three
+}

package/tests/fixtures/cjs-example/sub-folder/sub-sub-folder/three.js

@@ -0,0 +1,6 @@
+
+const three = 'three'
+
+module.exports = {
+  three
+}

package/tests/fixtures/cjs-example/sub-folder/two.js

@@ -0,0 +1,8 @@
+const { three } = require('./sub-sub-folder/three')
+
+const two = 'two'
+
+module.exports = {
+  two,
+  three
+}

package/tests/fixtures/cjs-parent.js

@@ -0,0 +1,5 @@
+const parent = 'parent'
+
+module.exports = {
+  parent
+}

package/tests/fixtures/esm-fixture/index.js

@@ -0,0 +1,8 @@
+import lodash from 'lodash'
+import { one, two, three } from './one.js'
+
+export {
+  one,
+  two,
+  three
+}

package/tests/fixtures/esm-fixture/one.js

@@ -0,0 +1,9 @@
+import { two, three } from './sub-folder/two.js'
+
+const one = 'one'
+
+export {
+  one,
+  two,
+  three
+}

package/tests/fixtures/esm-fixture/sub-folder/sub-sub-folder/three.js

@@ -0,0 +1,6 @@
+
+const three = 'three'
+
+export {
+  three
+}

package/tests/fixtures/esm-fixture/sub-folder/two.js

@@ -0,0 +1,8 @@
+import { three } from './sub-sub-folder/three.js'
+
+const two = 'two'
+
+export {
+  two,
+  three
+}

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()