vike 0.4.228-commit-84954ae → 0.4.228-commit-0e9e0f2

package/dist/esm/utils/requireResolve.js

@@ -11,93 +11,117 @@ import { scriptFileExtensionList } from './isScriptFile.js';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { assertIsImportPathNpmPackage, isImportPathNpmPackageOrPathAlias } from './parseNpmPackage.js';
+import { isNotNullish } from './isNullish.js';
 // @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
+assertPosixPath(importMetaUrl);
 assertIsNotBrowser();
 assertIsNotProductionRuntime();
-function requireResolve_(importPath, importerFile, options) {
-    assertPosixPath(importerFile);
+// - We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
+//   - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
+// - Passing context to createRequire(context) isn't equivalent to passing it to the `paths` argument of require.resolve()
+//   - https://github.com/brillout/require-test
+//   - In practice, I guess it doesn't make a difference? It just seems to be small Node.js weirdness.
+// - The argument createRequire(argument) seems to be overriden by the `paths` argument require.resolve()
+//   - For example, passing an empty array to `paths` kills the argument passed to `createRequire()`
+//   - Thus, when `paths` is defined, then the context needs to be passed to both createRequire() as well as the `paths` argument of require.resolve()
+function requireResolve_(importPath, importerFilePath, { userRootDir, doNotHandleFileExtension } = {}) {
     assertPosixPath(importPath);
-    assertPosixPath(importMetaUrl);
-    assert(path.posix.basename(importerFile).includes('.'), { cwd: importerFile });
-    const importerPath = addFilePrefix(importerFile);
-    const require_ = createRequire(importerPath);
-    if (!options?.doNotHandleFileExtension) {
-        addFileExtensionsToRequireResolve(require_);
-        importPath = removeFileExtention(importPath);
+    const contexts = importerFilePath
+        ? [importerFilePath]
+        : [userRootDir ? getFakeImporterFile(userRootDir) : importMetaUrl];
+    addExtraContextForNpmPackageImport(contexts, { importPath, userRootDir });
+    let importPathResolvedFilePath;
+    let failure;
+    for (const context of contexts) {
+        assertPosixPath(context);
+        const require_ = createRequire(ensureFilePrefix(context));
+        if (!doNotHandleFileExtension) {
+            addFileExtensionsToRequireResolve(require_);
+            importPath = removeFileExtention(importPath);
+        }
+        try {
+            importPathResolvedFilePath = require_.resolve(importPath);
+        }
+        catch (err) {
+            /* DEBUG
+            console.log('err', err)
+            console.log('importPath', importPath)
+            console.log('importerFilePath', importerFilePath)
+            console.log('context', context)
+            console.log('importMetaUrl', importMetaUrl)
+            console.log('paths', paths)
+            //*/
+            failure ?? (failure = { err });
+        }
+        if (importPathResolvedFilePath)
+            break;
     }
-    const paths = !options?.paths
-        ? undefined
-        : [
-            // Seems like `importerPath` gets overriden by the `paths` argument, so we add it to `paths`. (For example, passing an empty array to `paths` kills the argument passed to `createRequire()`.)
-            toDirPath(importerFile),
-            ...(options?.paths || [])
-        ];
-    let importedFile;
-    try {
-        // We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
-        // - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
-        importedFile = require_.resolve(importPath, { paths });
+    if (!importPathResolvedFilePath) {
+        assert(failure);
+        return { importPathResolvedFilePath: undefined, err: failure.err, hasFailed: true };
     }
-    catch (err) {
-        return { importedFile: undefined, err, hasFailed: true };
+    else {
+        assert(importPathResolvedFilePath);
+        importPathResolvedFilePath = toPosixPath(importPathResolvedFilePath);
+        return { importPathResolvedFilePath, err: undefined, hasFailed: false };
     }
-    importedFile = toPosixPath(importedFile);
-    return { importedFile, err: undefined, hasFailed: false };
 }
-function requireResolveOptional({ importPath, importerFile, userRootDir }) {
-    const paths = getExtraPathsForNpmPackageImport({ importPath, userRootDir });
-    const res = requireResolve_(importPath, importerFile, { paths });
+function requireResolveOptional({ importPath, importerFilePath, userRootDir }) {
+    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
     if (res.hasFailed)
         return null;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
 function requireResolveOptionalDir({ importPath, importerDir, userRootDir }) {
-    const importerFile = getFakeFilePath(importerDir);
-    const paths = getExtraPathsForNpmPackageImport({ importPath, userRootDir });
-    const res = requireResolve_(importPath, importerFile, { paths });
+    const importerFilePath = getFakeImporterFile(importerDir);
+    const res = requireResolve_(importPath, importerFilePath, { userRootDir });
     if (res.hasFailed)
         return null;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
 function requireResolveNpmPackage({ importPathNpmPackage, userRootDir }) {
     assertIsImportPathNpmPackage(importPathNpmPackage);
-    const importerFile = getFakeFilePath(userRootDir);
-    const paths = getExtraPathsForNpmPackageImport({ importPath: importPathNpmPackage, userRootDir });
-    const res = requireResolve_(importPathNpmPackage, importerFile, { paths });
+    const importerFilePath = getFakeImporterFile(userRootDir);
+    const res = requireResolve_(importPathNpmPackage, importerFilePath, { userRootDir });
     if (res.hasFailed)
         throw res.err;
-    return res.importedFile;
+    return res.importPathResolvedFilePath;
 }
 function requireResolveVikeDistFile(vikeDistFile) {
     const vikeNodeModulesRoot = getVikeNodeModulesRoot();
     assertPosixPath(vikeNodeModulesRoot);
     assertPosixPath(vikeDistFile);
-    const importedFile = path.posix.join(vikeNodeModulesRoot, vikeDistFile);
+    const importPathResolvedFilePath = path.posix.join(vikeNodeModulesRoot, vikeDistFile);
     // Double check
     {
-        const res = requireResolve_(importedFile, 
-        // Passing some dummy context as the context isn't needed since importerFile is already resolved and absolute
-        importMetaUrl, { doNotHandleFileExtension: true });
+        const res = requireResolve_(importPathResolvedFilePath, 
+        // No context needed: importPathResolvedFilePath is already resolved and absolute
+        null, { doNotHandleFileExtension: true });
         if (res.hasFailed)
             throw res.err;
-        assert(res.importedFile === importedFile);
+        assert(res.importPathResolvedFilePath === importPathResolvedFilePath);
     }
-    return importedFile;
+    return importPathResolvedFilePath;
 }
-function getExtraPathsForNpmPackageImport({ importPath, userRootDir }) {
-    if (
-    // Ideally we'd set `paths` only for npm packages, but unfortunately we cannot always disambiguate between npm package imports and path aliases.
-    !isImportPathNpmPackageOrPathAlias(importPath)) {
-        return undefined;
-    }
-    const paths = [
+function addExtraContextForNpmPackageImport(contexts, { importPath, userRootDir }) {
+    // We should add extra context only for npm packages, but unfortunately we cannot always disambiguate between npm package imports and path aliases.
+    if (!isImportPathNpmPackageOrPathAlias(importPath))
+        return;
+    const userRootDirFakeFile = userRootDir && getFakeImporterFile(userRootDir);
+    [
         // Workaround for monorepo resolve issue: https://github.com/vikejs/vike-react/pull/161/commits/dbaa6643e78015ac2797c237552800fef29b72a7
-        userRootDir,
-        // I can't think of a use case where this would be needed, but let's add it to be extra safe
-        toDirPath(importMetaUrl)
-    ];
-    return paths;
+        userRootDirFakeFile,
+        // I can't think of a use case where this would be needed, but let's add one extra last chance to sucessfully resolve some complex monorepo setups
+        importMetaUrl
+    ]
+        .filter(isNotNullish)
+        .forEach((context) => {
+        const alreadyHasContext = contexts.includes(context) || contexts.includes(ensureFilePrefix(context));
+        if (alreadyHasContext)
+            return;
+        contexts.push(context);
+    });
 }
 function removeFileExtention(importPath) {
     // Skip for Bun: https://github.com/vikejs/vike/issues/2204
@@ -132,16 +156,14 @@ function getVikeNodeModulesRoot() {
     const vikeNodeModulesRoot = path.posix.join(removeFilePrefix(importMetaUrl), '../../../../');
     return vikeNodeModulesRoot;
 }
-function toDirPath(filePath) {
-    return path.posix.dirname(removeFilePrefix(filePath));
-}
-function getFakeFilePath(dirPath) {
+function getFakeImporterFile(dirPath) {
     assertPosixPath(dirPath);
-    assert(!dirPath.startsWith('file')); // The file:// prefix is bogus with path.join
-    const filePath = path.posix.join(dirPath, 'fakeFileForNodeResolve.js');
-    return filePath;
+    assert(!dirPath.startsWith('file')); // The file:// prefix is bogus when used with path.posix.join()
+    const importerFilePath = path.posix.join(dirPath, 'fakeFileForNodeResolve.js');
+    return importerFilePath;
 }
-function addFilePrefix(filePath) {
+function ensureFilePrefix(filePath) {
+    assertPosixPath(filePath);
     const filePrefix = getFilePrefix();
     if (!filePath.startsWith(filePrefix)) {
         assert(!filePath.startsWith('file'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.228-commit-84954ae",
+  "version": "0.4.228-commit-0e9e0f2",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -123,7 +123,7 @@
     "@brillout/json-serializer": "^0.5.15",
     "@brillout/picocolors": "^1.0.26",
     "@brillout/require-shim": "^0.1.2",
-    "@brillout/vite-plugin-server-entry": "^0.7.5",
+    "@brillout/vite-plugin-server-entry": "^0.7.8",
     "acorn": "^8.0.0",
     "cac": "^6.0.0",
     "es-module-lexer": "^1.0.0",
@@ -256,7 +256,7 @@
     "react-streaming": "^0.3.47",
     "rimraf": "^5.0.5",
     "typescript": "^5.8.3",
-    "vite": "^6.2.5"
+    "vite": "^6.3.2"
   },
   "scripts": {
     "dev": "tsc --watch",