test: add for new node resolver

src/node-resolver.ts

@@ -1,10 +1,12 @@
-import { fileURLToPath, pathToFileURL } from "url";
 import type { NewResolver } from "./types";
 
-import type { ErrnoException } from '@dual-bundle/import-meta-resolve' with { "resolution-mode": "import" };
+import { fileURLToPath, pathToFileURL } from "url";
+import fs from "fs";
+import { createRequire } from "module";
 
-const importMetaResolveExports: typeof import('@dual-bundle/import-meta-resolve', { with: { "resolution-mode": "import" } }) = require('@dual-bundle/import-meta-resolve');
-const { moduleResolve } = importMetaResolveExports;
+import type { ErrnoException, moduleResolve as $moduleResolve } from '@dual-bundle/import-meta-resolve' with { "resolution-mode": "import" };
+const importMetaResolveExports = require('@dual-bundle/import-meta-resolve');
+const moduleResolve = importMetaResolveExports.moduleResolve as typeof $moduleResolve;
 
 interface NodeResolverOptions {
   /**
@@ -45,17 +47,48 @@ export function createNodeResolver({
           conditions,
           preserveSymlinks
         );
+
+        if (found.protocol === 'file:') {
+          if (fs.existsSync(found)) {
+            return {
+              found: true,
+              path: fileURLToPath(found),
+            };
+          }
+        } else if (found.protocol === 'node:' || found.protocol === 'data:') {
+          return {
+            found: true,
+            path: null
+          }
+        }
         return {
-          found: true,
-          path: fileURLToPath(found),
-        };
+          found: false
+        }
       } catch (error) {
-        if (assertErrNoException(error) && error.code === 'ERR_MODULE_NOT_FOUND') {
-          return {
-            found: false,
+        if (assertErrNoException(error)) {
+          if (error.code === 'ERR_MODULE_NOT_FOUND') {
+            return {
+              found: false,
+            }
           }
+          if (error.code === 'ERR_UNSUPPORTED_DIR_IMPORT') {
+            const $require = createRequire(sourceFile);
+            try {
+              const resolved = $require.resolve(modulePath);
+              return {
+                found: true,
+                path: resolved,
+              }
+            } catch {
+              return {
+                found: false,
+              }
+            }
+          }
+        }
+        return {
+          found: false,
         }
-        throw error;
       }
     }
   }

test/node-resolver.spec.ts

@@ -0,0 +1,45 @@
+import path from 'node:path'
+import { cwd } from 'node:process'
+import { createNodeResolver } from '../src/node-resolver';
+
+const resolver = createNodeResolver()
+
+function expectResolve(source: string, expected: boolean | string) {
+  it(`${source} => ${expected}`, () => {
+    try {
+      console.log({ source, expected, requireResolve: require.resolve(source, { paths: [__dirname] }) })
+
+    } catch {
+      console.log({ source, expected, requireResolve: null })
+    }
+    const result = resolver.resolve(source, __filename);
+    console.log({ source, expected, result })
+
+    if (typeof expected === 'string') {
+      expect(result.path).toBe(path.resolve(cwd(), expected))
+    } else {
+      expect(result.found).toBe(expected)
+    }
+  })
+}
+
+describe('builtin', () => {
+  expectResolve('path', true)
+  expectResolve('node:path', true)
+})
+
+describe('modules', () => {
+  expectResolve('jest', true)
+  expectResolve('@sukka/does-not-exists', false)
+})
+
+describe('relative', () => {
+  expectResolve('../package.json', 'package.json')
+  expectResolve('../.github/dependabot.yml', false)
+  expectResolve('../babel.config.js', 'babel.config.js')
+  expectResolve('../test/index.js', 'test/index.js')
+  expectResolve('../test/', 'test/index.js')
+  expectResolve('../test', 'test/index.js')
+
+  expectResolve('../inexistent.js', false)
+})