@davidwells/extract-deps 0.0.1 → 0.0.3

package/tests/get-exports.test.js

@@ -22,39 +22,39 @@ export default 42
 export default () => {}
   `
   
-  const exports = getDefaultExports(code)
-  
-  assert.ok(exports.length === 6, 'Should find 6 default exports')
-  
+  const foundExports = getDefaultExports(code)
+
+  assert.ok(foundExports.length === 6, 'Should find 6 default exports')
+
   // Check function export
-  const functionExport = exports.find(exp => exp.exportName === 'myFunction')
+  const functionExport = foundExports.find(exp => exp.exportName === 'myFunction')
   assert.ok(functionExport, 'Should find function export')
   assert.equal(functionExport.exportType, 'default')
   assert.equal(functionExport.exportValue, 'function myFunction')
-  
+
   // Check class export
-  const classExport = exports.find(exp => exp.exportName === 'MyClass')
+  const classExport = foundExports.find(exp => exp.exportName === 'MyClass')
   assert.ok(classExport, 'Should find class export')
   assert.equal(classExport.exportType, 'default')
   assert.equal(classExport.exportValue, 'class MyClass')
-  
+
   // Check object literal
-  const objectExport = exports.find(exp => exp.exportName === 'literal')
+  const objectExport = foundExports.find(exp => exp.exportName === 'literal')
   assert.ok(objectExport, 'Should find object literal export')
   assert.equal(objectExport.exportValue, "{ foo: 'bar' }")
-  
+
   // Check array literal
-  const arrayExport = exports.find(exp => exp.exportValue === '[1, 2, 3]')
+  const arrayExport = foundExports.find(exp => exp.exportValue === '[1, 2, 3]')
   assert.ok(arrayExport, 'Should find array literal export')
   assert.equal(arrayExport.exportName, 'literal')
-  
+
   // Check number literal
-  const numberExport = exports.find(exp => exp.exportValue === '42')
+  const numberExport = foundExports.find(exp => exp.exportValue === '42')
   assert.ok(numberExport, 'Should find number literal export')
   assert.equal(numberExport.exportName, '42')
-  
+
   // Check arrow function
-  const arrowExport = exports.find(exp => exp.exportValue === '() =>')
+  const arrowExport = foundExports.find(exp => exp.exportValue === '() =>')
   assert.ok(arrowExport, 'Should find arrow function export')
   assert.equal(arrowExport.exportName, 'anonymous')
 })
@@ -69,19 +69,19 @@ export class MyClass {}
 export async function asyncFunction() {}
   `
   
-  const exports = getNamedExports(code)
-  
-  assert.ok(exports.length === 6, 'Should find 6 named exports')
-  
-  const exportNames = exports.map(exp => exp.exportName)
+  const foundExports = getNamedExports(code)
+
+  assert.ok(foundExports.length === 6, 'Should find 6 named exports')
+
+  const exportNames = foundExports.map(exp => exp.exportName)
   assert.ok(exportNames.includes('myVariable'), 'Should find const export')
   assert.ok(exportNames.includes('anotherVariable'), 'Should find let export')
   assert.ok(exportNames.includes('thirdVariable'), 'Should find var export')
   assert.ok(exportNames.includes('myFunction'), 'Should find function export')
   assert.ok(exportNames.includes('MyClass'), 'Should find class export')
   assert.ok(exportNames.includes('asyncFunction'), 'Should find async function export')
-  
-  exports.forEach(exp => {
+
+  foundExports.forEach(exp => {
     assert.equal(exp.exportType, 'named')
     assert.ok(exp.isExport)
   })
@@ -96,28 +96,28 @@ export { default as aliasedDefault } from './module'
 export { Component, Button } from './components'
   `
   
-  const exports = getNamedDeclarationExports(code)
-  
-  assert.ok(exports.length === 8, 'Should find 8 named declaration exports')
-  
+  const foundExports = getNamedDeclarationExports(code)
+
+  assert.ok(foundExports.length === 8, 'Should find 8 named declaration exports')
+
   // Check simple exports
-  const simpleExports = exports.filter(exp => !exp.exportAlias)
+  const simpleExports = foundExports.filter(exp => !exp.exportAlias)
   assert.ok(simpleExports.length === 6, 'Should have 6 simple exports')
-  
+
   // Check aliased exports
-  const aliasedExports = exports.filter(exp => exp.exportAlias)
+  const aliasedExports = foundExports.filter(exp => exp.exportAlias)
   assert.ok(aliasedExports.length === 2, 'Should have 2 aliased exports')
-  
+
   // Check specific aliases
-  const aliasedFunction = exports.find(exp => exp.exportAlias === 'aliasedFunction')
+  const aliasedFunction = foundExports.find(exp => exp.exportAlias === 'aliasedFunction')
   assert.ok(aliasedFunction, 'Should find aliased function export')
   assert.equal(aliasedFunction.exportName, 'myFunction')
-  
-  const aliasedDefault = exports.find(exp => exp.exportAlias === 'aliasedDefault')
+
+  const aliasedDefault = foundExports.find(exp => exp.exportAlias === 'aliasedDefault')
   assert.ok(aliasedDefault, 'Should find aliased default export')
   assert.equal(aliasedDefault.exportName, 'default')
-  
-  exports.forEach(exp => {
+
+  foundExports.forEach(exp => {
     assert.equal(exp.exportType, 'named')
     assert.ok(exp.isExport)
   })
@@ -130,16 +130,16 @@ export * from './utils'
 export * from '@angular/core'
   `
   
-  const exports = getAllExports(code)
-  
-  assert.ok(exports.length === 3, 'Should find 3 all exports')
-  
-  const fromModules = exports.map(exp => exp.from)
+  const foundExports = getAllExports(code)
+
+  assert.ok(foundExports.length === 3, 'Should find 3 all exports')
+
+  const fromModules = foundExports.map(exp => exp.from)
   assert.ok(fromModules.includes('./module'), 'Should export all from ./module')
   assert.ok(fromModules.includes('./utils'), 'Should export all from ./utils')
   assert.ok(fromModules.includes('@angular/core'), 'Should export all from @angular/core')
-  
-  exports.forEach(exp => {
+
+  foundExports.forEach(exp => {
     assert.equal(exp.exportType, 'all')
     assert.ok(exp.isExport)
   })
@@ -152,21 +152,21 @@ export * as utils from './utils'
 export * as angular from '@angular/core'
   `
   
-  const exports = getNamespaceExports(code)
-  
-  assert.ok(exports.length === 3, 'Should find 3 namespace exports')
-  
-  const namespaceNames = exports.map(exp => exp.namespace)
+  const foundExports = getNamespaceExports(code)
+
+  assert.ok(foundExports.length === 3, 'Should find 3 namespace exports')
+
+  const namespaceNames = foundExports.map(exp => exp.namespace)
   assert.ok(namespaceNames.includes('namespace'), 'Should find namespace export')
   assert.ok(namespaceNames.includes('utils'), 'Should find utils namespace export')
   assert.ok(namespaceNames.includes('angular'), 'Should find angular namespace export')
-  
-  const fromModules = exports.map(exp => exp.from)
+
+  const fromModules = foundExports.map(exp => exp.from)
   assert.ok(fromModules.includes('./module'), 'Should export namespace from ./module')
   assert.ok(fromModules.includes('./utils'), 'Should export namespace from ./utils')
   assert.ok(fromModules.includes('@angular/core'), 'Should export namespace from @angular/core')
-  
-  exports.forEach(exp => {
+
+  foundExports.forEach(exp => {
     assert.equal(exp.exportType, 'namespace')
     assert.ok(exp.isExport)
   })
@@ -180,17 +180,17 @@ export type User = { id: string; name: string }
 export interface ComponentProps { children: React.ReactNode }
   `
   
-  const exports = getTypeExports(code)
-  
-  assert.ok(exports.length === 4, 'Should find 4 type exports')
-  
-  const typeNames = exports.map(exp => exp.exportName)
+  const foundExports = getTypeExports(code)
+
+  assert.ok(foundExports.length === 4, 'Should find 4 type exports')
+
+  const typeNames = foundExports.map(exp => exp.exportName)
   assert.ok(typeNames.includes('MyType'), 'Should find MyType export')
   assert.ok(typeNames.includes('MyInterface'), 'Should find MyInterface export')
   assert.ok(typeNames.includes('User'), 'Should find User type export')
   assert.ok(typeNames.includes('ComponentProps'), 'Should find ComponentProps interface export')
-  
-  exports.forEach(exp => {
+
+  foundExports.forEach(exp => {
     assert.equal(exp.exportType, 'type')
     assert.ok(exp.isExport)
   })
@@ -203,25 +203,25 @@ export { Component } from './component' with { type: 'css' }
 export { data } from './data.json' assert { type: 'json' }
   `
   
-  const exports = getAssertionExports(code)
-  
-  assert.ok(exports.length === 3, 'Should find 3 assertion exports')
-  
+  const foundExports = getAssertionExports(code)
+
+  assert.ok(foundExports.length === 3, 'Should find 3 assertion exports')
+
   // Check JSON assertion
-  const jsonExports = exports.filter(exp => exp.assertion.includes('json'))
+  const jsonExports = foundExports.filter(exp => exp.assertion.includes('json'))
   assert.ok(jsonExports.length === 2, 'Should find 2 JSON assertion exports')
-  
+
   // Check CSS assertion
-  const cssExports = exports.filter(exp => exp.assertion.includes('css'))
+  const cssExports = foundExports.filter(exp => exp.assertion.includes('css'))
   assert.ok(cssExports.length === 1, 'Should find 1 CSS assertion export')
-  
+
   // Check assertion types
-  const assertExports = exports.filter(exp => exp.assertionType === 'assert')
-  const withExports = exports.filter(exp => exp.assertionType === 'with')
+  const assertExports = foundExports.filter(exp => exp.assertionType === 'assert')
+  const withExports = foundExports.filter(exp => exp.assertionType === 'with')
   assert.ok(assertExports.length === 2, 'Should find 2 assert exports')
   assert.ok(withExports.length === 1, 'Should find 1 with export')
-  
-  exports.forEach(exp => {
+
+  foundExports.forEach(exp => {
     assert.equal(exp.exportType, 'assertion')
     assert.ok(exp.isExport)
     assert.ok(exp.isAssertion)
@@ -251,33 +251,33 @@ export type MyType = string
 export interface MyInterface {}
   `
   
-  const exports = getExports(code)
-  
-  assert.ok(exports.length === 11, 'Should find 11 total exports')
-  
-  const exportTypes = exports.map(exp => exp.exportType)
+  const foundExports = getExports(code)
+
+  assert.ok(foundExports.length === 11, 'Should find 11 total exports')
+
+  const exportTypes = foundExports.map(exp => exp.exportType)
   const defaultCount = exportTypes.filter(type => type === 'default').length
   const namedCount = exportTypes.filter(type => type === 'named').length
   const allCount = exportTypes.filter(type => type === 'all').length
   const namespaceCount = exportTypes.filter(type => type === 'namespace').length
   const typeCount = exportTypes.filter(type => type === 'type').length
-  
+
   assert.equal(defaultCount, 2, 'Should have 2 default exports')
   assert.equal(namedCount, 5, 'Should have 5 named exports')
   assert.equal(allCount, 1, 'Should have 1 all export')
   assert.equal(namespaceCount, 1, 'Should have 1 namespace export')
   assert.equal(typeCount, 2, 'Should have 2 type exports')
-  
+
   // Check sorting by index
-  for (let i = 1; i < exports.length; i++) {
-    assert.ok(exports[i].index >= exports[i-1].index, 'Exports should be sorted by index')
+  for (let i = 1; i < foundExports.length; i++) {
+    assert.ok(foundExports[i].index >= foundExports[i-1].index, 'Exports should be sorted by index')
   }
 })
 
 test('should handle empty code', () => {
-  const exports = getExports('')
-  
-  assert.ok(exports.length === 0, 'Should return empty array for empty code')
+  const foundExports = getExports('')
+
+  assert.ok(foundExports.length === 0, 'Should return empty array for empty code')
 })
 
 test('should handle code with no exports', () => {
@@ -286,10 +286,10 @@ function myFunction() {}
 const myVariable = 'value'
 import { something } from './module'
   `
-  
-  const exports = getExports(code)
-  
-  assert.ok(exports.length === 0, 'Should return empty array for code with no exports')
+
+  const foundExports = getExports(code)
+
+  assert.ok(foundExports.length === 0, 'Should return empty array for code with no exports')
 })
 
 test('should handle complex export patterns', () => {
@@ -312,16 +312,17 @@ export {
 } from './app'
   `
   
-  const exports = getExports(code)
-  
-  assert.ok(exports.length > 0, 'Should find exports in complex code')
-  
+  const foundExports = getExports(code)
+  // console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length > 0, 'Should find exports in complex code')
+
   // Should handle anonymous functions and classes
-  const anonymousExports = exports.filter(exp => exp.exportName === 'anonymous')
+  const anonymousExports = foundExports.filter(exp => exp.exportName === 'anonymous')
   assert.ok(anonymousExports.length >= 2, 'Should find anonymous function and class exports')
-  
+
   // Should handle complex named declaration exports
-  const namedDeclarations = exports.filter(exp => exp.exportType === 'named')
+  const namedDeclarations = foundExports.filter(exp => exp.exportType === 'named')
   assert.ok(namedDeclarations.length >= 6, 'Should find complex named declaration exports')
 })
 
@@ -331,16 +332,52 @@ export { default } from './module' assert { type: 'json' }
 export { Component } from './component' with { type: 'css' }
   `
   
-  const exports = getExports(code, { includeAssertionExports: true })
-  
-  assert.ok(exports.length === 4, 'Should find 4 exports when assertions enabled')
-  
-  const assertionExports = exports.filter(exp => exp.isAssertion)
+  const foundExports = getExports(code, { includeAssertionExports: true })
+
+  // console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 4, 'Should find 4 exports when assertions enabled')
+
+  const assertionExports = foundExports.filter(exp => exp.isAssertion)
   assert.ok(assertionExports.length === 2, 'Should find 2 assertion exports')
-  
+
   // Test without assertion exports
   const exportsWithoutAssertions = getExports(code, { includeAssertionExports: false })
   assert.ok(exportsWithoutAssertions.length === 2, 'Should find 2 named exports when assertions disabled')
 })
 
+
+test('export with default', () => {
+  /* single line export */
+  const code = `export { default as MyComponent, Button, Input }`
+  /* Equivalent to: */
+  const longForm = `
+import MyComponent, { Button, Input } from './components'
+export { MyComponent, Button, Input }  
+`
+  
+  const longFormExports = getExports(longForm)
+  // console.log('longFormExports', longFormExports)
+  assert.ok(longFormExports.length === 3, 'Should find 3 exports in longForm')
+
+  const foundExports = getExports(code)
+
+  // console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 3, 'Should find 3 exports when assertions enabled')
+
+  const firstExport = foundExports[0]
+  assert.ok(firstExport.exportName === 'default', 'Should find default export')
+  assert.ok(firstExport.exportAlias === 'MyComponent', 'Should find MyComponent export')
+  assert.ok(firstExport.exportType === 'named', 'Should find named export')
+
+  const secondExport = foundExports[1]
+  assert.ok(secondExport.exportName === 'Button', 'Should find Button export')
+  assert.ok(secondExport.exportType === 'named', 'Should find named export')
+
+  const thirdExport = foundExports[2]
+  assert.ok(thirdExport.exportName === 'Input', 'Should find Input export')
+  assert.ok(thirdExport.exportType === 'named', 'Should find named export')
+})
+
 test.run()