@davidwells/extract-deps 0.0.7 → 0.0.9

package/.claude/settings.local.json

@@ -7,7 +7,8 @@
       "Bash(npm pack:*)",
       "Bash(tar:*)",
       "Bash(npm install)",
-      "Bash(npm test)"
+      "Bash(npm test)",
+      "Bash(npm test:*)"
     ],
     "deny": [],
     "ask": []

package/examples/verify-basic.js

@@ -15,8 +15,6 @@ try {
   console.error(error.message)
 }
 
-console.log('foo')
-
 console.log('Verifying ESM fixture...')
 try {
   const graph = depGraph(esmFixture)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davidwells/extract-deps",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Get imports and requires from a codebase without AST",
   "main": "src/index.js",
   "exports": {

package/src/dep-graph.js

@@ -132,16 +132,18 @@ function verifyImportedValuesExist(dep, targetDeps, targetPath, sourcePath, erro
  * @param {boolean} throwOnFirstError - Whether to throw immediately on first error
  * @param {boolean} verify - Whether to verify imports/exports
  * @param {boolean} verifyNodeModules - Whether to verify node_modules can be resolved
+ * @param {boolean} includeNodeModules - Whether to include node_modules in the graph
  * @param {Map<string, string[]>|null} graph - Optional map to collect dependency graph
  * @param {Set} visited - Set of already-visited file paths to avoid cycles
  */
 function buildGraphRecursively(
-  filePath, 
-  errors, 
-  throwOnFirstError, 
-  verify, 
-  verifyNodeModules, 
-  graph = null, 
+  filePath,
+  errors,
+  throwOnFirstError,
+  verify,
+  verifyNodeModules,
+  includeNodeModules,
+  graph = null,
   visited = new Set(),
 ) {
   // Avoid infinite loops
@@ -171,7 +173,7 @@ function buildGraphRecursively(
 
   // Collect all non-relative dependencies (node_modules)
   const nodeModuleDeps = []
-  if (verifyNodeModules) {
+  if (verifyNodeModules || includeNodeModules) {
     if (deps.requires && deps.requires.length > 0) {
       nodeModuleDeps.push(...deps.requires.filter(req => !req.isRelative))
     }
@@ -217,7 +219,14 @@ function buildGraphRecursively(
     }
 
     // Recursively process the imported file
-    buildGraphRecursively(resolvedPath, errors, throwOnFirstError, verify, verifyNodeModules, graph, visited)
+    buildGraphRecursively(resolvedPath, errors, throwOnFirstError, verify, verifyNodeModules, includeNodeModules, graph, visited)
+  }
+
+  // Add node_modules to graph if enabled
+  if (includeNodeModules && graph !== null) {
+    for (const dep of nodeModuleDeps) {
+      graph.get(normalizedPath).push(dep.from)
+    }
   }
 
   // Verify node_modules dependencies if enabled
@@ -255,20 +264,22 @@ function buildGraphRecursively(
  * @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.verifyNodeModules] - If true, verify node_modules packages can be resolved. Default: false
+ * @param {boolean} [options.includeNodeModules] - If true, include node_modules package names in the graph. Default: false
  * @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.
+ * @returns {Map<string, string[]>|undefined} - Dependency graph where keys are file paths and values are arrays of dependency paths (or package names if includeNodeModules). Returns undefined if buildGraph is false.
  */
 function depGraph(filePath, options = {}) {
-  const { 
-    buildGraph = true, 
-    verifyGraph = true, 
-    verifyNodeModules = false, 
+  const {
+    buildGraph = true,
+    verifyGraph = true,
+    verifyNodeModules = false,
+    includeNodeModules = false,
     throwOnFirstError = false,
   } = options
   const errors = []
   const graph = buildGraph ? new Map() : null
 
-  buildGraphRecursively(filePath, errors, throwOnFirstError, verifyGraph, verifyNodeModules, graph)
+  buildGraphRecursively(filePath, errors, throwOnFirstError, verifyGraph, verifyNodeModules, includeNodeModules, graph)
 
   if (errors.length > 0) {
     const errorMessage = errors.map((err, idx) => `Dep graph error:\n ${err.message}`).join('\n')
@@ -287,15 +298,27 @@ function depGraph(filePath, options = {}) {
  * 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
+ * @returns {{ files: string[], nodeModules: string[] }} - Object with files in topological order and unique node_modules
  */
 function resolveDepPaths(filePath, options = {}) {
-  const graph = depGraph(filePath, options)
+  const graph = depGraph(filePath, { ...options, includeNodeModules: true })
+
+  // Collect node_modules (non-path strings in dependency arrays)
+  const nodeModulesSet = new Set()
+  for (const deps of graph.values()) {
+    for (const dep of deps) {
+      if (!dep.startsWith('/')) {
+        nodeModulesSet.add(dep)
+      }
+    }
+  }
 
-  // Calculate in-degree (number of dependencies) for each file
+  // Calculate in-degree (number of file dependencies) for each file
   const inDegree = new Map()
   for (const [file, deps] of graph) {
-    inDegree.set(file, deps.length)
+    // Only count file deps, not node_modules
+    const fileDeps = deps.filter(d => d.startsWith('/'))
+    inDegree.set(file, fileDeps.length)
   }
 
   // Queue of files with no dependencies (can be processed first)
@@ -324,14 +347,17 @@ function resolveDepPaths(filePath, options = {}) {
     }
   }
 
-  return buildOrder
+  return {
+    files: buildOrder,
+    nodeModules: Array.from(nodeModulesSet)
+  }
 }
 
 
 if (require.main === module) {
   const entry = path.resolve(__dirname, '../tests/fixtures/cjs-deep-example/index.js')
   const graph = depGraph(entry, {
-    verifyNodeModules: false,
+    includeNodeModules: true,
     throwOnFirstError: true
   })
   console.log('graph', graph)

package/src/index.js

@@ -50,6 +50,19 @@ if (require.main === module) {
   }
   `
 
+  const code2 = `
+// Get users Lambda handler
+import _ from 'lodash'
+
+export async function handler(event, context) {
+  const data = { message: 'get function called' }
+  return {
+    statusCode: 200,
+    body: JSON.stringify(_.omit(data, [])),
+  }
+}
+  `
+
   const failCase = `
 const { test } = require('uvu')
 const assert = require('uvu/assert')
@@ -65,7 +78,7 @@ const config = await import('./config.js')
 const lerna = require('lerna')
 const { execSync, spawnSync } = require('child_process')
 `
-  const result = extractDeps(code)
+  const result = extractDeps(code2)
 
   const { imports, requires } = result
 

package/src/verify-package-entries.js

@@ -149,11 +149,12 @@ function verifyPackageEntries(packagePath, options = {}) {
 
       if (collectDeps) {
         // Collect dependencies using resolveDepPaths
-        const relativeDeps = resolveDepPaths(entryPoint.resolvedPath, { verifyGraph, verifyNodeModules: true })
-        result.sourceFiles = relativeDeps
+        const { files, nodeModules } = resolveDepPaths(entryPoint.resolvedPath, { verifyGraph, verifyNodeModules: true })
+        result.sourceFiles = files
+        result.nodeModules = nodeModules
 
         // Add to sourceFiles set
-        relativeDeps.forEach(dep => sourceFilesSet.add(dep))
+        files.forEach(dep => sourceFilesSet.add(dep))
       } else if (verifyGraph) {
         // Just verify without collecting deps
         depGraph(entryPoint.resolvedPath, { buildGraph: false, verifyGraph: true })

package/tests/dep-graph.test.js

@@ -117,38 +117,39 @@ test('should work with all options combined', () => {
 })
 
 // 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 object with files and nodeModules', () => {
+  const result = resolveDepPaths(CJS_FIXTURE_PATH)
+  assert.ok(Array.isArray(result.files), 'files should be an array')
+  assert.ok(Array.isArray(result.nodeModules), 'nodeModules should be an array')
 })
 
 test('resolveDepPaths should return deduplicated paths', () => {
-  const deps = resolveDepPaths(CJS_DEEP_FIXTURE_PATH)
-  const uniqueDeps = [...new Set(deps)]
+  const { files } = resolveDepPaths(CJS_DEEP_FIXTURE_PATH)
+  const uniqueDeps = [...new Set(files)]
 
-  assert.is(deps.length, uniqueDeps.length, 'Should not have duplicate paths')
+  assert.is(files.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)
+  const { files } = resolveDepPaths(CJS_FIXTURE_PATH)
 
-  assert.is(deps.length, graph.size, 'Should have same number of files as graph')
+  assert.is(files.length, graph.size, 'Should have same number of files as graph')
 
-  // All graph keys should be in deps
+  // All graph keys should be in files
   for (const key of graph.keys()) {
-    assert.ok(deps.includes(key), `Should include ${path.basename(key)}`)
+    assert.ok(files.includes(key), `Should include ${path.basename(key)}`)
   }
 })
 
 test('resolveDepPaths should return paths in topological order (dependencies first)', () => {
-  const deps = resolveDepPaths(CJS_FIXTURE_PATH)
+  const { files } = 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'))
+  const threeIdx = files.findIndex(p => p.includes('three.js'))
+  const twoIdx = files.findIndex(p => p.includes('two.js'))
+  const oneIdx = files.findIndex(p => p.includes('one.js'))
+  const indexIdx = files.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')
@@ -157,45 +158,45 @@ test('resolveDepPaths should return paths in topological order (dependencies fir
 })
 
 test('resolveDepPaths should work with ESM fixtures', () => {
-  const deps = resolveDepPaths(ESM_FIXTURE_PATH)
+  const { files } = resolveDepPaths(ESM_FIXTURE_PATH)
 
-  assert.ok(Array.isArray(deps), 'Should return an array')
-  assert.ok(deps.length > 0, 'Should have dependencies')
+  assert.ok(Array.isArray(files), 'Should return an array')
+  assert.ok(files.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')
+  assert.ok(files.some(p => p.includes('index.js')), 'Should include index.js')
+  assert.ok(files.some(p => p.includes('one.js')), 'Should include one.js')
+  assert.ok(files.some(p => p.includes('two.js')), 'Should include two.js')
+  assert.ok(files.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]
+  const { files } = resolveDepPaths(CJS_FIXTURE_PATH)
+  const lastFile = files[files.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]
+  const { files } = resolveDepPaths(CJS_FIXTURE_PATH)
+  const firstFile = files[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)
+  const { files } = resolveDepPaths(CJS_DEEP_FIXTURE_PATH)
 
   // Should be deduplicated
-  const uniqueDeps = [...new Set(deps)]
-  assert.is(deps.length, uniqueDeps.length, 'Should deduplicate shared dependencies')
+  const uniqueDeps = [...new Set(files)]
+  assert.is(files.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'))
+  const threeIdx = files.findIndex(p => p.includes('d-three.js'))
+  const twoIdx = files.findIndex(p => p.includes('d-two.js'))
+  const twoAIdx = files.findIndex(p => p.includes('d-two-a.js'))
+  const twoBIdx = files.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')
@@ -204,10 +205,10 @@ test('resolveDepPaths should handle complex graphs with shared dependencies', ()
 })
 
 test('resolveDepPaths should pass options to depGraph', () => {
-  const deps = resolveDepPaths(CJS_FIXTURE_PATH, { verifyGraph: false })
+  const { files } = resolveDepPaths(CJS_FIXTURE_PATH, { verifyGraph: false })
 
-  assert.ok(Array.isArray(deps), 'Should work with options')
-  assert.ok(deps.length > 0, 'Should return dependencies')
+  assert.ok(Array.isArray(files), 'Should work with options')
+  assert.ok(files.length > 0, 'Should return dependencies')
 })
 
 // verifyNodeModules tests
@@ -373,13 +374,68 @@ test('should resolve directory import to index.js', () => {
 })
 
 test('resolveDepPaths should work with directory imports', () => {
-  const deps = resolveDepPaths(DIR_INDEX_FIXTURE_PATH)
+  const { files } = resolveDepPaths(DIR_INDEX_FIXTURE_PATH)
 
-  assert.ok(Array.isArray(deps), 'Should return an array')
-  assert.is(deps.length, 2, 'Should have 2 files')
+  assert.ok(Array.isArray(files), 'Should return an array')
+  assert.is(files.length, 2, 'Should have 2 files')
 
-  assert.ok(deps.some(p => p.includes('shared-pkg/index.js')), 'Should include resolved index.js')
-  assert.ok(deps.some(p => p.includes('entry.js')), 'Should include entry.js')
+  assert.ok(files.some(p => p.includes('shared-pkg/index.js')), 'Should include resolved index.js')
+  assert.ok(files.some(p => p.includes('entry.js')), 'Should include entry.js')
+})
+
+test('resolveDepPaths should return nodeModules', () => {
+  const { nodeModules } = resolveDepPaths(CJS_DEEP_FIXTURE_PATH)
+
+  assert.ok(Array.isArray(nodeModules), 'nodeModules should be an array')
+  assert.ok(nodeModules.includes('lodash'), 'Should include lodash')
+})
+
+// includeNodeModules tests
+test('includeNodeModules should default to false', () => {
+  const graph = depGraph(CJS_DEEP_FIXTURE_PATH)
+
+  // Check that no dependency array contains 'lodash'
+  for (const deps of graph.values()) {
+    assert.ok(!deps.includes('lodash'), 'Should not include node_modules by default')
+  }
+})
+
+test('includeNodeModules: true should add package names to graph', () => {
+  const graph = depGraph(CJS_DEEP_FIXTURE_PATH, { includeNodeModules: true })
+
+  // Find index.js which requires lodash
+  const indexPath = Array.from(graph.keys()).find(key => key.includes('cjs-deep-example/index.js'))
+  assert.ok(indexPath, 'Should have index.js in graph')
+
+  const indexDeps = graph.get(indexPath)
+  assert.ok(indexDeps.includes('lodash'), 'Should include lodash in dependencies')
+})
+
+test('includeNodeModules: true should mix package names with file paths', () => {
+  const graph = depGraph(CJS_DEEP_FIXTURE_PATH, { includeNodeModules: true })
+
+  const indexPath = Array.from(graph.keys()).find(key => key.includes('cjs-deep-example/index.js'))
+  const indexDeps = graph.get(indexPath)
+
+  // Should have both relative dep (d-one.js) and node_module (lodash)
+  const hasRelativeDep = indexDeps.some(dep => dep.includes('d-one.js'))
+  const hasNodeModule = indexDeps.includes('lodash')
+
+  assert.ok(hasRelativeDep, 'Should have relative dependency')
+  assert.ok(hasNodeModule, 'Should have node_module dependency')
+})
+
+test('includeNodeModules works independently of verifyNodeModules', () => {
+  // Include but don't verify
+  const graph = depGraph(CJS_DEEP_FIXTURE_PATH, {
+    includeNodeModules: true,
+    verifyNodeModules: false
+  })
+
+  const indexPath = Array.from(graph.keys()).find(key => key.includes('cjs-deep-example/index.js'))
+  const indexDeps = graph.get(indexPath)
+
+  assert.ok(indexDeps.includes('lodash'), 'Should include lodash without verification')
 })
 
 test.run()

package/types/dep-graph.d.ts

@@ -4,19 +4,26 @@
  * @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.verifyNodeModules] - If true, verify node_modules packages can be resolved. Default: false
+ * @param {boolean} [options.includeNodeModules] - If true, include node_modules package names in the graph. Default: false
  * @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.
+ * @returns {Map<string, string[]>|undefined} - Dependency graph where keys are file paths and values are arrays of dependency paths (or package names if includeNodeModules). Returns undefined if buildGraph is false.
  */
 export function depGraph(filePath: string, options?: {
     buildGraph?: boolean;
     verifyGraph?: boolean;
+    verifyNodeModules?: boolean;
+    includeNodeModules?: 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
+ * @returns {{ files: string[], nodeModules: string[] }} - Object with files in topological order and unique node_modules
  */
-export function resolveDepPaths(filePath: string, options?: object): string[];
+export function resolveDepPaths(filePath: string, options?: object): {
+    files: string[];
+    nodeModules: string[];
+};
 //# sourceMappingURL=dep-graph.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"dep-graph.d.ts","sourceRoot":"","sources":["../src/dep-graph.js"],"names":[],"mappings":"AAmQA;;;;;;;;;;GAUG;AACH,mCATW,MAAM,YAEd;IAA0B,UAAU,GAA5B,OAAO;IACW,WAAW,GAA7B,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,kBAAkB,GAApC,OAAO;IACW,iBAAiB,GAAnC,OAAO;CACf,GAAU,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAC,SAAS,CAyB3C;AAGD;;;;;GAKG;AACH,0CAJW,MAAM,YACN,MAAM,GACJ;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,CAqDtD"}

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

@@ -32,4 +32,14 @@ export function getObjectAssignExports(originalText?: string, sanitizedText?: st
     index: number;
     isExport: boolean;
 }[];
+export function getDefinePropertyExports(originalText?: string, sanitizedText?: string): {
+    line: string;
+    exportType: string;
+    exportName: string;
+    exportValue: string;
+    exportDefinitionName: string;
+    index: number;
+    isExport: boolean;
+    isDefineProperty: boolean;
+}[];
 //# sourceMappingURL=get-cjs-exports.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"get-cjs-exports.d.ts","sourceRoot":"","sources":["../src/get-cjs-exports.js"],"names":[],"mappings":"AAoCA,gDAiCC;AA+BD;;;;;;;;IAqGC;AAED;;;;;;;IAqBC;AAED;;;;;;;IAqBC;AAED;;;;;;;IAiDC;AAED;;;;;;;;;IAwEC"}

package/types/get-imports.d.ts

@@ -24,6 +24,7 @@ export function getTypeImports(targetText?: string): {
     importName: string;
     index: number;
     isImport: boolean;
+    isTypeImport: boolean;
     isRelative: boolean;
 }[];
 export function getDynamicImports(targetText?: string): {

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

@@ -1 +1 @@
-{"version":3,"file":"get-imports.d.ts","sourceRoot":"","sources":["../src/get-imports.js"],"names":[],"mappings":"AAWA;;;;;;;;;IAQC;AAGD;;;;;;;;;IAkBC;AAED;;;;;;;IAgBC;AAED;;;;;;;;;;IAoBC;AAED;;;;;;;;;;;;IAwBC"}
+{"version":3,"file":"get-imports.d.ts","sourceRoot":"","sources":["../src/get-imports.js"],"names":[],"mappings":"AAWA;;;;;;;;;IAQC;AAGD;;;;;;;;;IAkBC;AAED;;;;;;;;IAiBC;AAED;;;;;;;;;;IAoBC;AAED;;;;;;;;;;;;IAwBC"}

package/types/vendor/inspect-parameters-declaration.d.ts

@@ -0,0 +1,4 @@
+export function inspectParameters(source: any): any;
+export function getParametersNames(source: any): any;
+export function getParametersNamesFromInspection(inspectedParameters: any): any;
+//# sourceMappingURL=inspect-parameters-declaration.d.ts.map

package/types/vendor/inspect-parameters-declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect-parameters-declaration.d.ts","sourceRoot":"","sources":["../../src/vendor/inspect-parameters-declaration.js"],"names":[],"mappings":"AA0QA,oDAaC;AAtBD,qDAGC;AAED,gFAEC"}

package/types/verify-package-entries.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Extract all entry points from package.json
+ * @param {string} packageJsonPath - Path to package.json
+ * @returns {Array<{field: string, path: string, resolvedPath: string}>} - Array of entry point objects
+ */
+export function getPackageEntryPoints(packageJsonPath: string): Array<{
+    field: string;
+    path: string;
+    resolvedPath: string;
+}>;
+/**
+ * Verify all package.json entry points and collect dependencies
+ * @param {string} packagePath - Path to package.json
+ * @param {object} options - Options
+ * @param {boolean} [options.collectDeps] - If true, collect dependency paths for each entry point. Default: true
+ * @param {boolean} [options.verifyGraph] - If true, verify imports/exports. Default: true
+ * @param {boolean} [options.throwIfErrors] - If true, throw an error if there are any errors. Default: false
+ * @returns {{entryPoints: Array, sourceFiles: Set, errors: Array}} - Verification results
+ */
+export function verifyPackageEntries(packagePath: string, options?: {
+    collectDeps?: boolean;
+    verifyGraph?: boolean;
+    throwIfErrors?: boolean;
+}): {
+    entryPoints: any[];
+    sourceFiles: Set<any>;
+    errors: any[];
+};
+export function collectEntryPoints(packageJson: any, packageDir: any): any[];
+//# sourceMappingURL=verify-package-entries.d.ts.map

package/types/verify-package-entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-package-entries.d.ts","sourceRoot":"","sources":["../src/verify-package-entries.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,uDAHW,MAAM,GACJ,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,CAAC,CAOtE;AAmGD;;;;;;;;GAQG;AACH,kDAPW,MAAM,YAEd;IAA0B,WAAW,GAA7B,OAAO;IACW,WAAW,GAA7B,OAAO;IACW,aAAa,GAA/B,OAAO;CACf,GAAU;IAAC,WAAW,QAAQ;IAAC,WAAW,WAAM;IAAC,MAAM,QAAO;CAAC,CAoEjE;AA5KD,6EA8DC"}