@davidwells/extract-deps 0.0.1

package/src/utils.js

@@ -0,0 +1,64 @@
+const { inspectParameters, getParametersNames } = require('inspect-parameters-declaration')
+
+function isRelativeImport(importLocation) {
+  return !!importLocation.match(/^\./)
+}
+
+function isRelativeImportWithQuotes(importLocation) {
+  // TODO harden for "${" or " + 'var' + "
+  return !!importLocation.match(/[`"']\./) 
+    && importLocation.indexOf('${') === -1  // No template literals
+    && importLocation.indexOf(' + ') === -1 // No string concatenation
+}
+
+function getNames(names) {
+  // console.log('names', names)
+  // Safety check for undefined or null names
+  if (!names || names.trim() === '') {
+    return null
+  }
+  const results = inspectParameters(names).map((item) => {
+    item.name = item.parameter
+    if (item.destructuredParameters && item.destructuredParameters.length > 0) {
+      item.destructuredParameters = item.destructuredParameters.map((details) => {
+        if (details.parameter.indexOf(':') > -1) {
+          const [ name, alias ] = details.parameter.replace(/^{/, '').replace(/}$/, '').split(':')
+          details.name = name.trim()
+          details.alias = alias.trim()
+          delete details.parameter
+          return details
+        }
+        if (details.declaration.indexOf(' as ') > -1) {
+          const [ parameter, alias ] = details.declaration.split(' as ')
+          details.name = parameter.trim()
+          details.alias = alias.trim()
+          delete details.parameter
+          return details
+        }
+        details.name = details.parameter
+        delete details.parameter
+        return details
+      })
+    }
+
+    if (item.name.indexOf('{') === -1 && item.parameter.indexOf(' as ') > -1) {
+      const [ parameter, alias ] = item.parameter.split(' as ')
+      item.name = parameter.trim()
+      item.alias = alias.trim()
+    }
+
+    delete item.parameter
+
+    return item
+  })
+  
+  // Return the first (and only) result instead of the array
+  return results.length > 0 ? results[0] : null
+}
+
+
+module.exports = {
+  isRelativeImport,
+  isRelativeImportWithQuotes,
+  getNames
+}

package/tests/detect-syntax.test.js

@@ -0,0 +1,280 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { hasESMSyntax, hasCJSSyntax, detectSyntax } = require('../src/detect-syntax.js')
+
+// Test data for ESM syntax
+const ESM_EXAMPLES = [
+  'import foo from "bar"',
+  'import { foo } from "bar"',
+  'import * as foo from "bar"',
+  'import foo, { bar } from "baz"',
+  'export default foo',
+  'export { foo }',
+  'export * from "bar"',
+  'export const foo = "bar"',
+  'export function foo() {}',
+  'export class Foo {}',
+  'export type Foo = string',
+  'export async function foo() {}',
+  'import.meta.url',
+  'import.meta.resolve("foo")'
+]
+
+// Test data for CJS syntax
+const CJS_EXAMPLES = [
+  'module.exports = foo',
+  'module.exports.foo = bar',
+  'exports.foo = bar',
+  'require("foo")',
+  'const foo = require("bar")',
+  'global.foo = bar',
+  'global.console.log("test")'
+]
+
+// Test data for mixed syntax
+const MIXED_EXAMPLES = [
+  `import foo from "bar"
+   module.exports = foo`,
+  `const foo = require("bar")
+   export default foo`,
+  `export { foo }
+   const bar = require("baz")`
+]
+
+// Test data for no syntax
+const NO_SYNTAX_EXAMPLES = [
+  'const foo = "bar"',
+  'function test() { return true }',
+  'class Test {}',
+  'console.log("hello")',
+  'const obj = { foo: "bar" }',
+  'if (true) { console.log("test") }'
+]
+
+// Test data with comments
+const COMMENTED_EXAMPLES = [
+  '// import foo from "bar"',
+  '/* export default foo */',
+  'const foo = "bar" // module.exports = foo',
+  '/* require("foo") */ const bar = "baz"'
+]
+
+// Test data with comments followed by actual syntax
+const COMMENTED_WITH_SYNTAX_EXAMPLES = [
+  `// This is a comment
+   import foo from "bar"`,
+  `/* Multi-line comment
+     about exports */
+   module.exports = foo`
+]
+
+test('hasESMSyntax should detect ESM syntax correctly', () => {
+  ESM_EXAMPLES.forEach((code, index) => {
+    assert.ok(hasESMSyntax(code), `ESM example ${index + 1} should be detected: "${code}"`)
+  })
+})
+
+test('hasESMSyntax should not detect non-ESM syntax', () => {
+  CJS_EXAMPLES.forEach((code, index) => {
+    assert.not(hasESMSyntax(code), `CJS example ${index + 1} should not be detected as ESM: "${code}"`)
+  })
+  
+  NO_SYNTAX_EXAMPLES.forEach((code, index) => {
+    assert.not(hasESMSyntax(code), `No syntax example ${index + 1} should not be detected as ESM: "${code}"`)
+  })
+})
+
+test('hasCJSSyntax should detect CJS syntax correctly', () => {
+  CJS_EXAMPLES.forEach((code, index) => {
+    assert.ok(hasCJSSyntax(code), `CJS example ${index + 1} should be detected: "${code}"`)
+  })
+})
+
+test('hasCJSSyntax should not detect non-CJS syntax', () => {
+  ESM_EXAMPLES.forEach((code, index) => {
+    assert.not(hasCJSSyntax(code), `ESM example ${index + 1} should not be detected as CJS: "${code}"`)
+  })
+  
+  NO_SYNTAX_EXAMPLES.forEach((code, index) => {
+    assert.not(hasCJSSyntax(code), `No syntax example ${index + 1} should not be detected as CJS: "${code}"`)
+  })
+})
+
+test('detectSyntax should correctly identify ESM-only code', () => {
+  ESM_EXAMPLES.forEach((code, index) => {
+    const result = detectSyntax(code)
+    assert.ok(result.hasESM, `ESM example ${index + 1} should have hasESM=true: "${code}"`)
+    assert.not(result.hasCJS, `ESM example ${index + 1} should have hasCJS=false: "${code}"`)
+    assert.not(result.isMixed, `ESM example ${index + 1} should have isMixed=false: "${code}"`)
+  })
+})
+
+test('detectSyntax should correctly identify CJS-only code', () => {
+  CJS_EXAMPLES.forEach((code, index) => {
+    const result = detectSyntax(code)
+    assert.not(result.hasESM, `CJS example ${index + 1} should have hasESM=false: "${code}"`)
+    assert.ok(result.hasCJS, `CJS example ${index + 1} should have hasCJS=true: "${code}"`)
+    assert.not(result.isMixed, `CJS example ${index + 1} should have isMixed=false: "${code}"`)
+  })
+})
+
+test('detectSyntax should correctly identify mixed syntax code', () => {
+  MIXED_EXAMPLES.forEach((code, index) => {
+    const result = detectSyntax(code)
+    /*
+    console.info(code);
+    console.log(result)
+    /** */
+    assert.ok(result.hasESM, `Mixed example ${index + 1} should have hasESM=true: "${code}"`)
+    assert.ok(result.hasCJS, `Mixed example ${index + 1} should have hasCJS=true: "${code}"`)
+    assert.ok(result.isMixed, `Mixed example ${index + 1} should have isMixed=true: "${code}"`)
+  })
+})
+
+test('detectSyntax should correctly identify code with no syntax', () => {
+  NO_SYNTAX_EXAMPLES.forEach((code, index) => {
+    const result = detectSyntax(code)
+    assert.not(result.hasESM, `No syntax example ${index + 1} should have hasESM=false: "${code}"`)
+    assert.not(result.hasCJS, `No syntax example ${index + 1} should have hasCJS=false: "${code}"`)
+    assert.not(result.isMixed, `No syntax example ${index + 1} should have isMixed=false: "${code}"`)
+  })
+})
+
+test('should handle comments correctly (comments are always stripped)', () => {
+  COMMENTED_EXAMPLES.forEach((code, index) => {
+    const result = detectSyntax(code)
+    // Comments are always stripped to avoid false positives from commented syntax
+    assert.not(result.hasESM, `Commented example ${index + 1} should not detect commented ESM: "${code}"`)
+    assert.not(result.hasCJS, `Commented example ${index + 1} should not detect commented CJS: "${code}"`)
+  })
+})
+
+test('should detect actual syntax even when comments are present', () => {
+  COMMENTED_WITH_SYNTAX_EXAMPLES.forEach((code, index) => {
+    const result = detectSyntax(code)
+    // After stripping comments, actual syntax should be detected
+    if (code.includes('import')) {
+      assert.ok(result.hasESM, `Should detect ESM after stripping comments: "${code}"`)
+    }
+    if (code.includes('module.exports')) {
+      assert.ok(result.hasCJS, `Should detect CJS after stripping comments: "${code}"`)
+    }
+  })
+  
+  const commentedCode = '// import foo from "bar"\nmodule.exports = foo'
+  const result = detectSyntax(commentedCode)
+  
+  // Should detect the actual syntax, not the commented syntax
+  assert.not(result.hasESM, 'Should not detect commented ESM')
+  assert.ok(result.hasCJS, 'Should detect actual CJS syntax')
+})
+
+test('should handle complex real-world examples', () => {
+  const complexESM = `
+    import React from 'react'
+    import { useState, useEffect } from 'react'
+    import * as utils from './utils'
+    
+    export default function App() {
+      const [state, setState] = useState()
+      return <div>Hello</div>
+    }
+    
+    export const helper = () => {}
+  `
+  
+  const complexCJS = `
+    const express = require('express')
+    const path = require('path')
+    
+    module.exports = function(app) {
+      app.get('/', (req, res) => {
+        res.send('Hello')
+      })
+    }
+    
+    exports.helper = function() {}
+  `
+  
+  const complexMixed = `
+    import React from 'react'
+    const express = require('express')
+    
+    export default function App() {
+      return <div>Hello</div>
+    }
+    
+    module.exports = { App }
+  `
+  
+  // Test ESM
+  const esmResult = detectSyntax(complexESM)
+  assert.ok(esmResult.hasESM, 'Complex ESM should be detected')
+  assert.not(esmResult.hasCJS, 'Complex ESM should not have CJS')
+  assert.not(esmResult.isMixed, 'Complex ESM should not be mixed')
+  
+  // Test CJS
+  const cjsResult = detectSyntax(complexCJS)
+  assert.not(cjsResult.hasESM, 'Complex CJS should not have ESM')
+  assert.ok(cjsResult.hasCJS, 'Complex CJS should be detected')
+  assert.not(cjsResult.isMixed, 'Complex CJS should not be mixed')
+  
+  // Test Mixed
+  const mixedResult = detectSyntax(complexMixed)
+  assert.ok(mixedResult.hasESM, 'Complex mixed should have ESM')
+  assert.ok(mixedResult.hasCJS, 'Complex mixed should have CJS')
+  assert.ok(mixedResult.isMixed, 'Complex mixed should be mixed')
+})
+
+test('should handle edge cases and whitespace', () => {
+  // Empty string
+  const emptyResult = detectSyntax('')
+  assert.not(emptyResult.hasESM, 'Empty string should not have ESM')
+  assert.not(emptyResult.hasCJS, 'Empty string should not have CJS')
+  assert.not(emptyResult.isMixed, 'Empty string should not be mixed')
+  
+  // Whitespace only
+  const whitespaceResult = detectSyntax('   \n\t  ')
+  assert.not(whitespaceResult.hasESM, 'Whitespace only should not have ESM')
+  assert.not(whitespaceResult.hasCJS, 'Whitespace only should not have CJS')
+  assert.not(whitespaceResult.isMixed, 'Whitespace only should not be mixed')
+  
+  // Syntax with extra whitespace
+  const spacedESM = '  import  foo  from  "bar"  '
+  const spacedCJS = '  module.exports  =  foo  '
+  
+  assert.ok(hasESMSyntax(spacedESM), 'ESM with extra whitespace should be detected')
+  assert.ok(hasCJSSyntax(spacedCJS), 'CJS with extra whitespace should be detected')
+})
+
+test('should handle regex edge cases', () => {
+  // Test that the regex doesn't match partial words
+  const partialESM = 'importing foo from "bar"'
+  const partialCJS = 'module.exporting = foo'
+  
+  assert.not(hasESMSyntax(partialESM), 'Partial ESM word should not be detected')
+  assert.not(hasCJSSyntax(partialCJS), 'Partial CJS word should not be detected')
+  
+  // Test that it matches at word boundaries
+  const boundaryESM = 'const x = "import foo from bar"'
+  const boundaryCJS = 'const x = "module.exports = foo"'
+  
+  assert.not(hasESMSyntax(boundaryESM), 'ESM in string should not be detected')
+  assert.not(hasCJSSyntax(boundaryCJS), 'CJS in string should not be detected')
+})
+
+test('should handle TypeScript-specific syntax', () => {
+  const tsExamples = [
+    'import type { Foo } from "bar"',
+    'export type Foo = string',
+    'import { type Foo } from "bar"',
+    'export interface Foo {}',
+    'export enum Foo {}'
+  ]
+  
+  tsExamples.forEach((code, index) => {
+    assert.ok(hasESMSyntax(code), `TypeScript example ${index + 1} should be detected as ESM: "${code}"`)
+  })
+})
+
+test.run() 

package/tests/get-exports.test.js

@@ -0,0 +1,346 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { 
+  getExports, 
+  getDefaultExports, 
+  getNamedExports, 
+  getNamedDeclarationExports, 
+  getAllExports, 
+  getNamespaceExports, 
+  getTypeExports,
+  getAssertionExports 
+} = require('../src/get-exports.js')
+
+test('should extract default exports', () => {
+  const code = `
+export default function myFunction() {}
+export default class MyClass {}
+export default { foo: 'bar' }
+export default [1, 2, 3]
+export default 'hello'
+export default 42
+export default () => {}
+  `
+  
+  const exports = getDefaultExports(code)
+  
+  assert.ok(exports.length === 6, 'Should find 6 default exports')
+  
+  // Check function export
+  const functionExport = exports.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')
+  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')
+  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]')
+  assert.ok(arrayExport, 'Should find array literal export')
+  assert.equal(arrayExport.exportName, 'literal')
+  
+  // Check number literal
+  const numberExport = exports.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 === '() =>')
+  assert.ok(arrowExport, 'Should find arrow function export')
+  assert.equal(arrowExport.exportName, 'anonymous')
+})
+
+test('should extract named exports', () => {
+  const code = `
+export const myVariable = 'value'
+export let anotherVariable = 'value'
+export var thirdVariable = 'value'
+export function myFunction() {}
+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)
+  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 => {
+    assert.equal(exp.exportType, 'named')
+    assert.ok(exp.isExport)
+  })
+})
+
+test('should extract named declaration exports', () => {
+  const code = `
+export { myFunction, anotherFunction }
+export { myFunction as aliasedFunction, anotherFunction }
+export { default } from './module'
+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')
+  
+  // Check simple exports
+  const simpleExports = exports.filter(exp => !exp.exportAlias)
+  assert.ok(simpleExports.length === 6, 'Should have 6 simple exports')
+  
+  // Check aliased exports
+  const aliasedExports = exports.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')
+  assert.ok(aliasedFunction, 'Should find aliased function export')
+  assert.equal(aliasedFunction.exportName, 'myFunction')
+  
+  const aliasedDefault = exports.find(exp => exp.exportAlias === 'aliasedDefault')
+  assert.ok(aliasedDefault, 'Should find aliased default export')
+  assert.equal(aliasedDefault.exportName, 'default')
+  
+  exports.forEach(exp => {
+    assert.equal(exp.exportType, 'named')
+    assert.ok(exp.isExport)
+  })
+})
+
+test('should extract all exports (re-exports)', () => {
+  const code = `
+export * from './module'
+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)
+  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 => {
+    assert.equal(exp.exportType, 'all')
+    assert.ok(exp.isExport)
+  })
+})
+
+test('should extract namespace exports', () => {
+  const code = `
+export * as namespace from './module'
+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)
+  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)
+  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 => {
+    assert.equal(exp.exportType, 'namespace')
+    assert.ok(exp.isExport)
+  })
+})
+
+test('should extract type exports', () => {
+  const code = `
+export type MyType = string
+export interface MyInterface {}
+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)
+  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 => {
+    assert.equal(exp.exportType, 'type')
+    assert.ok(exp.isExport)
+  })
+})
+
+test('should extract assertion exports', () => {
+  const code = `
+export { default } from './module' assert { type: 'json' }
+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')
+  
+  // Check JSON assertion
+  const jsonExports = exports.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'))
+  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')
+  assert.ok(assertExports.length === 2, 'Should find 2 assert exports')
+  assert.ok(withExports.length === 1, 'Should find 1 with export')
+  
+  exports.forEach(exp => {
+    assert.equal(exp.exportType, 'assertion')
+    assert.ok(exp.isExport)
+    assert.ok(exp.isAssertion)
+  })
+})
+
+test('should combine all export types in getExports', () => {
+  const code = `
+// Default exports
+export default function myFunction() {}
+export default class MyClass {}
+
+// Named exports
+export const myVariable = 'value'
+export function myFunction() {}
+
+// Named declaration exports
+export { myFunction, anotherFunction }
+export { myFunction as aliasedFunction }
+
+// Re-exports
+export * from './module'
+export * as namespace from './module'
+
+// Type exports
+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 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')
+  }
+})
+
+test('should handle empty code', () => {
+  const exports = getExports('')
+  
+  assert.ok(exports.length === 0, 'Should return empty array for empty code')
+})
+
+test('should handle code with no exports', () => {
+  const code = `
+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')
+})
+
+test('should handle complex export patterns', () => {
+  const code = `
+// Complex default exports
+export default (props) => <Component {...props} />
+export default function() { return 'anonymous' }
+export default class { constructor() {} }
+
+// Complex named exports with destructuring
+export const { Component, Button } = React
+export const [first, second] = ['a', 'b']
+
+// Complex re-exports
+export { default as MyComponent, Button, Input } from './components'
+export { 
+  default as App,
+  Header,
+  Footer 
+} from './app'
+  `
+  
+  const exports = getExports(code)
+  
+  assert.ok(exports.length > 0, 'Should find exports in complex code')
+  
+  // Should handle anonymous functions and classes
+  const anonymousExports = exports.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')
+  assert.ok(namedDeclarations.length >= 6, 'Should find complex named declaration exports')
+})
+
+test('should handle assertion exports with options', () => {
+  const code = `
+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)
+  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.run()