Reinstated existsSync approach and added suggested improvements

Author: pabloerhard

lib/get-exports.js

@@ -2,7 +2,7 @@
 
 const getEsmExports = require('./get-esm-exports.js')
 const { parse: parseCjs } = require('cjs-module-lexer')
-const { readFileSync } = require('fs')
+const { readFileSync, existsSync } = require('fs')
 const { builtinModules } = require('module')
 const { fileURLToPath, pathToFileURL } = require('url')
 const { dirname, join } = require('path')
@@ -32,13 +32,9 @@ const urlsBeingProcessed = new Set() // Guard against circular imports.
  * Once the package.json file has been found, we extract the file path from the specifier
  * @param {string} specifier The specifier that is being search for inside the imports object
  * @param {URL|string} fromUrl The url from which the search starts from
- * @returns file to url to file export
+ * @returns object with url and resolvedExport
  */
 function resolvePackageImports (specifier, fromUrl) {
-  if (!specifier.startsWith('#')) {
-    return null
-  }
-
   try {
     const fromPath = fileURLToPath(fromUrl)
     let currentDir = dirname(fromPath)
@@ -47,44 +43,39 @@ function resolvePackageImports (specifier, fromUrl) {
     while (currentDir !== dirname(currentDir)) {
       const packageJsonPath = join(currentDir, 'package.json')
 
-      let packageJson
-      try {
-        packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
-      } catch (error) {
-        if (error.code === 'ENOENT') {
-          currentDir = dirname(currentDir)
-          continue
-        }
-        throw error
-      }
-
-      if (packageJson) {
+      if (existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
         if (packageJson.imports && packageJson.imports[specifier]) {
           const imports = packageJson.imports[specifier]
 
           // Look for path inside packageJson
-          let resolvedPath
+          let resolvedExport
           if (Object.prototype.toString.call(imports) === '[object Object]') {
-            const requireSpecifier = imports.require
-            const importSpecifier = imports.import
+            const requireExport = imports.require
+            const importExport = imports.import
             // look for the possibility of require and import which is standard for CJS/ESM
-            if (requireSpecifier || importSpecifier) {
+            if (requireExport || importExport) {
               // trying to resolve based on order of importance
-              resolvedPath = requireSpecifier.node || requireSpecifier.default || importSpecifier.node || importSpecifier.default
+              resolvedExport = requireExport.node || requireExport.default || importExport.node || importExport.default
             } else if (imports.node || imports.default) {
-              resolvedPath = imports.node || imports.default
+              resolvedExport = imports.node || imports.default
             }
           } else if (typeof imports === 'string') {
-            resolvedPath = imports
+            resolvedExport = imports
           }
 
-          if (resolvedPath) {
-            return pathToFileURL(require.resolve(resolvedPath, { paths: [currentDir] })).href
+          if (resolvedExport) {
+            const url = resolvedExport.startsWith('.')
+              ? pathToFileURL(join(currentDir, resolvedExport))
+              : fromUrl
+            return { url, export: resolvedExport }
           }
         }
         // return if we find a package.json but did not find an import
         return null
       }
+
+      currentDir = dirname(currentDir)
     }
   } catch (error) {
     throw new Error(`Failed to find sub path export: ${specifier}`)
@@ -113,18 +104,19 @@ async function getCjsExports (url, context, parentLoad, source) {
           re = './'
         }
 
-        let newUrl
         // Entries in the import field should always start with #
         if (re.startsWith('#')) {
-          newUrl = resolvePackageImports(re, url)
-          if (!newUrl) {
+          const resolvedSpecifier = resolvePackageImports(re, url)
+          if (!resolvedSpecifier) {
             // Unable to resolve specifier import
             return
           }
-        } else {
-          newUrl = pathToFileURL(require.resolve(re, { paths: [dirname(fileURLToPath(url))] })).href
+          re = resolvedSpecifier.export
+          url = resolvedSpecifier.url
         }
 
+        const newUrl = pathToFileURL(require.resolve(re, { paths: [dirname(fileURLToPath(url))] })).href
+
         if (newUrl.endsWith('.node') || newUrl.endsWith('.json')) {
           return
         }

test/hook/testin-specifier.mjs

@@ -0,0 +1,40 @@
+import { execSync } from 'child_process';
+import { writeFileSync } from 'fs';
+
+const timings = [];
+const command = 'npm run test:single test/hook/specifier-imports.mjs'; // Replace with your actual command
+
+console.log('Running test 100 times...');
+
+for (let i = 1; i <= 100; i++) {
+    process.stdout.write(`\rRun ${i}/100`);
+
+    try {
+        const output = execSync(command, { encoding: 'utf-8' });
+
+        // Extract the milliseconds value
+        const match = output.match(/resolvePackageImports took ([\d.]+) milliseconds/);
+        if (match) {
+            timings.push(parseFloat(match[1]));
+        }
+    } catch (error) {
+        console.error(`\nError on run ${i}:`, error.message);
+    }
+}
+
+console.log('\n\nDone!');
+console.log(`Timings:`, timings);
+
+// Save to file
+writeFileSync('timing-results.txt', timings.join('\n'));
+
+// Calculate statistics
+const avg = timings.reduce((a, b) => a + b, 0) / timings.length;
+const min = Math.min(...timings);
+const max = Math.max(...timings);
+
+console.log(`\nStatistics:`);
+console.log(`Average: ${avg} ms`);
+console.log(`Min: ${min} ms`);
+console.log(`Max: ${max} ms`);
+console.log(`\nResults saved to timing-results.txt`);