@davidwells/extract-deps 0.1.12 → 0.1.13

package/package.json

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

package/src/dep-graph.js

@@ -6,6 +6,79 @@ const { resolve: resolveImport } = require('@dual-bundle/import-meta-resolve')
 const { extractDepsShared: extractDeps } = require('./index')
 const { isBuiltIn } = require('./utils')
 
+/**
+ * Parsed deps per file, keyed on mtime + size: callers walk the same shared
+ * files for every entry point (and a walk parses each import target twice:
+ * to verify the importer's names, then to recurse). Results are read-only.
+ * @type {Map<string, { key: string, deps: ReturnType<typeof extractDeps> }>}
+ */
+const parseCache = new Map()
+
+/**
+ * @param {string} filePath
+ * @returns {ReturnType<typeof extractDeps>}
+ */
+function readDeps(filePath) {
+  const stat = fs.statSync(filePath)
+  const key = `${stat.mtimeMs}:${stat.size}`
+  const cached = parseCache.get(filePath)
+  if (cached && cached.key === key) return cached.deps
+  const deps = extractDeps(fs.readFileSync(filePath, 'utf8'))
+  parseCache.set(filePath, { key, deps })
+  return deps
+}
+
+/** @type {Map<string, string | null>} `${baseDir}\0${importPath}` -> resolved file (or null) */
+const relativeResolveCache = new Map()
+/** @type {Map<string, { url: string } | { error: Error }>} `${parentDir}\0${specifier}` -> package resolution */
+const packageResolveCache = new Map()
+/** @type {Map<string, string>} path -> realpath */
+const realpathCache = new Map()
+
+/**
+ * fs.realpathSync, memoized per path.
+ * @param {string} filePath
+ * @returns {string}
+ */
+function realpath(filePath) {
+  let real = realpathCache.get(filePath)
+  if (real === undefined) {
+    real = fs.realpathSync(filePath)
+    realpathCache.set(filePath, real)
+  }
+  return real
+}
+
+/**
+ * resolveImport (import-meta-resolve) memoized per importing directory: a
+ * bare specifier resolves the same from every file in one directory.
+ * @param {string} specifier
+ * @param {string} parentPath - Importing file
+ * @returns {string} resolved URL
+ */
+function resolvePackageImport(specifier, parentPath) {
+  const key = `${path.dirname(parentPath)}\0${specifier}`
+  let cached = packageResolveCache.get(key)
+  if (!cached) {
+    try {
+      cached = { url: resolveImport(specifier, pathToFileURL(parentPath).href) }
+    } catch (error) {
+      cached = { error: /** @type {Error} */ (error) }
+    }
+    packageResolveCache.set(key, cached)
+  }
+  if ('error' in cached) throw cached.error
+  return cached.url
+}
+
+/** Drop memoized parses and resolutions (e.g. between runs in a long-lived process). */
+function clearDepGraphCache() {
+  parseCache.clear()
+  relativeResolveCache.clear()
+  packageResolveCache.clear()
+  realpathCache.clear()
+}
+
 function fsExistsSync(path) {
   try {
     fs.accessSync(path, fs.constants.F_OK)
@@ -30,6 +103,21 @@ function isFileSync(filePath) {
  * @returns {string|null} - Resolved file path or null if not found
  */
 function resolveImportPath(baseDir, importPath) {
+  const key = `${baseDir}\0${importPath}`
+  let resolved = relativeResolveCache.get(key)
+  if (resolved === undefined) {
+    resolved = resolveImportPathUncached(baseDir, importPath)
+    relativeResolveCache.set(key, resolved)
+  }
+  return resolved
+}
+
+/**
+ * @param {string} baseDir
+ * @param {string} importPath
+ * @returns {string|null}
+ */
+function resolveImportPathUncached(baseDir, importPath) {
   const possibleExtensions = ['.js', '.mjs', '.ts', '.json', '']
 
   // Try direct file resolution (must be a file, not directory)
@@ -198,7 +286,7 @@ function buildGraphRecursively(
   visited = new Set(),
 ) {
   // Avoid infinite loops
-  const normalizedPath = fs.realpathSync(filePath)
+  const normalizedPath = realpath(filePath)
   if (visited.has(normalizedPath)) {
     return
   }
@@ -210,8 +298,7 @@ function buildGraphRecursively(
   }
 
   // Read and extract deps from this file
-  const content = fs.readFileSync(filePath, 'utf8')
-  const deps = extractDeps(content)
+  const deps = readDeps(filePath)
 
   // Collect all relative dependencies
   const relativeDeps = []
@@ -255,15 +342,14 @@ function buildGraphRecursively(
 
     // Add edge to graph if building
     if (graph !== null) {
-      const normalizedResolvedPath = fs.realpathSync(resolvedPath)
+      const normalizedResolvedPath = realpath(resolvedPath)
       graph.get(normalizedPath).push(normalizedResolvedPath)
     }
 
     // Verify imports if verification is enabled
     if (verify) {
       // Extract deps from the imported file
-      const targetContent = fs.readFileSync(resolvedPath, 'utf8')
-      const targetDeps = extractDeps(targetContent)
+      const targetDeps = readDeps(resolvedPath)
 
       // Verify the imported values are exported
       verifyImportedValuesExist(dep, targetDeps, resolvedPath, filePath, errors, throwOnFirstError)
@@ -282,8 +368,6 @@ function buildGraphRecursively(
 
   // Verify node_modules dependencies if enabled (skip built-ins)
   if (verifyNodeModules && nodeModuleDeps.length > 0) {
-    const parentURL = pathToFileURL(filePath).href
-
     for (const dep of nodeModuleDeps) {
       const { from, line } = dep
 
@@ -295,7 +379,7 @@ function buildGraphRecursively(
       let resolvedPath
       try {
         // resolveImport throws if file doesn't exist
-        const resolved = resolveImport(from, parentURL)
+        const resolved = resolvePackageImport(from, filePath)
         resolvedPath = fileURLToPath(resolved)
       } catch (error) {
         const err = new Error(
@@ -313,8 +397,7 @@ function buildGraphRecursively(
 
       // Verify import/export styles match (only needed for ESM imports)
       if (dep.isESM) {
-        const targetContent = fs.readFileSync(resolvedPath, 'utf8')
-        const targetDeps = extractDeps(targetContent)
+        const targetDeps = readDeps(resolvedPath)
         verifyImportedValuesExist(dep, targetDeps, resolvedPath, filePath, errors, throwOnFirstError)
       }
     }
@@ -470,5 +553,6 @@ if (require.main === module) {
 
 module.exports = {
   depGraph,
-  resolveDepPaths
+  resolveDepPaths,
+  clearDepGraphCache
 }

package/src/get-cjs-exports.js

@@ -41,9 +41,11 @@ function getCjsExports(code) {
   // values) keeps working off the same indices.
   const sanitizedCode = stripCommentsAndStrings(code)
 
-  const assignmentExports = getModuleExportsAssignment(code, sanitizedCode)
-  const modulePropertyExports = getModuleExportsProperty(code, sanitizedCode)
-  const propertyExports = getExportsProperty(code, sanitizedCode)
+  // Their regexes need `module.exports` / `exports` in the sanitized text.
+  const hasModuleExports = sanitizedCode.includes('module.exports')
+  const assignmentExports = hasModuleExports ? getModuleExportsAssignment(code, sanitizedCode) : []
+  const modulePropertyExports = hasModuleExports ? getModuleExportsProperty(code, sanitizedCode) : []
+  const propertyExports = sanitizedCode.includes('exports') ? getExportsProperty(code, sanitizedCode) : []
 
   // Quick pre-checks to avoid expensive regex operations when not needed
   const objectAssignExports = sanitizedCode.includes('Object.assign')

package/src/get-exports.js

@@ -16,6 +16,8 @@ const EXPORT_TYPE_REGEX = /export\s+(?:type|interface)\s+([\w$]+)/gm
 const EXPORT_ASSERTION_REGEX = /export\s+(?:["'\s]*([\w*{}\n\r\t, ]+)from\s*)?["'\s](.*[@\w_-]+)["'\s]+(assert|with)\s*\{([^}]+)\};?$/gm
 
 function getExports(code = '', options = {}) {
+  // Every pattern below needs the word `export`; stripping never adds one.
+  if (!code.includes('export')) return []
   // Comments first, then strings — order matters. Running stripStringContents
   // alone would mis-pair an apostrophe inside a JSDoc comment (`Netlify's …`)
   // with a later quote and shift subsequent backtick pairing, which could

package/src/get-imports.js

@@ -37,6 +37,8 @@ const DYNAMIC_IMPORT_REGEX = /(?:(const|var|let)\s+([\w*{}\n\r\t,:= $]+)\s*=\s*)
 const ASSERTION_IMPORT_REGEX = /(?:^|\n)\s*import\s+(?:["'\s]*([\w*{}\n\r\t, $]+)from\s*)?["'\s]+([^"'`\n;\s]+)\s*["']\s+(assert|with)\s*\{([^}]+)\}/gm
 
 function getImports(code = '', options = {}) {
+  // Every pattern below needs the word `import`; stripping never adds one.
+  if (!code.includes('import')) return []
   // Strip comments FIRST so apostrophes/backticks inside JSDoc text get
   // removed before `stripStringContents` looks for string literals.
   // (Running the two in the opposite order let comment chars masquerade as

package/src/get-requires.js

@@ -105,6 +105,8 @@ function getStaticRequires(targetText = '') {
 }
 
 function getRequires(code) {
+  // Both scanners need the word `require`; stripping never adds one.
+  if (!code.includes('require')) return []
   // Strip comments first, then strings — order matters. `stripComments`
   // alone would mis-eat `//` inside strings; running it first instead means
   // comment chars (incl. apostrophes/backticks inside JSDoc) disappear

package/src/utils.js

@@ -37,8 +37,18 @@ const EMBEDDED_CODE_RE = /\b(?:import|export|require|module\.exports)\b/
 function stripStringContents(code) {
   let output = ''
   let i = 0
+  const special = /[/"'`]/g
 
   while (i < code.length) {
+    // Copy the run of ordinary characters up to the next / or quote in one go.
+    special.lastIndex = i
+    const next = special.exec(code)
+    const stop = next ? next.index : code.length
+    if (stop > i) {
+      output += code.slice(i, stop)
+      i = stop
+      if (i >= code.length) break
+    }
     const char = code[i]
 
     if (char === '/' && isRegexLiteralStart(code, i)) {
@@ -218,8 +228,18 @@ function appendSkippedComment(output, commentText, preserveLength) {
 function stripCommentsImpl(code, { preserveLength = false } = {}) {
   let output = ''
   let i = 0
+  const special = /[/"'`]/g
 
   while (i < code.length) {
+    // Copy the run of ordinary characters up to the next / or quote in one go.
+    special.lastIndex = i
+    const found = special.exec(code)
+    const stop = found ? found.index : code.length
+    if (stop > i) {
+      output += code.slice(i, stop)
+      i = stop
+      if (i >= code.length) break
+    }
     const char = code[i]
     const next = code[i + 1]
 

package/tests/dep-graph.test.js

@@ -2,7 +2,7 @@
 const { test } = require('uvu')
 const assert = require('uvu/assert')
 const path = require('path')
-const { depGraph, resolveDepPaths } = require('../src/dep-graph.js')
+const { depGraph, resolveDepPaths, clearDepGraphCache } = 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')
@@ -727,4 +727,32 @@ test('TS regex exports: resolveDepPaths with returnErrors should have zero error
   assert.is(result.errors.length, 0, 'Should have zero verification errors')
 })
 
+test('memoized walks see edited files and new files after clearDepGraphCache', () => {
+  const fs = require('fs')
+  const os = require('os')
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'dep-graph-memo-')))
+  const entry = path.join(dir, 'index.js')
+  fs.writeFileSync(entry, "const a = require('./a')\nmodule.exports = a")
+  fs.writeFileSync(path.join(dir, 'a.js'), 'module.exports = 1')
+  try {
+    assert.equal(resolveDepPaths(entry).files.map(f => path.basename(f)), ['a.js', 'index.js'])
+    // Edit: a new import. mtime moves, so the file is parsed again.
+    fs.writeFileSync(path.join(dir, 'b.js'), 'module.exports = 2')
+    fs.writeFileSync(entry, "const a = require('./a')\nconst b = require('./b')\nmodule.exports = a + b")
+    const later = new Date(Date.now() + 5000)
+    fs.utimesSync(entry, later, later)
+    assert.equal(resolveDepPaths(entry).files.map(f => path.basename(f)).sort(), ['a.js', 'b.js', 'index.js'])
+    // A missing import stays missing until the cache is cleared.
+    fs.writeFileSync(entry, "const c = require('./c')\nmodule.exports = c")
+    const later2 = new Date(Date.now() + 10000)
+    fs.utimesSync(entry, later2, later2)
+    assert.is(resolveDepPaths(entry, { returnErrors: true }).errors.length, 1)
+    fs.writeFileSync(path.join(dir, 'c.js'), 'module.exports = 3')
+    clearDepGraphCache()
+    assert.is(resolveDepPaths(entry, { returnErrors: true }).errors.length, 0)
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true })
+  }
+})
+
 test.run()