vike 0.4.228-commit-8d90991 → 0.4.228-commit-84954ae

package/dist/esm/utils/{isNpmPackage.js → parseNpmPackage.js}

@@ -1,50 +1,50 @@
-export { isNpmPackageImport };
-export { isNpmPackageImport_unreliable };
-export { assertIsNpmPackageImport };
-export { isValidPathAlias };
+export { isImportPathNpmPackage };
+export { isImportPathNpmPackageOrPathAlias };
+export { assertIsImportPathNpmPackage };
+export { isPathAliasRecommended };
 /* Currently not used
 export { isNpmPackageName }
 export { getNpmPackageName }
 export { getNpmPackageImportPath }
 */
 // For ./isNpmPackage.spec.ts
-export { parse };
+export { parseNpmPackage };
 export { isDistinguishable };
 import { assert } from './assert.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
 assertIsNotBrowser();
-function isNpmPackageImport(str, { cannotBePathAlias }) {
+function isImportPathNpmPackage(str, { cannotBePathAlias }) {
     assert(cannotBePathAlias);
-    return isNpmPackageImport_unreliable(str);
+    return isImportPathNpmPackageOrPathAlias(str);
 }
 // We cannot distinguish path aliases that look like npm package imports
-function isNpmPackageImport_unreliable(str) {
-    const res = parse(str);
+function isImportPathNpmPackageOrPathAlias(str) {
+    const res = parseNpmPackage(str);
     return res !== null;
 }
-function assertIsNpmPackageImport(str) {
-    assert(isNpmPackageImport(str, {
-        // If `str` is a path alias that looks like an npm package => assertIsNpmPackageImport() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
+function assertIsImportPathNpmPackage(str) {
+    assert(isImportPathNpmPackage(str, {
+        // If `str` is a path alias that looks like an npm package => assertIsImportPathNpmPackage() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
         cannotBePathAlias: true
     }), str);
 }
 function isNpmPackageName(str) {
-    const res = parse(str);
+    const res = parseNpmPackage(str);
     return res !== null && res.importPath === null;
 }
 function getNpmPackageName(str) {
-    const res = parse(str);
+    const res = parseNpmPackage(str);
     if (!res)
         return null;
     return res.pkgName;
 }
 function getNpmPackageImportPath(str) {
-    const res = parse(str);
+    const res = parseNpmPackage(str);
     if (!res)
         return null;
     return res.importPath;
 }
-function isValidPathAlias(alias) {
+function isPathAliasRecommended(alias) {
     // Cannot be distinguished from npm package names
     if (!isDistinguishable(alias))
         return false;
@@ -60,14 +60,14 @@ function isValidPathAlias(alias) {
     return true;
 }
 function isDistinguishable(alias) {
-    return (parse(alias) === null &&
-        parse(`${alias}fake-path`) === null &&
-        parse(`${alias}/fake-path`) === null &&
-        parse(`${alias}fake/deep/path`) === null &&
-        parse(`${alias}/fake/deep/path`) === null &&
+    return (parseNpmPackage(alias) === null &&
+        parseNpmPackage(`${alias}fake-path`) === null &&
+        parseNpmPackage(`${alias}/fake-path`) === null &&
+        parseNpmPackage(`${alias}fake/deep/path`) === null &&
+        parseNpmPackage(`${alias}/fake/deep/path`) === null &&
         // See note about '-' in ./isNpmPackageName.spec.ts
         // ```ts
-        // expect(parse('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
+        // expect(parseNpmPackage('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
         // ```
         !alias.startsWith('-'));
 }
@@ -75,7 +75,7 @@ function isDistinguishable(alias) {
 //  - https://www.npmjs.com/package/-
 // The correct logic is complex, see https://github.com/npm/validate-npm-package-name
 // We don't need to be accurate: are there npm packages with weird names that are actually being used?
-function parse(str) {
+function parseNpmPackage(str) {
     if (!str)
         return null;
     let scope = null;

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

@@ -11,4 +11,4 @@ declare function pathJoin(path1: string, path2: string): string;
 /**********************/
 declare function toPosixPath(path: string): string;
 declare function assertPosixPath(path: string): void;
-declare function pathIsRelative(importPath: string): boolean;
+declare function pathIsRelative(path: string): boolean;

package/dist/esm/utils/path.js

@@ -42,6 +42,16 @@ function assertPosixPath(path) {
     assert(path);
     assert(!path.includes('\\'), errMsg(path));
 }
-function pathIsRelative(importPath) {
-    return importPath.startsWith('./') || importPath.startsWith('../');
+// See also `import { isImportPathRelative } from './isImportPath.js'`
+function pathIsRelative(path) {
+    assertPosixPath(path);
+    if (path.startsWith('./') || path.startsWith('../')) {
+        return true;
+    }
+    else {
+        /* Not true if `path` starts with a hidden directory  (i.e. a directory with a name that starts with `.`)
+        assert(!path.startsWith('.'))
+        */
+        return false;
+    }
 }

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

@@ -1,8 +1,21 @@
-export { requireResolve };
 export { requireResolveOptional };
-export { requireResolveNonUserFile };
-export { requireResolveOptionalNonUserFile };
-declare function requireResolveOptional(importPath: string, cwd: string): string | null;
-declare function requireResolveOptionalNonUserFile(importPath: string, cwd: string): string | null;
-declare function requireResolveNonUserFile(importPath: string, cwd: string): string;
-declare function requireResolve(importPath: string, cwd: string): string;
+export { requireResolveOptionalDir };
+export { requireResolveNpmPackage };
+export { requireResolveVikeDistFile };
+export { getVikeNodeModulesRoot };
+declare function requireResolveOptional({ importPath, importerFile, userRootDir }: {
+    importPath: string;
+    importerFile: string;
+    userRootDir: string;
+}): string | null;
+declare function requireResolveOptionalDir({ importPath, importerDir, userRootDir }: {
+    importPath: string;
+    importerDir: string;
+    userRootDir: string;
+}): string | null;
+declare function requireResolveNpmPackage({ importPathNpmPackage, userRootDir }: {
+    importPathNpmPackage: string;
+    userRootDir: string;
+}): string;
+declare function requireResolveVikeDistFile(vikeDistFile: `dist/esm/${string}`): string;
+declare function getVikeNodeModulesRoot(): string;

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-8d90991",
+  "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;
-};