vike 0.4.228-commit-4bed128 → 0.4.228-commit-84954ae

package/dist/esm/utils/requireResolve.js

@@ -1,7 +1,8 @@
-export { requireResolve };
 export { requireResolveOptional };
-export { requireResolveNonUserFile };
-export { requireResolveOptionalNonUserFile };
+export { requireResolveOptionalDir };
+export { requireResolveNpmPackage };
+export { requireResolveVikeDistFile };
+export { getVikeNodeModulesRoot };
 import { assert } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 import { assertIsNotProductionRuntime } from './assertSetup.js';
@@ -9,68 +10,94 @@ import { assertPosixPath, toPosixPath } from './path.js';
 import { scriptFileExtensionList } from './isScriptFile.js';
 import { createRequire } from 'node:module';
 import path from 'node:path';
+import { assertIsImportPathNpmPackage, isImportPathNpmPackageOrPathAlias } from './parseNpmPackage.js';
 // @ts-ignore import.meta.url is shimmed at dist/cjs by dist-cjs-fixup.js.
 const importMetaUrl = import.meta.url;
-const require_ = createRequire(importMetaUrl);
 assertIsNotBrowser();
 assertIsNotProductionRuntime();
-function requireResolve_(importPath, cwd, options) {
-    assertPosixPath(cwd);
+function requireResolve_(importPath, importerFile, options) {
+    assertPosixPath(importerFile);
     assertPosixPath(importPath);
-    cwd = resolveCwd(cwd);
-    let clean = () => { };
+    assertPosixPath(importMetaUrl);
+    assert(path.posix.basename(importerFile).includes('.'), { cwd: importerFile });
+    const importerPath = addFilePrefix(importerFile);
+    const require_ = createRequire(importerPath);
     if (!options?.doNotHandleFileExtension) {
-        clean = addFileExtensionsToRequireResolve();
+        addFileExtensionsToRequireResolve(require_);
         importPath = removeFileExtention(importPath);
     }
+    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: [cwd] });
+        importedFile = require_.resolve(importPath, { paths });
     }
     catch (err) {
-        clean();
         return { importedFile: undefined, err, hasFailed: true };
     }
-    clean();
     importedFile = toPosixPath(importedFile);
     return { importedFile, err: undefined, hasFailed: false };
 }
-function requireResolveOptional(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd);
+function requireResolveOptional({ importPath, importerFile, userRootDir }) {
+    const paths = getExtraPathsForNpmPackageImport({ importPath, userRootDir });
+    const res = requireResolve_(importPath, importerFile, { paths });
     if (res.hasFailed)
         return null;
     return res.importedFile;
 }
-function requireResolveOptionalNonUserFile(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd, { doNotHandleFileExtension: true });
+function requireResolveOptionalDir({ importPath, importerDir, userRootDir }) {
+    const importerFile = getFakeFilePath(importerDir);
+    const paths = getExtraPathsForNpmPackageImport({ importPath, userRootDir });
+    const res = requireResolve_(importPath, importerFile, { paths });
     if (res.hasFailed)
         return null;
     return res.importedFile;
 }
-function requireResolveNonUserFile(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd, { doNotHandleFileExtension: true });
+function requireResolveNpmPackage({ importPathNpmPackage, userRootDir }) {
+    assertIsImportPathNpmPackage(importPathNpmPackage);
+    const importerFile = getFakeFilePath(userRootDir);
+    const paths = getExtraPathsForNpmPackageImport({ importPath: importPathNpmPackage, userRootDir });
+    const res = requireResolve_(importPathNpmPackage, importerFile, { paths });
     if (res.hasFailed)
         throw res.err;
     return res.importedFile;
 }
-function requireResolve(importPath, cwd) {
-    const res = requireResolve_(importPath, cwd);
-    if (res.hasFailed)
-        throw res.err;
-    return res.importedFile;
+function requireResolveVikeDistFile(vikeDistFile) {
+    const vikeNodeModulesRoot = getVikeNodeModulesRoot();
+    assertPosixPath(vikeNodeModulesRoot);
+    assertPosixPath(vikeDistFile);
+    const importedFile = 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 });
+        if (res.hasFailed)
+            throw res.err;
+        assert(res.importedFile === importedFile);
+    }
+    return importedFile;
 }
-function resolveCwd(cwd) {
-    let prefix = 'file://';
-    if (process.platform === 'win32')
-        prefix += '/';
-    if (cwd.startsWith(prefix)) {
-        cwd = cwd.slice(prefix.length);
-        cwd = path.posix.dirname(cwd);
+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;
     }
-    assert(!cwd.startsWith('file:'));
-    return cwd;
+    const paths = [
+        // 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;
 }
 function removeFileExtention(importPath) {
     // Skip for Bun: https://github.com/vikejs/vike/issues/2204
@@ -88,7 +115,7 @@ function removeFileExtention(importPath) {
     }
     return importPath;
 }
-function addFileExtensionsToRequireResolve() {
+function addFileExtensionsToRequireResolve(require_) {
     const added = [];
     scriptFileExtensionList.forEach((ext) => {
         assert(!ext.includes('.'));
@@ -98,10 +125,42 @@ function addFileExtensionsToRequireResolve() {
             added.push(ext);
         }
     });
-    const clean = () => {
-        added.forEach((ext) => {
-            delete require_.extensions[ext];
-        });
-    };
-    return clean;
+}
+function getVikeNodeModulesRoot() {
+    // [RELATIVE_PATH_FROM_DIST] Current file: vike/dist/esm/utils/requireResolve.js
+    assert(importMetaUrl.includes('/dist/esm/') || importMetaUrl.includes('/dist/cjs/'));
+    const vikeNodeModulesRoot = path.posix.join(removeFilePrefix(importMetaUrl), '../../../../');
+    return vikeNodeModulesRoot;
+}
+function toDirPath(filePath) {
+    return path.posix.dirname(removeFilePrefix(filePath));
+}
+function getFakeFilePath(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;
+}
+function addFilePrefix(filePath) {
+    const filePrefix = getFilePrefix();
+    if (!filePath.startsWith(filePrefix)) {
+        assert(!filePath.startsWith('file'));
+        filePath = filePrefix + filePath;
+    }
+    assert(filePath.startsWith(filePrefix));
+    return filePath;
+}
+function removeFilePrefix(filePath) {
+    const filePrefix = getFilePrefix();
+    if (filePath.startsWith(filePrefix)) {
+        filePath = filePath.slice(filePrefix.length);
+    }
+    assert(!filePath.startsWith('file'));
+    return filePath;
+}
+function getFilePrefix() {
+    let prefix = 'file://';
+    if (process.platform === 'win32')
+        prefix += '/';
+    return prefix;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.228-commit-4bed128",
+  "version": "0.4.228-commit-84954ae",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

package/dist/esm/utils/isNpmPackage.d.ts

@@ -1,17 +0,0 @@
-export { isNpmPackageImport };
-export { isNpmPackageImport_unreliable };
-export { assertIsNpmPackageImport };
-export { isValidPathAlias };
-export { parse };
-export { isDistinguishable };
-declare function isNpmPackageImport(str: string, { cannotBePathAlias }: {
-    cannotBePathAlias: true;
-}): boolean;
-declare function isNpmPackageImport_unreliable(str: string): boolean;
-declare function assertIsNpmPackageImport(str: string): void;
-declare function isValidPathAlias(alias: string): boolean;
-declare function isDistinguishable(alias: string): boolean;
-declare function parse(str: string | undefined): null | {
-    pkgName: string;
-    importPath: null | string;
-};