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 array with url and resolvedExport
  */
 function resolvePackageImports (specifier, fromUrl) {
-  if (!specifier.startsWith('#')) {
-    return null
-  }
-
   try {
     const fromPath = fileURLToPath(fromUrl)
     let currentDir = dirname(fromPath)
@@ -47,47 +43,42 @@ 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
-          if (Object.prototype.toString.call(imports) === '[object Object]') {
-            const requireSpecifier = imports.require
-            const importSpecifier = imports.import
+          let resolvedExport
+          if (typeof imports === 'object') {
+            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, 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}`)
+    throw new Error(`Failed to find export: ${specifier}`)
   }
 
   return null
@@ -113,18 +104,15 @@ 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) {
-            // Unable to resolve specifier import
-            return
-          }
-        } else {
-          newUrl = pathToFileURL(require.resolve(re, { paths: [dirname(fileURLToPath(url))] })).href
+          const resolved = resolvePackageImports(re, url)
+          if (!resolved) return
+          [url, re] = resolved
         }
 
+        const newUrl = pathToFileURL(require.resolve(re, { paths: [dirname(fileURLToPath(url))] })).href
+
         if (newUrl.endsWith('.node') || newUrl.endsWith('.json')) {
           return
         }