@davidwells/extract-deps 0.0.4 → 0.0.6

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

@@ -588,4 +588,175 @@ module.exports = async function handler(event) {
   assert.equal(foundExports[0].exportName, '', 'exportName should empty because it default function')
 })
 
+test('should handle Object.defineProperty on module.exports', () => {
+  const code = `
+function assembleStyles() {
+  return { color: 'red', fontSize: '16px' }
+}
+
+Object.defineProperty(module, 'exports', {
+  enumerable: true,
+  get: assembleStyles
+})
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.equal(foundExports[0].exportType, 'default', 'Should be default export')
+  assert.equal(foundExports[0].exportName, '', 'Default export should have empty name')
+  assert.equal(foundExports[0].exportDefinitionName, 'assembleStyles', 'Should extract getter function name')
+  assert.ok(foundExports[0].isDefineProperty, 'Should have isDefineProperty flag')
+  assert.ok(foundExports[0].exportValue.includes('Object.defineProperty'), 'Should include full defineProperty call')
+})
+
+test('should handle Object.defineProperty on exports with named function', () => {
+  const code = `
+function getVersion() {
+  return '1.0.0'
+}
+
+Object.defineProperty(exports, 'version', {
+  enumerable: true,
+  get: getVersion
+})
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.equal(foundExports[0].exportType, 'named', 'Should be named export')
+  assert.equal(foundExports[0].exportName, 'version', 'Should extract property name')
+  assert.equal(foundExports[0].exportDefinitionName, 'getVersion', 'Should extract getter function name')
+  assert.ok(foundExports[0].isDefineProperty, 'Should have isDefineProperty flag')
+})
+
+test('should handle Object.defineProperty with arrow function getter', () => {
+  const code = `
+Object.defineProperty(exports, 'version', {
+  enumerable: true,
+  get: () => '1.0.0'
+})
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.equal(foundExports[0].exportType, 'named', 'Should be named export')
+  assert.equal(foundExports[0].exportName, 'version', 'Should extract property name')
+  assert.equal(foundExports[0].exportDefinitionName, 'arrow function', 'Should detect arrow function')
+  assert.ok(foundExports[0].isDefineProperty, 'Should have isDefineProperty flag')
+})
+
+test('should handle Object.defineProperty with getter method', () => {
+  const code = `
+Object.defineProperty(exports, 'config', {
+  enumerable: true,
+  get() {
+    return { debug: true }
+  }
+})
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.equal(foundExports[0].exportType, 'named', 'Should be named export')
+  assert.equal(foundExports[0].exportName, 'config', 'Should extract property name')
+  assert.equal(foundExports[0].exportDefinitionName, 'getter method', 'Should detect getter method')
+  assert.ok(foundExports[0].isDefineProperty, 'Should have isDefineProperty flag')
+})
+
+test('should handle multiple Object.defineProperty exports', () => {
+  const code = `
+Object.defineProperty(exports, 'foo', {
+  get: getFoo
+})
+
+Object.defineProperty(exports, 'bar', {
+  get: () => 'bar value'
+})
+
+Object.defineProperty(exports, 'baz', {
+  get() {
+    return 'baz value'
+  }
+})
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 3, 'Should find 3 exports')
+  
+  const fooExport = foundExports.find(exp => exp.exportName === 'foo')
+  assert.ok(fooExport, 'Should find foo export')
+  assert.equal(fooExport.exportDefinitionName, 'getFoo', 'Should extract named function')
+  
+  const barExport = foundExports.find(exp => exp.exportName === 'bar')
+  assert.ok(barExport, 'Should find bar export')
+  assert.equal(barExport.exportDefinitionName, 'arrow function', 'Should detect arrow function')
+  
+  const bazExport = foundExports.find(exp => exp.exportName === 'baz')
+  assert.ok(bazExport, 'Should find baz export')
+  assert.equal(bazExport.exportDefinitionName, 'getter method', 'Should detect getter method')
+  
+  foundExports.forEach(exp => {
+    assert.ok(exp.isDefineProperty, 'All should have isDefineProperty flag')
+  })
+})
+
+test('should handle mixed exports with Object.defineProperty', () => {
+  const code = `
+// Standard exports
+module.exports.hello = function() { return 'hello' }
+exports.foo = function() {}
+exports.bar = 'bar'
+
+// Object.defineProperty exports
+function assembleStyles() {
+  return { color: 'red' }
+}
+
+Object.defineProperty(module, 'exports', {
+  enumerable: true,
+  get: assembleStyles
+})
+
+Object.defineProperty(exports, 'version', {
+  enumerable: true,
+  get: () => '1.0.0'
+})
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 5, 'Should find 5 exports total')
+  
+  // Check standard exports
+  const helloExport = foundExports.find(exp => exp.exportName === 'hello')
+  assert.ok(helloExport, 'Should find hello export')
+  assert.ok(!helloExport.isDefineProperty, 'Standard export should not have isDefineProperty flag')
+  
+  const barExport = foundExports.find(exp => exp.exportName === 'bar')
+  assert.ok(barExport, 'Should find bar export')
+  assert.equal(barExport.exportValue, "'bar'", 'Should only capture bar value, not following code')
+  
+  // Check Object.defineProperty exports
+  const definePropertyExports = foundExports.filter(exp => exp.isDefineProperty)
+  assert.equal(definePropertyExports.length, 2, 'Should find 2 Object.defineProperty exports')
+  
+  const moduleExport = definePropertyExports.find(exp => exp.exportType === 'default')
+  assert.ok(moduleExport, 'Should find module.exports defineProperty')
+  assert.equal(moduleExport.exportDefinitionName, 'assembleStyles', 'Should extract getter name')
+  
+  const versionExport = definePropertyExports.find(exp => exp.exportName === 'version')
+  assert.ok(versionExport, 'Should find version defineProperty')
+  assert.equal(versionExport.exportDefinitionName, 'arrow function', 'Should detect arrow function')
+  
+  // Check sorting 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.run()

package/tests/get-imports.test.js

@@ -96,7 +96,7 @@ test('get jsDoc Imports', async () => {
     const importsFound = getTypeImports(code)
     /*
     console.log('importsFound')
-    deepLog(importsFound)
+    console.log(importsFound)
     /** */
     assert.equal(normalizeTestResult(importsFound), [
       {
@@ -104,6 +104,7 @@ test('get jsDoc Imports', async () => {
         importPath: './foo',
         importName: 'hdhdhdhdhddh',
         isImport: true,
+        isTypeImport: true,
         isRelative: true
       },
       {
@@ -111,6 +112,7 @@ test('get jsDoc Imports', async () => {
         importPath: 'lodash',
         importName: 'omit',
         isImport: true,
+        isTypeImport: true,
         isRelative: false
       },
       {
@@ -118,6 +120,7 @@ test('get jsDoc Imports', async () => {
         importPath: 'uvu/assert',
         importName: '',
         isImport: true,
+        isTypeImport: true,
         isRelative: false
       }
     ])

package/tests/manual/broken-cjs.js

@@ -0,0 +1,38 @@
+// Verify package.json entry points and their dependencies
+const path = require('path')
+const { getPackageEntryPoints, verifyPackageEntries } = require('../../src/verify-package-entries')
+
+if (require.main === module) {
+  // const pkgPath = path.resolve(__dirname, '../fixtures/esm-broken-fixture/package.json')
+  const pkgPath = path.resolve(__dirname, '../fixtures/cjs-broken-example/package.json')
+  console.log('=== Package Entry Points ===\n')
+  const entryPoints = getPackageEntryPoints(pkgPath)
+  entryPoints.forEach(ep => {
+    console.log(`${ep.field}: ${ep.path}`)
+  })
+
+  console.log('\n=== Verification Results ===\n')
+  const throwIfErrors = false
+  const results = verifyPackageEntries(pkgPath, { throwIfErrors })
+  console.log('results', results)
+
+  results.entryPoints.forEach(ep => {
+    console.log('\n──────────────────────────────────────────────────────────────')
+    console.log('PATH:  ', ep.path)
+    console.log(`Field:  "${ep.field}"`)
+    console.log(`Valid:  ${ep.valid ? '✅' : '❌'}`)
+    if (ep.sourceFiles) {
+      console.log(`srcFiles:  ${ep.sourceFiles.length} files`)
+      ep.sourceFiles.forEach(sf => {
+        console.log(`- ${sf}`)
+      })
+    }
+    if (ep.error) {
+      console.log(`Error:`)
+      console.log(ep.error.message)
+    }
+  })
+  console.log('\n──────────────────────────────────────────────────────────────')
+  console.log(`\nTotal unique dependencies: ${results.sourceFiles.size}`)
+  console.log(`Total errors: ${results.errors.length}`)
+}

package/tests/manual/broken-esm.js

@@ -0,0 +1,37 @@
+// Verify package.json entry points and their dependencies
+const path = require('path')
+const { getPackageEntryPoints, verifyPackageEntries } = require('../../src/verify-package-entries')
+
+if (require.main === module) {
+  const pkgPath = path.resolve(__dirname, '../fixtures/esm-broken-fixture/package.json')
+  console.log('=== Package Entry Points ===\n')
+  const entryPoints = getPackageEntryPoints(pkgPath)
+  entryPoints.forEach(ep => {
+    console.log(`${ep.field}: ${ep.path}`)
+  })
+
+  console.log('\n=== Verification Results ===\n')
+  const throwIfErrors = false
+  const results = verifyPackageEntries(pkgPath, { throwIfErrors })
+  console.log('results', results)
+
+  results.entryPoints.forEach(ep => {
+    console.log('\n──────────────────────────────────────────────────────────────')
+    console.log('PATH:  ', ep.path)
+    console.log(`Field:  "${ep.field}"`)
+    console.log(`Valid:  ${ep.valid ? '✅' : '❌'}`)
+    if (ep.sourceFiles) {
+      console.log(`srcFiles: ${ep.sourceFiles.length} files`)
+    }
+    if (ep.error) {
+      console.log(`Error:`)
+      console.log(ep.error.message)
+    }
+    ep.sourceFiles.forEach(dep => {
+      console.log(`- ${dep}`)
+    })
+  })
+  console.log('\n──────────────────────────────────────────────────────────────')
+  console.log(`\nTotal unique dependencies: ${results.sourceFiles.size}`)
+  console.log(`Total errors: ${results.errors.length}`)
+}

package/tests/verify-package-entries.test.js

@@ -0,0 +1,272 @@
+// Test package.json entry point verification
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const path = require('path')
+const { getPackageEntryPoints, verifyPackageEntries, collectEntryPoints } = require('../src/verify-package-entries')
+
+const CJS_EXAMPLE_PKG = path.resolve(__dirname, './fixtures/cjs-example/package.json')
+const ESM_FIXTURE_PKG = path.resolve(__dirname, './fixtures/esm-fixture/package.json')
+const CJS_DEEP_EXAMPLE_PKG = path.resolve(__dirname, './fixtures/cjs-deep-example/package.json')
+
+const packageStub = {
+  "name": "my-package",
+  "version": "1.0.0",
+  "description": "Example package with all entry points",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "browser": "./dist/browser.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "my-cli": "./bin/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "browser": "./dist/browser.js"
+    },
+    "./dep-graph": "./src/dep-graph.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ]
+}
+
+test('getPackageEntryPoints should extract all entry points from package.json', () => {
+  const entryPoints = collectEntryPoints(packageStub, 'dir-path')
+  console.log('entryPoints', entryPoints)
+  assert.ok(Array.isArray(entryPoints), 'Should return an array')
+  assert.ok(entryPoints.length > 0, 'Should have at least one entry point')
+})
+
+// getPackageEntryPoints tests
+test('getPackageEntryPoints should extract main field', () => {
+  const entryPoints = getPackageEntryPoints(CJS_EXAMPLE_PKG)
+  console.log('entryPoints', entryPoints)
+
+  assert.ok(Array.isArray(entryPoints), 'Should return an array')
+  assert.ok(entryPoints.length > 0, 'Should have at least one entry point')
+
+  const mainEntry = entryPoints.find(ep => ep.field === 'main')
+  assert.ok(mainEntry, 'Should have main entry point')
+  assert.is(mainEntry.path, './index.js', 'Main path should be ./index.js')
+})
+
+test('getPackageEntryPoints should extract multiple fields', () => {
+  const entryPoints = getPackageEntryPoints(ESM_FIXTURE_PKG)
+
+  const fields = entryPoints.map(ep => ep.field)
+  assert.ok(fields.includes('main'), 'Should include main')
+  assert.ok(fields.includes('module'), 'Should include module')
+})
+
+test('getPackageEntryPoints should extract exports field', () => {
+  const entryPoints = getPackageEntryPoints(ESM_FIXTURE_PKG)
+
+  const exportsEntry = entryPoints.find(ep => ep.field.startsWith('exports'))
+  assert.ok(exportsEntry, 'Should have exports entry point')
+})
+
+test('getPackageEntryPoints should handle complex exports with conditionals', () => {
+  const entryPoints = getPackageEntryPoints(CJS_DEEP_EXAMPLE_PKG)
+
+  const fields = entryPoints.map(ep => ep.field)
+
+  // Should extract conditional exports
+  assert.ok(fields.some(f => f.includes('require')), 'Should extract require conditional')
+  assert.ok(fields.some(f => f.includes('import')), 'Should extract import conditional')
+})
+
+test('getPackageEntryPoints should skip .d.ts files', () => {
+  const entryPoints = getPackageEntryPoints(ESM_FIXTURE_PKG)
+
+  const hasDts = entryPoints.some(ep => ep.path.endsWith('.d.ts'))
+  assert.not(hasDts, 'Should not include .d.ts files')
+})
+
+test('getPackageEntryPoints should skip .json files', () => {
+  const entryPoints = getPackageEntryPoints(ESM_FIXTURE_PKG)
+
+  const hasJson = entryPoints.some(ep => ep.path.endsWith('.json'))
+  assert.not(hasJson, 'Should not include .json files')
+})
+
+test('getPackageEntryPoints should resolve absolute paths', () => {
+  const entryPoints = getPackageEntryPoints(CJS_EXAMPLE_PKG)
+
+  entryPoints.forEach(ep => {
+    assert.ok(path.isAbsolute(ep.resolvedPath), 'Resolved path should be absolute')
+  })
+})
+
+test('getPackageEntryPoints should extract nested exports', () => {
+  const entryPoints = getPackageEntryPoints(CJS_DEEP_EXAMPLE_PKG)
+
+  const fields = entryPoints.map(ep => ep.field)
+
+  // Should have nested paths like exports./one, exports./sub
+  assert.ok(fields.some(f => f.includes('one')), 'Should extract nested export "./one"')
+  assert.ok(fields.some(f => f.includes('sub')), 'Should extract nested export "./sub"')
+})
+
+// verifyPackageEntries tests
+test('verifyPackageEntries should return correct structure', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+  console.log('results', results)
+
+  assert.ok(results.entryPoints, 'Should have entryPoints')
+  assert.ok(results.sourceFiles, 'Should have sourceFiles')
+  assert.ok(results.errors, 'Should have errors')
+
+  assert.ok(Array.isArray(results.entryPoints), 'entryPoints should be array')
+  assert.ok(results.sourceFiles instanceof Set, 'sourceFiles should be Set')
+  assert.ok(Array.isArray(results.errors), 'errors should be array')
+})
+
+test('verifyPackageEntries should verify valid entry points', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+
+  const validCount = results.entryPoints.filter(ep => ep.valid).length
+  assert.ok(validCount > 0, 'Should have at least one valid entry point')
+})
+
+test('verifyPackageEntries should collect dependencies by default', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+
+  results.entryPoints.forEach(ep => {
+    if (ep.valid) {
+      assert.ok(ep.sourceFiles, 'Valid entry should have sourceFiles')
+      assert.ok(Array.isArray(ep.sourceFiles), 'sourceFiles should be array')
+    }
+  })
+})
+
+test('verifyPackageEntries should deduplicate dependencies in sourceFiles', () => {
+  const results = verifyPackageEntries(CJS_DEEP_EXAMPLE_PKG)
+
+  // Count total sourceFiles from all entry points
+  let totalDeps = 0
+  results.entryPoints.forEach(ep => {
+    if (ep.sourceFiles) {
+      totalDeps += ep.sourceFiles.length
+    }
+  })
+
+  // sourceFiles should be less than or equal to total (deduplication)
+  assert.ok(results.sourceFiles.size <= totalDeps, 'sourceFiles should deduplicate')
+})
+
+test('verifyPackageEntries should work with collectDeps option', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG, { collectDeps: true })
+
+  assert.ok(results.sourceFiles.size > 0, 'Should collect dependencies')
+})
+
+test('verifyPackageEntries should skip sourceFiles when collectDeps is false', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG, { collectDeps: false })
+  console.log('results', results)
+  results.entryPoints.forEach(ep => {
+    console.log('ep', ep)
+    assert.equal(ep.sourceFiles, [], 'Should not collect sourceFiles when collectDeps is false')
+  })
+
+  assert.is(results.sourceFiles.size, 0, 'sourceFiles should be empty')
+})
+
+test('verifyPackageEntries should work with verifyGraph option', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG, { verifyGraph: true })
+
+  // Should complete without throwing
+  assert.ok(results, 'Should return results')
+})
+
+test('verifyPackageEntries should skip verification when verifyGraph is false', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG, { verifyGraph: false })
+
+  // Should still collect sourceFiles but skip verification
+  assert.ok(results.sourceFiles.size > 0, 'Should still collect sourceFiles')
+})
+
+test('verifyPackageEntries should collect all errors', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+
+  // With valid fixtures, should have 0 errors
+  assert.is(results.errors.length, 0, 'Valid fixtures should have no errors')
+})
+
+test('verifyPackageEntries should mark entry as invalid on error', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+
+  results.entryPoints.forEach(ep => {
+    if (!ep.valid) {
+      assert.ok(ep.error, 'Invalid entry should have error')
+    }
+  })
+})
+
+test('verifyPackageEntries should process all entries even if one fails', () => {
+  const results = verifyPackageEntries(CJS_DEEP_EXAMPLE_PKG)
+
+  // Should process all 6 entry points from deep example
+  assert.ok(results.entryPoints.length >= 6, 'Should process all entry points')
+})
+
+test('verifyPackageEntries should collect sourceFiles for each entry separately', () => {
+  const results = verifyPackageEntries(CJS_DEEP_EXAMPLE_PKG)
+
+  const validEntries = results.entryPoints.filter(ep => ep.valid)
+
+  validEntries.forEach(ep => {
+    assert.ok(ep.sourceFiles, 'Each entry should have its own sourceFiles')
+    assert.ok(Array.isArray(ep.sourceFiles), 'sourceFiles should be array')
+    assert.ok(ep.sourceFiles.length > 0, 'sourceFiles should not be empty')
+  })
+})
+
+test('verifyPackageEntries should work with simple package', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+
+  assert.is(results.errors.length, 0, 'Should have no errors')
+  assert.ok(results.sourceFiles.size > 0, 'Should have dependencies')
+})
+
+test('verifyPackageEntries should work with ESM package', () => {
+  const results = verifyPackageEntries(ESM_FIXTURE_PKG)
+
+  assert.is(results.errors.length, 0, 'Should have no errors')
+  assert.ok(results.sourceFiles.size > 0, 'Should have dependencies')
+})
+
+test('verifyPackageEntries should work with complex package', () => {
+  const results = verifyPackageEntries(CJS_DEEP_EXAMPLE_PKG)
+
+  assert.is(results.errors.length, 0, 'Should have no errors')
+  assert.ok(results.sourceFiles.size > 0, 'Should have dependencies')
+  assert.ok(results.entryPoints.length >= 6, 'Should have multiple entry points')
+})
+
+test('verifyPackageEntries should include entry point file in sourceFiles', () => {
+  const results = verifyPackageEntries(CJS_EXAMPLE_PKG)
+
+  const mainEntry = results.entryPoints.find(ep => ep.field === 'main')
+  assert.ok(mainEntry, 'Should have main entry')
+  assert.ok(mainEntry.sourceFiles, 'Should have sourceFiles')
+
+  // Entry point file should be in its sourceFiles (as it's the last file in build order)
+  const hasEntryInDeps = mainEntry.sourceFiles.some(dep => dep === mainEntry.resolvedPath)
+  assert.ok(hasEntryInDeps, 'Entry point should be in its own sourceFiles list')
+})
+
+test('verifyPackageEntries should collect unique sourceFiles across all entries', () => {
+  const results = verifyPackageEntries(CJS_DEEP_EXAMPLE_PKG)
+
+  const sourceFilesArray = Array.from(results.sourceFiles)
+  const uniqueDeps = [...new Set(sourceFilesArray)]
+
+  assert.is(sourceFilesArray.length, uniqueDeps.length, 'sourceFiles should not have duplicates')
+})
+
+test.run()

package/types/dep-graph.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Build dependency graph for a file and its dependencies
+ * @param {string} filePath - File to analyze
+ * @param {object} options - Options
+ * @param {boolean} [options.buildGraph] - If true, build and return dependency graph. Default: true
+ * @param {boolean} [options.verifyGraph] - If true, verify imports/exports. Default: true
+ * @param {boolean} [options.throwOnFirstError] - If true, throw immediately on first error. Default: false
+ * @returns {Map<string, string[]>|undefined} - Dependency graph where keys are file paths and values are arrays of dependency paths. Returns undefined if buildGraph is false.
+ */
+export function depGraph(filePath: string, options?: {
+    buildGraph?: boolean;
+    verifyGraph?: boolean;
+    throwOnFirstError?: boolean;
+}): Map<string, string[]> | undefined;
+/**
+ * Get all dependency file paths in build order (dependencies first), deduplicated
+ * @param {string} filePath - Entry file path
+ * @param {object} options - Options to pass to depGraph
+ * @returns {string[]} - Array of unique dependency file paths in topological order
+ */
+export function resolveDepPaths(filePath: string, options?: object): string[];
+//# sourceMappingURL=dep-graph.d.ts.map

package/types/dep-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dep-graph.d.ts","sourceRoot":"","sources":["../src/dep-graph.js"],"names":[],"mappings":"AA+LA;;;;;;;;GAQG;AACH,mCAPW,MAAM;IAEY,UAAU,GAA5B,OAAO;IACW,WAAW,GAA7B,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACL,IAAI,MAAM,EAAE,MAAM,EAAE,CAAC,GAAC,SAAS,CAiB3C;AAGD;;;;;GAKG;AACH,0CAJW,MAAM,YACN,MAAM,GACJ,MAAM,EAAE,CAsCpB"}

package/types/get-cjs-exports.d.ts

@@ -0,0 +1,35 @@
+export function getCjsExports(code: any): any[];
+export function getModuleExportsAssignment(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportDefinitionName: any;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getModuleExportsProperty(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getExportsProperty(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+export function getObjectAssignExports(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportValue: string;
+    index: number;
+    isExport: boolean;
+}[];
+//# sourceMappingURL=get-cjs-exports.d.ts.map

package/types/get-cjs-exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-cjs-exports.d.ts","sourceRoot":"","sources":["../src/get-cjs-exports.js"],"names":[],"mappings":"AA+BA,gDAuBC;AA+BD;;;;;;;;IAqGC;AAED;;;;;;;IAqBC;AAED;;;;;;;IAqBC;AAED;;;;;;;IAiDC"}

package/types/get-exports.d.ts

@@ -2,7 +2,8 @@ export function getExports(code: any, options?: {}): any[];
 export function getDefaultExports(targetText?: string): {
     line: string;
     exportType: string;
-    exportName: any;
+    exportName: string;
+    exportDefinitionName: any;
     exportValue: string;
     index: number;
     isExport: boolean;
@@ -42,6 +43,7 @@ export function getAssertionExports(targetText?: string): {
     exportType: string;
     exportName: string;
     definitions: any;
+    keys: any;
     from: string;
     assertion: string;
     assertionType: string;

package/types/get-exports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-exports.d.ts","sourceRoot":"","sources":["../src/get-exports.js"],"names":[],"mappings":"AAiBA,2DAsBC;AAED;;;;;;;IA4BC;AAED;;;;;;IAeC;AAED,uEAmBC;AAED;;;;;;IAeC;AAED;;;;;;;IAgBC;AAED;;;;;;IAeC;AAED;;;;;;;;;;;IAuBC"}
+{"version":3,"file":"get-exports.d.ts","sourceRoot":"","sources":["../src/get-exports.js"],"names":[],"mappings":"AAiBA,2DA+BC;AAED;;;;;;;;IAqDC;AAED;;;;;;IAeC;AAED,uEAuBC;AAED;;;;;;IAeC;AAED;;;;;;;IAgBC;AAED;;;;;;IAeC;AAED;;;;;;;;;;;;IA0BC"}

package/types/index.d.ts

@@ -1,4 +1,4 @@
-export function extractDeps(code: any): {
+export function extractDeps(code: any, filePath?: string): {
     imports: {
         line: string;
         varType: string;
@@ -9,6 +9,7 @@ export function extractDeps(code: any): {
         isImport: boolean;
         isRelative: boolean;
     }[];
+    exports: any[];
     requires: {
         line: string;
         varType: string;
@@ -20,8 +21,11 @@ export function extractDeps(code: any): {
         isRelative: boolean;
         isDynamic: boolean;
     }[];
-    exports: any[];
+    moduleExports: any[];
 };
+import { hasESMSyntax } from "./detect-syntax";
+import { hasCJSSyntax } from "./detect-syntax";
+import { detectSyntax } from "./detect-syntax";
 import { getRequires } from "./get-requires";
 import { getDynamicRequires } from "./get-requires";
 import { getStaticRequires } from "./get-requires";
@@ -35,5 +39,5 @@ import { getNamedDeclarationExports } from "./get-exports";
 import { getAllExports } from "./get-exports";
 import { getNamespaceExports } from "./get-exports";
 import { getTypeExports } from "./get-exports";
-export { getRequires, getDynamicRequires, getStaticRequires, getImports, getStaticImports, getDynamicImports, getExports, getDefaultExports, getNamedExports, getNamedDeclarationExports, getAllExports, getNamespaceExports, getTypeExports };
+export { hasESMSyntax, hasCJSSyntax, detectSyntax, getRequires, getDynamicRequires, getStaticRequires, getImports, getStaticImports, getDynamicImports, getExports, getDefaultExports, getNamedExports, getNamedDeclarationExports, getAllExports, getNamespaceExports, getTypeExports };
 //# sourceMappingURL=index.d.ts.map