vike 0.4.165 → 0.4.166-commit-a5e2596

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.d.ts

@@ -1,4 +1,4 @@
 export { crawlPlusFiles };
 declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: string, isDev: boolean): Promise<{
-    filePathRelativeToUserRootDir: string;
+    filePathAbsoluteUserRootDir: string;
 }[]>;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -1,14 +1,14 @@
 export { crawlPlusFiles };
-import { assertPosixPath, assert, toPosixPath, assertWarning, scriptFileExtensionList, scriptFileExtensions, getGlobalObject, humanizeTime } from '../../../../utils.js';
+import { assertPosixPath, assert, toPosixPath, assertWarning, scriptFileExtensionList, scriptFileExtensions, humanizeTime, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove } from '../../../../utils.js';
 import path from 'path';
 import glob from 'fast-glob';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import pc from '@brillout/picocolors';
 const execA = promisify(exec);
-const globalObject = getGlobalObject('crawlPlusFiles.ts', {
-    gitIsMissing: false
-});
+assertIsNotProductionRuntime();
+assertIsSingleModuleInstance('crawlPlusFiles.ts');
+let gitIsNotUsable = false;
 async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
     assertPosixPath(userRootDir);
     assertPosixPath(outDirAbsoluteFilesystem);
@@ -43,14 +43,14 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
     const plusFiles = files.map((p) => {
         p = toPosixPath(p);
         assert(!p.startsWith(userRootDir));
-        const filePathRelativeToUserRootDir = path.posix.join('/', p);
-        return { filePathRelativeToUserRootDir };
+        const filePathAbsoluteUserRootDir = path.posix.join('/', p);
+        return { filePathAbsoluteUserRootDir };
     });
     return plusFiles;
 }
 // Same as fastGlob() but using `$ git ls-files`
 async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
-    if (globalObject.gitIsMissing)
+    if (gitIsNotUsable)
         return null;
     const ignoreAsPatterns = getIgnoreAsPatterns(outDirRelativeFromUserRootDir);
     const ignoreAsFilterFn = getIgnoreAsFilterFn(outDirRelativeFromUserRootDir);
@@ -68,14 +68,14 @@ async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
         ;
         [files, filesDeleted] = await Promise.all([
             // Main command
-            runCmd(cmd, userRootDir),
+            runCmd1(cmd, userRootDir),
             // Get tracked by deleted files
-            runCmd('git ls-files --deleted', userRootDir)
+            runCmd1('git ls-files --deleted', userRootDir)
         ]);
     }
     catch (err) {
-        if (await isGitMissing(userRootDir)) {
-            globalObject.gitIsMissing = true;
+        if (await isGitNotUsable(userRootDir)) {
+            gitIsNotUsable = true;
             return null;
         }
         throw err;
@@ -119,24 +119,53 @@ function getIgnoreAsFilterFn(outDirRelativeFromUserRootDir) {
         !file.includes('.telefunc.') &&
         (outDirRelativeFromUserRootDir === null || !file.startsWith(`${outDirRelativeFromUserRootDir}/`));
 }
-// Whether Git is installed and whether userRootDir is inside a Git repository
-async function isGitMissing(userRootDir) {
-    let res;
-    try {
-        res = await execA('git rev-parse --is-inside-work-tree', { cwd: userRootDir });
+// Whether Git is installed and whether we can use it
+async function isGitNotUsable(userRootDir) {
+    // Check Git version
+    {
+        const res = await runCmd2('git --version', userRootDir);
+        if ('err' in res)
+            return true;
+        let { stdout, stderr } = res;
+        assert(stderr === '');
+        const prefix = 'git version ';
+        assert(stdout.startsWith(prefix));
+        const gitVersion = stdout.slice(prefix.length);
+        //  - Works with Git 2.43.1 but also (most certainly) with earlier versions.
+        //    - We didn't bother test which is the earliest verision that works.
+        //  - Git 2.32.0 doesn't seem to work: https://github.com/vikejs/vike/discussions/1549
+        //    - Maybe it's because of StackBlitz: looking at the release notes, Git 2.32.0 should be working.
+        if (!isVersionOrAbove(gitVersion, '2.43.1'))
+            return true;
     }
-    catch {
-        return true;
+    // Is userRootDir inside a Git repository?
+    {
+        const res = await runCmd2('git rev-parse --is-inside-work-tree', userRootDir);
+        if ('err' in res)
+            return true;
+        let { stdout, stderr } = res;
+        assert(stderr === '');
+        assert(stdout === 'true');
+        return false;
     }
-    const { stdout, stderr } = res;
-    assert(stderr.toString().trim() === '');
-    assert(stdout.toString().trim() === 'true');
-    return false;
 }
-async function runCmd(cmd, cwd) {
-    const res = await execA(cmd, { cwd });
+async function runCmd1(cmd, cwd) {
+    const { stdout } = await execA(cmd, { cwd });
     /* Not always true: https://github.com/vikejs/vike/issues/1440#issuecomment-1892831303
     assert(res.stderr === '')
     */
-    return res.stdout.toString().split('\n').filter(Boolean);
+    return stdout.toString().split('\n').filter(Boolean);
+}
+async function runCmd2(cmd, cwd) {
+    let res;
+    try {
+        res = await execA(cmd, { cwd });
+    }
+    catch (err) {
+        return { err };
+    }
+    let { stdout, stderr } = res;
+    stdout = stdout.toString().trim();
+    stderr = stderr.toString().trim();
+    return { stdout, stderr };
 }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.d.ts

@@ -39,7 +39,7 @@ type LocationId = string & {
  *
  * The value `locationId` is always a user-land path, because Filesystem Routing/Inheritance only applies to the user-land (Vike never uses Filesystem Routing/Inheritance for `node_modules/**`).
  */
-declare function getLocationId(filePathRelativeToUserRootDir: string): LocationId;
+declare function getLocationId(filePathAbsoluteUserRootDir: string): LocationId;
 /** Filesystem Routing: get the URL */
 declare function getFilesystemRouteString(locationId: LocationId): string;
 /**

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js

@@ -16,10 +16,10 @@ import { assert, assertPosixPath, higherFirst } from '../../../../utils.js';
  */
 function getLocationId(
 // We always determine `locationId` from a real user-land file: the `locationId` for Vike extensions is the `locationId` of the the user's `+config.js` that extends the Vike extension.
-filePathRelativeToUserRootDir) {
-    assertPosixPath(filePathRelativeToUserRootDir);
-    assert(filePathRelativeToUserRootDir.startsWith('/'));
-    const locationId = removeFilename(filePathRelativeToUserRootDir);
+filePathAbsoluteUserRootDir) {
+    assertPosixPath(filePathAbsoluteUserRootDir);
+    assert(filePathAbsoluteUserRootDir.startsWith('/'));
+    const locationId = removeFilename(filePathAbsoluteUserRootDir);
     assertLocationId(locationId);
     return locationId;
 }
@@ -96,8 +96,8 @@ function removeDirectories(somePath, removeDirs) {
         somePath = '/';
     return somePath;
 }
-function removeFilename(filePathRelativeToUserRootDir) {
-    const filePathParts = filePathRelativeToUserRootDir.split('/');
+function removeFilename(filePathAbsoluteUserRootDir) {
+    const filePathParts = filePathAbsoluteUserRootDir.split('/');
     {
         const filename = filePathParts.slice(-1)[0];
         assert(filename.includes('.'));

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/loadFileAtConfigTime.d.ts

@@ -3,7 +3,7 @@ export { loadValueFile };
 export { loadConfigFile };
 export type { ImportedFilesLoaded };
 export type { ConfigFile };
-import type { FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
 import type { InterfaceValueFile } from '../getVikeConfig.js';
 type ImportedFilesLoaded = Record<string, Promise<Record<string, unknown>>>;
 type ConfigFile = {

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/loadFileAtConfigTime.js

@@ -2,13 +2,14 @@
 export { loadImportedFile };
 export { loadValueFile };
 export { loadConfigFile };
-import { assertPosixPath, assert, assertUsage, assertWarning, hasProp, assertIsNotProductionRuntime, isNpmPackageImport } from '../../../../utils.js';
+import { assert, assertUsage, assertWarning, hasProp, assertIsNotProductionRuntime, isNpmPackageImport } from '../../../../utils.js';
 import { transpileAndExecuteFile } from './transpileAndExecuteFile.js';
 import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
 import pc from '@brillout/picocolors';
 import { parseImportData } from './transformFileImports.js';
 import { getConfigFileExport } from '../getConfigFileExport.js';
 import { assertImportPath, resolveImportPath } from './resolveImportPath.js';
+import { getFilePathResolved } from '../../../../shared/getFilePath.js';
 assertIsNotProductionRuntime();
 // Load fake import
 async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
@@ -58,21 +59,12 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
     const extendsConfigFiles = [];
     extendsImportData.map((importData) => {
-        const { importPath: importPath } = importData;
+        const { importPath: importPathAbsolute } = importData;
         const filePathAbsoluteFilesystem = resolveImportPath(importData, configFilePath);
         assertImportPath(filePathAbsoluteFilesystem, importData, configFilePath);
-        warnUserLandExtension(importPath, configFilePath);
-        // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
-        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsoluteFilesystem for added clarity
-        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir);
-        const filePathAbsoluteVite = filePathRelativeToUserRootDir ?? importPath;
-        extendsConfigFiles.push({
-            filePathAbsoluteFilesystem,
-            filePathAbsoluteVite,
-            filePathRelativeToUserRootDir,
-            filePathToShowToUser: filePathAbsoluteVite,
-            importPathAbsolute: importPath
-        });
+        warnUserLandExtension(importPathAbsolute, configFilePath);
+        const filePath = getFilePathResolved({ filePathAbsoluteFilesystem, userRootDir, importPathAbsolute });
+        extendsConfigFiles.push(filePath);
     });
     const extendsConfigs = [];
     await Promise.all(extendsConfigFiles.map(async (configFilePath) => {
@@ -83,19 +75,12 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
     return { extendsConfigs, extendsFilePaths };
 }
-function determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir) {
-    assertPosixPath(filePathAbsoluteFilesystem);
-    assertPosixPath(userRootDir);
-    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        return null;
-    }
-    let filePathRelativeToUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
-    if (!filePathRelativeToUserRootDir.startsWith('/'))
-        filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
-    return filePathRelativeToUserRootDir;
-}
 function warnUserLandExtension(importPath, configFilePath) {
-    assertWarning(isNpmPackageImport(importPath), `${configFilePath.filePathToShowToUser} uses ${pc.cyan('extends')} to inherit from ${pc.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this.`, { onlyOnce: true });
+    // We preserve this feature because we may need it for eject
+    assertWarning(isNpmPackageImport(importPath, {
+        // Vike config files don't support path aliases. (If they do one day, then Vike will/should be able to resolve path aliases.)
+        cannotBePathAlias: true
+    }) || importPath.includes('/node_modules/'), `${configFilePath.filePathToShowToUser} uses ${pc.cyan('extends')} to inherit from ${pc.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this.`, { onlyOnce: true });
 }
 function getExtendsImportData(configFileExports, configFilePath) {
     const { filePathToShowToUser } = configFilePath;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveImportPath.d.ts

@@ -2,8 +2,9 @@ export { resolveImport };
 export { resolveImportPath };
 export { assertImportPath };
 export { clearFilesEnvMap };
-import type { ConfigEnvInternal, DefinedAtFileFullInfo, FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { ConfigEnvInternal, DefinedAtFileFullInfo } from '../../../../../../shared/page-configs/PageConfig.js';
 import { type ImportData } from './transformFileImports.js';
+import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
 declare function resolveImport(configValue: unknown, importerFilePath: FilePathResolved, userRootDir: string, configEnv: ConfigEnvInternal, configName: string): null | (DefinedAtFileFullInfo & {
     fileExportName: string;
 });

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveImportPath.js

@@ -6,6 +6,7 @@ import pc from '@brillout/picocolors';
 import { assert, assertPosixPath, assertUsage, deepEqual, requireResolve } from '../../../../utils.js';
 import { parseImportData } from './transformFileImports.js';
 import path from 'path';
+import { getFilePathResolved, getFilePathUnresolved } from '../../../../shared/getFilePath.js';
 const filesEnvMap = new Map();
 function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
     if (typeof configValue !== 'string')
@@ -17,49 +18,44 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
     const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
     assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
     const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
+    let filePath;
     if (importPath.startsWith('.')) {
         // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
         // ```
         // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
         // ```
         assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
-        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
-        const filePath = {
-            filePathAbsoluteFilesystem,
-            filePathRelativeToUserRootDir,
-            filePathAbsoluteVite: filePathRelativeToUserRootDir,
-            filePathToShowToUser: filePathRelativeToUserRootDir,
-            importPathAbsolute: null
-        };
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
+        const filePathAbsoluteUserRootDir = resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
+        filePath = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
     }
     else {
         // importPath can be:
         //  - an npm package import
         //  - a path alias
-        const filePath = {
-            filePathAbsoluteFilesystem,
-            filePathRelativeToUserRootDir: null,
-            filePathAbsoluteVite: importPath,
-            filePathToShowToUser: importPath,
-            importPathAbsolute: importPath
-        };
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
+        if (filePathAbsoluteFilesystem) {
+            filePath = getFilePathResolved({
+                userRootDir,
+                filePathAbsoluteFilesystem,
+                importPathAbsolute: importPath
+            });
+        }
+        else {
+            filePath = getFilePathUnresolved({
+                importPathAbsolute: importPath
+            });
+        }
     }
+    return {
+        ...filePath,
+        fileExportName: exportName,
+        fileExportPathToShowToUser
+    };
 }
-function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
+function resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
     assertPosixPath(userRootDir);
-    let filePathRelativeToUserRootDir;
+    let filePathAbsoluteUserRootDir;
     if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
+        filePathAbsoluteUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
     }
     else {
         assertUsage(false, `${configFilePath.filePathToShowToUser} imports from a relative path ${pc.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
@@ -68,20 +64,21 @@ function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, imp
         // assert(filePathAbsoluteFilesystem.startsWith('/'))
         // filePath = `/@fs${filePathAbsoluteFilesystem}`
         // /*/
-        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem)
-        // assert(filePathRelativeToUserRootDir.startsWith('../'))
-        // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
+        // filePathAbsoluteUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem)
+        // assert(filePathAbsoluteUserRootDir.startsWith('../'))
+        // filePathAbsoluteUserRootDir = '/' + filePathAbsoluteUserRootDir
         // //*/
     }
-    assertPosixPath(filePathRelativeToUserRootDir);
-    assert(filePathRelativeToUserRootDir.startsWith('/'));
-    return filePathRelativeToUserRootDir;
+    assertPosixPath(filePathAbsoluteUserRootDir);
+    assert(filePathAbsoluteUserRootDir.startsWith('/'));
+    return filePathAbsoluteUserRootDir;
 }
 function resolveImportPath(importData, importerFilePath) {
     const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     assertPosixPath(importerFilePathAbsolute);
     const cwd = path.posix.dirname(importerFilePathAbsolute);
-    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer): https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
+    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer)
+    // https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
     // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
     const filePathAbsoluteFilesystem = requireResolve(importData.importPath, cwd);
     return filePathAbsoluteFilesystem;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.d.ts

@@ -3,7 +3,7 @@ export { getConfigBuildErrorFormatted };
 export { getConfigExecutionErrorIntroMsg };
 export { isTmpFile };
 import 'source-map-support/register.js';
-import type { FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { FilePathResolved } from '../../../../../../shared/page-configs/FilePath.js';
 declare function transpileAndExecuteFile(filePath: FilePathResolved, userRootDir: string, isConfigFile: boolean | 'is-extension-config'): Promise<{
     fileExports: Record<string, unknown>;
 }>;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/transpileAndExecuteFile.js

@@ -14,13 +14,12 @@ import 'source-map-support/register.js';
 assertIsNotProductionRuntime();
 const debug = createDebugger('vike:pointer-imports');
 async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
-    const { filePathAbsoluteFilesystem } = filePath;
+    const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     const fileExtension = getFileExtension(filePathAbsoluteFilesystem);
-    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
-    assertUsage(isJavaScriptFile(filePathAbsoluteFilesystem), `${filePathToShowToUser2} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
+    assertUsage(isJavaScriptFile(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
     const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     if (isHeader) {
-        assertWarning(false, `${pc.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUser2} to ${removeHeaderFileExtension(filePathToShowToUser2)} is usually enough, although you may occasionally need to use ${pc.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
+        assertWarning(false, `${pc.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUserResolved} to ${removeHeaderFileExtension(filePathToShowToUserResolved)} is usually enough, although you may occasionally need to use ${pc.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
     }
     if (isConfigFile === 'is-extension-config' && !isHeader && fileExtension.endsWith('js')) {
         // This doesn't track dependencies => we should never use this for user land configs
@@ -35,28 +34,27 @@ async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
     }
 }
 async function transpileFile(filePath, transformImports, userRootDir) {
-    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
-    const { filePathAbsoluteFilesystem } = filePath;
+    const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.add(filePathAbsoluteFilesystem);
     if (debug.isEnabled)
-        debug('transpile', filePathToShowToUser2);
+        debug('transpile', filePathToShowToUserResolved);
     let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports);
     if (debug.isEnabled)
-        debug(`code, post esbuild (${filePathToShowToUser2})`, code);
+        debug(`code, post esbuild (${filePathToShowToUserResolved})`, code);
     let isImportTransformed = false;
     if (transformImports) {
-        const codeMod = transformFileImports(code, filePathToShowToUser2, pointerImports);
+        const codeMod = transformFileImports(code, filePathToShowToUserResolved, pointerImports);
         if (codeMod) {
             code = codeMod;
             isImportTransformed = true;
             if (debug.isEnabled)
-                debug(`code, post transformImports() (${filePathToShowToUser2})`, code);
+                debug(`code, post transformImports() (${filePathToShowToUserResolved})`, code);
         }
     }
     if (!isImportTransformed) {
         if (debug.isEnabled)
-            debug(`code, no transformImports() (${filePathToShowToUser2})`);
+            debug(`code, no transformImports() (${filePathToShowToUserResolved})`);
     }
     return code;
 }
@@ -72,7 +70,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         outfile: path.posix.join(
         // Needed for correct inline source map
         entryFileDir, 
-        // `write: false` => no file is actually be emitted
+        // `write: false` => no file is actually emitted
         'NEVER_EMITTED.js'),
         logLevel: 'silent',
         format: 'esm',
@@ -104,10 +102,10 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                             return;
                         if (args.pluginData?.[useEsbuildResolver])
                             return;
-                        const isImportAbsolute = !args.path.startsWith('.');
                         const { path, ...opts } = args;
                         opts.pluginData = { [useEsbuildResolver]: true };
                         const resolved = await build.resolve(path, opts);
+                        resolved.path = toPosixPath(resolved.path);
                         // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
                         //  - This is temporary, see comment below.
                         const isVikeExtensionConfigImport = resolved.path.endsWith('+config.js');
@@ -122,14 +120,15 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                             //  - For example if esbuild cannot resolve a path alias while Vite can.
                             //    - When tsconfig.js#compilerOptions.paths is set, then esbuild is able to resolve the path alias.
                             resolved.errors.length > 0;
-                        pointerImports_[args.path] = isPointerImport;
+                        pointerImports_[resolved.path] = isPointerImport;
+                        assertPosixPath(resolved.path);
                         const isExternal = isPointerImport ||
-                            // npm package imports that aren't pointer imports (e.g. Vite plugin import)
-                            isImportAbsolute;
+                            // npm package imports that aren't pointer imports (e.g. importing a Vite plugin)
+                            resolved.path.includes('/node_modules/');
                         if (debug.isEnabled)
                             debug('onResolved()', { args, resolved, isPointerImport, isExternal });
                         if (isExternal) {
-                            return { external: true, path: args.path };
+                            return { external: true, path: resolved.path };
                         }
                         else {
                             return resolved;
@@ -292,19 +291,12 @@ function triggerPrepareStackTrace(err) {
     }
 }
 function getErrIntroMsg(operation, filePath) {
-    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
+    const { filePathToShowToUserResolved } = filePath;
     const msg = [
         // prettier ignore
         pc.red(`Failed to ${operation}`),
-        pc.bold(pc.red(filePathToShowToUser2)),
+        pc.bold(pc.red(filePathToShowToUserResolved)),
         pc.red(`because:`)
     ].join(' ');
     return msg;
 }
-/** `filePath.filePathToShowToUser` may show the import path of a package, use `filePathToShowToUser2` instead always show a file path instead. */
-function getFilePathToShowToUser2(filePath) {
-    const { filePathAbsoluteFilesystem, filePathRelativeToUserRootDir } = filePath;
-    const filePathToShowToUser2 = filePathRelativeToUserRootDir || filePathAbsoluteFilesystem;
-    assert(filePathToShowToUser2);
-    return filePathToShowToUser2;
-}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.d.ts

@@ -5,9 +5,10 @@ export { isVikeConfigFile };
 export { isV1Design };
 export type { VikeConfigObject };
 export type { InterfaceValueFile };
-import type { PageConfigGlobalBuildTime, PageConfigBuildTime, FilePathResolved } from '../../../../../shared/page-configs/PageConfig.js';
+import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import { type LocationId } from './getVikeConfig/filesystemRouting.js';
 import type { ResolvedConfig } from 'vite';
+import type { FilePathResolved } from '../../../../../shared/page-configs/FilePath.js';
 type InterfaceFileCommons = {
     locationId: LocationId;
     filePath: FilePathResolved;
@@ -28,6 +29,6 @@ type VikeConfigObject = {
 };
 declare const vikeConfigDependencies: Set<string>;
 declare function reloadVikeConfig(userRootDir: string, outDirRoot: string): void;
-declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: boolean): Promise<VikeConfigObject>;
+declare function getVikeConfig(config: ResolvedConfig, isDev: boolean, tolerateInvalidConfig?: true): Promise<VikeConfigObject>;
 declare function isV1Design(config: ResolvedConfig, isDev: boolean): Promise<boolean>;
 declare function isVikeConfigFile(filePath: string): boolean;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -19,7 +19,7 @@ import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 import { getConfigFileExport } from './getConfigFileExport.js';
 import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig/loadFileAtConfigTime.js';
 import { clearFilesEnvMap, resolveImport } from './getVikeConfig/resolveImportPath.js';
-import { resolveFilePathRelativeToUserRootDir } from './getVikeConfig/resolveFilePath.js';
+import { getFilePathResolved } from '../../../shared/getFilePath.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -62,7 +62,7 @@ async function handleReloadSideEffects() {
         }
     }
 }
-async function getVikeConfig(config, isDev, tolerateInvalidConfig = false) {
+async function getVikeConfig(config, isDev, tolerateInvalidConfig) {
     const { outDirRoot } = getOutDirs(config);
     const userRootDir = config.root;
     if (!vikeConfigPromise) {
@@ -92,11 +92,11 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
     await Promise.all([
         // Config files
         ...configFiles.map(async (filePath) => {
-            const { filePathRelativeToUserRootDir } = filePath;
-            assert(filePathRelativeToUserRootDir);
+            const { filePathAbsoluteUserRootDir } = filePath;
+            assert(filePathAbsoluteUserRootDir);
             const { configFile, extendsConfigs } = await loadConfigFile(filePath, userRootDir, [], false);
-            assert(filePath.filePathRelativeToUserRootDir);
-            const locationId = getLocationId(filePathRelativeToUserRootDir);
+            assert(filePath.filePathAbsoluteUserRootDir);
+            const locationId = getLocationId(filePathAbsoluteUserRootDir);
             const interfaceFile = getInterfaceFileFromConfigFile(configFile, false, locationId);
             interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
             interfaceFilesByLocationId[locationId].push(interfaceFile);
@@ -145,11 +145,11 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
         }),
         // Value files
         ...valueFiles.map(async (filePath) => {
-            const { filePathRelativeToUserRootDir } = filePath;
-            assert(filePathRelativeToUserRootDir);
-            const configName = getConfigName(filePathRelativeToUserRootDir);
+            const { filePathAbsoluteUserRootDir } = filePath;
+            assert(filePathAbsoluteUserRootDir);
+            const configName = getConfigName(filePathAbsoluteUserRootDir);
             assert(configName);
-            const locationId = getLocationId(filePathRelativeToUserRootDir);
+            const locationId = getLocationId(filePathAbsoluteUserRootDir);
             const interfaceFile = {
                 locationId,
                 filePath,
@@ -348,9 +348,9 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
         const interfaceFilesGlobalPaths = [];
         objectEntries(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
             assert(isGlobalLocation(locationId, locationIds));
-            interfaceFiles.forEach(({ filePath: { filePathRelativeToUserRootDir } }) => {
-                if (filePathRelativeToUserRootDir) {
-                    interfaceFilesGlobalPaths.push(filePathRelativeToUserRootDir);
+            interfaceFiles.forEach(({ filePath: { filePathAbsoluteUserRootDir } }) => {
+                if (filePathAbsoluteUserRootDir) {
+                    interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir);
                 }
             });
         });
@@ -459,10 +459,10 @@ async function resolveConfigValueSources(configName, configDef, interfaceFilesRe
 }
 function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
     return lowerFirst((interfaceFile) => {
-        const { filePathRelativeToUserRootDir } = interfaceFile.filePath;
+        const { filePathAbsoluteUserRootDir } = interfaceFile.filePath;
         assert(isInterfaceFileUserLand(interfaceFile));
-        assert(filePathRelativeToUserRootDir);
-        return filePathRelativeToUserRootDir.length;
+        assert(filePathAbsoluteUserRootDir);
+        return filePathAbsoluteUserRootDir.length;
     })(interfaceFile1, interfaceFile2);
 }
 function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName) {
@@ -536,6 +536,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
                 configName !== 'extends') {
                 if (import_.filePathAbsoluteFilesystem) {
                     assert(hasProp(import_, 'filePathAbsoluteFilesystem', 'string')); // Help TS
+                    assert(hasProp(import_, 'filePathToShowToUserResolved', 'string')); // Help TS
                     const fileExport = await loadImportedFile(import_, userRootDir, importedFilesLoaded);
                     configValueSource.value = fileExport;
                 }
@@ -739,7 +740,7 @@ function getComputed(configValueSources, configDefinitions) {
 }
 async function findPlusFiles(userRootDir, outDirRoot, isDev) {
     const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
-    const plusFiles = files.map(({ filePathRelativeToUserRootDir }) => resolveFilePathRelativeToUserRootDir(filePathRelativeToUserRootDir, userRootDir));
+    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }
 function getConfigName(filePath) {
@@ -829,9 +830,9 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     const configDefinedAt = getConfigDefinedAtString('Config', configName, configFilesystemRoutingRoot);
     assertUsage(typeof value === 'string', `${configDefinedAt} should be a string`);
     assertUsage(value.startsWith('/'), `${configDefinedAt} is ${pc.cyan(value)} but it should start with a leading slash ${pc.cyan('/')}`);
-    const { filePathRelativeToUserRootDir } = configFilesystemRoutingRoot.definedAt;
-    assert(filePathRelativeToUserRootDir);
-    const before = getFilesystemRouteString(getLocationId(filePathRelativeToUserRootDir));
+    const { filePathAbsoluteUserRootDir } = configFilesystemRoutingRoot.definedAt;
+    assert(filePathAbsoluteUserRootDir);
+    const before = getFilesystemRouteString(getLocationId(filePathAbsoluteUserRootDir));
     const after = value;
     const filesystemRoutingRootEffect = { before, after };
     return { filesystemRoutingRootEffect, filesystemRoutingRootDefinedAt: configDefinedAt };
@@ -1006,7 +1007,11 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
         // Sort after whether the config value was defined by an npm package
         .sort(makeFirst(([, [source]]) => {
         const { importPathAbsolute } = source.definedAt;
-        return !!importPathAbsolute && isNpmPackageImport(importPathAbsolute);
+        return (!!importPathAbsolute &&
+            isNpmPackageImport(importPathAbsolute, {
+                // Vike config files don't support path aliases. (If they do one day, then Vike will/should be able to resolve path aliases.)
+                cannotBePathAlias: true
+            }));
     }))
         // Sort after the filesystem inheritance of the config value
         .sort(([, [source1]], [, [source2]]) => reverse(sortAfterInheritanceOrder(source1.locationId, source2.locationId, locationIdPage))));