vike 0.4.166 → 0.4.167-commit-14e4b5e

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

@@ -1,12 +1,12 @@
 export { getConfigFileExport };
 import pc from '@brillout/picocolors';
 import { assertPlusFileExport } from '../../../../../shared/page-configs/assertPlusFileExport.js';
-import { assert, assertUsage, isObject } from '../../../utils.js';
+import { assertUsage, isObject } from '../../../utils.js';
 function getConfigFileExport(fileExports, filePathToShowToUser) {
     assertPlusFileExport(fileExports, filePathToShowToUser, 'config');
-    const fileExport = fileExports.default || fileExports.config;
-    assert('default' in fileExports !== 'config' in fileExports);
-    const exportName = pc.cyan('default' in fileExports ? 'export default' : 'export { config }');
+    const usesNamedExport = !!fileExports.config;
+    const fileExport = usesNamedExport ? fileExports.config : fileExports.default;
+    const exportName = pc.cyan(usesNamedExport ? 'export { config }' : 'export default');
     assertUsage(isObject(fileExport), `The ${exportName} of ${filePathToShowToUser} should be an object (but it's ${pc.cyan(`typeof exportedValue === ${JSON.stringify(typeof fileExport)}`)} instead)`);
     return fileExport;
 }

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

@@ -5,6 +5,7 @@ import glob from 'fast-glob';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import pc from '@brillout/picocolors';
+import { isTemporaryBuildFile } from './transpileAndExecuteFile.js';
 const execA = promisify(exec);
 assertIsNotProductionRuntime();
 assertIsSingleModuleInstance('crawlPlusFiles.ts');
@@ -29,6 +30,7 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
     else {
         files = await fastGlob(userRootDir, outDirRelativeFromUserRootDir);
     }
+    files = files.filter((file) => !isTemporaryBuildFile(file));
     {
         const timeAfter = new Date().getTime();
         const timeSpent = timeAfter - timeBefore;

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

@@ -76,7 +76,11 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     return { extendsConfigs, extendsFilePaths };
 }
 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.js

@@ -18,6 +18,7 @@ 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:
         // ```
@@ -25,28 +26,30 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         // ```
         assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
         const filePathAbsoluteUserRootDir = resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
-        const filePath = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir, importPathAbsolute: null });
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
+        filePath = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
     }
     else {
         // importPath can be:
         //  - an npm package import
         //  - a path alias
-        const filePath = getFilePathUnresolved({
-            filePathAbsoluteFilesystem,
-            filePathAbsoluteUserRootDir: null,
-            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_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
     assertPosixPath(userRootDir);
@@ -74,7 +77,8 @@ 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

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

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

@@ -1,7 +1,7 @@
 export { transpileAndExecuteFile };
 export { getConfigBuildErrorFormatted };
 export { getConfigExecutionErrorIntroMsg };
-export { isTmpFile };
+export { isTemporaryBuildFile };
 import { build, formatMessages } from 'esbuild';
 import fs from 'fs';
 import path from 'path';
@@ -37,10 +37,10 @@ async function transpileFile(filePath, transformImports, userRootDir) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    if (debug.isEnabled)
+    if (debug.isActivated)
         debug('transpile', filePathToShowToUserResolved);
     let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports);
-    if (debug.isEnabled)
+    if (debug.isActivated)
         debug(`code, post esbuild (${filePathToShowToUserResolved})`, code);
     let isImportTransformed = false;
     if (transformImports) {
@@ -48,12 +48,12 @@ async function transpileFile(filePath, transformImports, userRootDir) {
         if (codeMod) {
             code = codeMod;
             isImportTransformed = true;
-            if (debug.isEnabled)
+            if (debug.isActivated)
                 debug(`code, post transformImports() (${filePathToShowToUserResolved})`, code);
         }
     }
     if (!isImportTransformed) {
-        if (debug.isEnabled)
+        if (debug.isActivated)
             debug(`code, no transformImports() (${filePathToShowToUserResolved})`);
     }
     return code;
@@ -70,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',
@@ -90,9 +90,11 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
     else {
         const pointerImports_ = (pointerImports = {});
         options.plugins = [
-            // Determine what import should be externalized (and then transformed to a pointer/fake import)
+            // Determine whether an import should be:
+            //  - A pointer import
+            //  - Externalized
             {
-                name: 'vike:externalize-heuristic',
+                name: 'vike-esbuild-plugin',
                 setup(build) {
                     // https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
                     const useEsbuildResolver = 'useEsbuildResolver';
@@ -102,10 +104,19 @@ 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);
+                        if (resolved.errors.length > 0) {
+                            /* We could do the following to let Node.js throw the error, but we don't because the error shown by esbuild is prettier: the Node.js error refers to the transpiled [build-f7i251e0iwnw]+config.ts.mjs file which isn't that nice, whereas esbuild refers to the source +config.ts file.
+                            pointerImports_[args.path] = false
+                            return { external: true }
+                            */
+                            // Let esbuild throw the error. (It throws a nice & pretty error.)
+                            return resolved;
+                        }
+                        assert(resolved.path);
+                        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');
@@ -120,14 +131,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;
-                        if (debug.isEnabled)
+                            // Performance: npm package imports that aren't pointer imports can be externalized. For example, if Vike eventually adds support for setting Vite configs in the vike.config.js file, then the user may import a Vite plugin in his vike.config.js file. (We could as well let esbuild always transpile /node_modules/ code but it would be useless and would unnecessarily slow down transpilation.)
+                            resolved.path.includes('/node_modules/');
+                        if (debug.isActivated)
                             debug('onResolved()', { args, resolved, isPointerImport, isExternal });
                         if (isExternal) {
-                            return { external: true, path: args.path };
+                            return { external: true, path: resolved.path };
                         }
                         else {
                             return resolved;
@@ -185,7 +197,7 @@ async function executeTranspiledFile(filePath, code) {
     const { filePathAbsoluteFilesystem } = filePath;
     // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
     //  - But seems to break source maps, so I don't think it's worth it
-    const filePathTmp = getFilePathTmp(filePathAbsoluteFilesystem);
+    const filePathTmp = getTemporaryBuildFilePath(filePathAbsoluteFilesystem);
     fs.writeFileSync(filePathTmp, code);
     const clean = () => fs.unlinkSync(filePathTmp);
     let fileExports = {};
@@ -242,20 +254,19 @@ function getConfigExecutionErrorIntroMsg(err) {
     const errIntroMsg = execErrIntroMsg.get(err);
     return errIntroMsg ?? null;
 }
-const tmpPrefix = `[build-`;
-function getFilePathTmp(filePathAbsoluteFilesystem) {
+function getTemporaryBuildFilePath(filePathAbsoluteFilesystem) {
     assertPosixPath(filePathAbsoluteFilesystem);
     const dirname = path.posix.dirname(filePathAbsoluteFilesystem);
     const filename = path.posix.basename(filePathAbsoluteFilesystem);
-    // Syntax with semicolon `[build:${/*...*/}]` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
-    const tag = `${tmpPrefix}${getRandomId(12)}]`;
-    const filePathTmp = path.posix.join(dirname, `${tag}${filename}.mjs`);
+    // Syntax with semicolon `build:${/*...*/}` doesn't work on Windows: https://github.com/vikejs/vike/issues/800#issuecomment-1517329455
+    const filePathTmp = path.posix.join(dirname, `${filename}.build-${getRandomId(12)}.mjs`);
+    assert(isTemporaryBuildFile(filePathTmp));
     return filePathTmp;
 }
-function isTmpFile(filePath) {
+function isTemporaryBuildFile(filePath) {
     assertPosixPath(filePath);
     const fileName = path.posix.basename(filePath);
-    return fileName.startsWith(tmpPrefix);
+    return /\.build-[a-z0-9]{12}\.mjs$/.test(fileName);
 }
 function isHeaderFile(filePath) {
     assertPosixPath(filePath);

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

@@ -7,7 +7,7 @@ import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEn
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
-import { isTmpFile } from './getVikeConfig/transpileAndExecuteFile.js';
+import { isTemporaryBuildFile } from './getVikeConfig/transpileAndExecuteFile.js';
 import { isConfigInvalid, isConfigInvalid_set } from '../../../../runtime/renderPage/isConfigInvalid.js';
 import { getViteDevServer } from '../../../../runtime/globalContext.js';
 import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNotProd.js';
@@ -740,12 +740,12 @@ function getComputed(configValueSources, configDefinitions) {
 }
 async function findPlusFiles(userRootDir, outDirRoot, isDev) {
     const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
-    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir, importPathAbsolute: null }));
+    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }
 function getConfigName(filePath) {
     assertPosixPath(filePath);
-    if (isTmpFile(filePath))
+    if (isTemporaryBuildFile(filePath))
         return null;
     const fileName = path.posix.basename(filePath);
     // assertNoUnexpectedPlusSign(filePath, fileName)
@@ -1007,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))));

package/dist/esm/node/plugin/shared/getFilePath.d.ts

@@ -1,20 +1,21 @@
 export { getFilePathResolved };
 export { getFilePathUnresolved };
+export { getModuleFilePath };
+export { getFilePathToShowToUserFromUnkown };
+export { cleanFilePathUnkown };
 import type { FilePath, FilePathResolved } from '../../../shared/page-configs/FilePath.js';
-declare function getFilePathUnresolved(args: {
-    filePathAbsoluteFilesystem: string | null;
-    filePathAbsoluteUserRootDir: string | null;
-    importPathAbsolute: string | null;
-} & ({
-    filePathAbsoluteUserRootDir: string;
-} | {
+import type { ResolvedConfig } from 'vite';
+declare function getFilePathUnresolved({ importPathAbsolute }: {
     importPathAbsolute: string;
-})): FilePath;
+}): FilePath;
 declare function getFilePathResolved(args: {
     userRootDir: string;
-    importPathAbsolute: string | null;
+    importPathAbsolute?: string;
 } & ({
     filePathAbsoluteFilesystem: string;
 } | {
     filePathAbsoluteUserRootDir: string;
 })): FilePathResolved;
+declare function getModuleFilePath(moduleId: string, config: ResolvedConfig): string;
+declare function getFilePathToShowToUserFromUnkown(filePathUnkown: string, userRootDir: string): string;
+declare function cleanFilePathUnkown(filePathUnknown: string): string;

package/dist/esm/node/plugin/shared/getFilePath.js

@@ -1,26 +1,16 @@
 export { getFilePathResolved };
 export { getFilePathUnresolved };
+export { getModuleFilePath };
+export { getFilePathToShowToUserFromUnkown };
+export { cleanFilePathUnkown };
 import path from 'path';
-import { assert, assertPosixPath, hasProp } from '../utils.js';
-function getFilePathUnresolved(args) {
-    const { filePathAbsoluteFilesystem, filePathAbsoluteUserRootDir } = args;
-    let filePathAbsoluteVite;
-    if (args.filePathAbsoluteUserRootDir !== null) {
-        filePathAbsoluteVite = args.filePathAbsoluteUserRootDir;
-    }
-    else {
-        assert(args.importPathAbsolute !== null); // Help TS
-        filePathAbsoluteVite = args.importPathAbsolute;
-    }
-    return {
-        ...args,
-        filePathAbsoluteVite,
-        filePathToShowToUser: filePathAbsoluteVite,
-        filePathToShowToUserResolved: filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem
-    };
+import { assert, assertPathIsFilesystemAbsolute, assertPosixPath, toPosixPath } from '../utils.js';
+function getFilePathUnresolved({ importPathAbsolute }) {
+    return getFilePath({ importPathAbsolute, filePathAbsoluteUserRootDir: null });
 }
 function getFilePathResolved(args) {
-    const { userRootDir, importPathAbsolute } = args;
+    const { userRootDir } = args;
+    const importPathAbsolute = args.importPathAbsolute ?? null;
     let filePathAbsoluteFilesystem;
     let filePathAbsoluteUserRootDir;
     if ('filePathAbsoluteFilesystem' in args) {
@@ -31,40 +21,67 @@ function getFilePathResolved(args) {
         filePathAbsoluteUserRootDir = args.filePathAbsoluteUserRootDir;
         filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir });
     }
-    let filePathResolved;
+    let filePath;
     const common = {
         filePathAbsoluteUserRootDir,
-        filePathAbsoluteFilesystem,
         importPathAbsolute,
         userRootDir
     };
     if (importPathAbsolute) {
-        filePathResolved = getFilePathUnresolved({
+        filePath = getFilePath({
             ...common,
             importPathAbsolute
         });
     }
     else {
         assert(filePathAbsoluteUserRootDir);
-        filePathResolved = getFilePathUnresolved({
+        filePath = getFilePath({
             ...common,
             filePathAbsoluteUserRootDir
         });
     }
     assert(filePathAbsoluteFilesystem);
-    assert(hasProp(filePathResolved, 'filePathAbsoluteFilesystem', 'string'));
-    assert(hasProp(filePathResolved, 'filePathToShowToUserResolved', 'string'));
+    assertPathIsFilesystemAbsolute(filePathAbsoluteFilesystem);
+    const filePathToShowToUserResolved = filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
+    assert(filePathToShowToUserResolved);
+    const filePathResolved = {
+        ...filePath,
+        filePathAbsoluteFilesystem,
+        filePathToShowToUserResolved
+    };
     return filePathResolved;
 }
+function getFilePath(args) {
+    let filePathAbsoluteVite;
+    if (args.filePathAbsoluteUserRootDir !== null) {
+        filePathAbsoluteVite = args.filePathAbsoluteUserRootDir;
+    }
+    else {
+        assert(args.importPathAbsolute !== null); // Help TS
+        filePathAbsoluteVite = args.importPathAbsolute;
+    }
+    const filePathToShowToUser = filePathAbsoluteVite;
+    assert(filePathToShowToUser);
+    return {
+        ...args,
+        filePathAbsoluteFilesystem: null,
+        filePathAbsoluteVite,
+        filePathToShowToUser
+    };
+}
 function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir }) {
     assertPosixPath(filePathAbsoluteUserRootDir);
     assertPosixPath(userRootDir);
+    assertPathIsFilesystemAbsolute(userRootDir);
     const filePathAbsoluteFilesystem = path.posix.join(userRootDir, filePathAbsoluteUserRootDir);
+    assertPathIsFilesystemAbsolute(userRootDir);
     return filePathAbsoluteFilesystem;
 }
 function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }) {
     assertPosixPath(filePathAbsoluteFilesystem);
     assertPosixPath(userRootDir);
+    assertPathIsFilesystemAbsolute(filePathAbsoluteFilesystem);
+    assertPathIsFilesystemAbsolute(userRootDir);
     const filePathRelative = path.posix.relative(userRootDir, filePathAbsoluteFilesystem);
     if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
         assert(filePathRelative.startsWith('../'));
@@ -72,11 +89,48 @@ function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDi
     }
     assert(!filePathRelative.startsWith('.') && !filePathRelative.startsWith('/'));
     const filePathAbsoluteUserRootDir = `/${filePathRelative}`;
-    {
-        let check = filePathAbsoluteFilesystem.slice(userRootDir.length);
-        if (!check.startsWith('/'))
-            check = '/' + check;
-        assert(filePathAbsoluteUserRootDir === check);
+    assert(filePathAbsoluteUserRootDir === getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir));
+    return filePathAbsoluteUserRootDir;
+}
+function getModuleFilePath(moduleId, config) {
+    const userRootDir = config.root;
+    assertPosixPath(moduleId);
+    assertPosixPath(userRootDir);
+    const filePathAbsoluteFilesystem = cleanModuleId(moduleId);
+    assertPathIsFilesystemAbsolute(filePathAbsoluteFilesystem);
+    const filePath = getFilePathResolved({ filePathAbsoluteFilesystem, userRootDir });
+    return filePath.filePathToShowToUserResolved;
+}
+function getFilePathToShowToUserFromUnkown(
+// We don't have any guarentee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
+filePathUnkown, userRootDir) {
+    assertPosixPath(userRootDir);
+    assertPathIsFilesystemAbsolute(userRootDir);
+    filePathUnkown = cleanFilePathUnkown(filePathUnkown);
+    if (!filePathUnkown.startsWith(userRootDir)) {
+        return filePathUnkown;
     }
+    else {
+        return getFilePathAbsoluteUserRootDir2(filePathUnkown, userRootDir);
+    }
+}
+function getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir) {
+    assert(filePathAbsoluteFilesystem.startsWith(userRootDir));
+    let filePathAbsoluteUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
+    if (!filePathAbsoluteUserRootDir.startsWith('/'))
+        filePathAbsoluteUserRootDir = '/' + filePathAbsoluteUserRootDir;
     return filePathAbsoluteUserRootDir;
 }
+function cleanFilePathUnkown(filePathUnknown) {
+    filePathUnknown = toPosixPath(filePathUnknown);
+    filePathUnknown = cleanModuleId(filePathUnknown);
+    return filePathUnknown;
+}
+function cleanModuleId(moduleId) {
+    // remove query
+    const parts = moduleId.split('?');
+    if (parts.length > 1)
+        parts.pop();
+    assert(parts.length >= 1);
+    return parts.join('?');
+}

package/dist/esm/node/plugin/shared/isErrorDebug.js

@@ -1,5 +1,5 @@
 export { isErrorDebug };
-import { isDebugEnabled } from '../utils.js';
+import { isDebugActivated } from '../utils.js';
 function isErrorDebug() {
-    return isDebugEnabled('vike:error');
+    return isDebugActivated('vike:error');
 }

package/dist/esm/node/plugin/shared/loggerNotProd/errorWithCodeSnippet.js

@@ -7,7 +7,8 @@ export { isEquivalentErrorWithCodeSnippet };
 export { getPrettyErrMessage };
 // Copied & adapted from https://github.com/vitejs/vite/blob/9c114c5c72a6af87e3330d5573362554b4511265/packages/vite/src/node/server/middlewares/error.ts
 import pc from '@brillout/picocolors';
-import { assert, escapeRegex, getFilePathAbsoluteUserRootDir, isObject, removeEmptyLines, stripAnsi, toPosixPath } from '../../utils.js';
+import { assert, escapeRegex, isObject, removeEmptyLines, stripAnsi } from '../../utils.js';
+import { cleanFilePathUnkown, getFilePathToShowToUserFromUnkown } from '../getFilePath.js';
 function isErrorWithCodeSnippet(err) {
     if (!isObject(err)) {
         return false;
@@ -46,7 +47,7 @@ function getPrettyErrorWithCodeSnippet(err, userRootDir) {
     let { id, frame } = err;
     const msgFirstLine = [
         pc.red('Failed to transpile'),
-        pc.bold(pc.red(getFilePathAbsoluteUserRootDir(normalizeId(id), userRootDir))),
+        pc.bold(pc.red(getFilePathToShowToUserFromUnkown(id, userRootDir))),
         pc.red('because:')
     ].join(' ');
     const errMsg = getPrettyErrMessage(err);
@@ -85,7 +86,7 @@ function getPrettyErrMessage(err) {
     // Remove "/home/rom/code/vike/examples/react-full/components/Counter.tsx:1:8:" (redundant since we already print the filename)
     const pos = /(?:\:\d+|)/;
     errMsg = errMsg.split(reg([id, pos, pos, trail], 'gi')).join('');
-    errMsg = errMsg.split(reg([normalizeId(id), pos, pos, trail], 'gi')).join('');
+    errMsg = errMsg.split(reg([cleanFilePathUnkown(id), pos, pos, trail], 'gi')).join('');
     // Remove "ERROR:" (useless)
     errMsg = errMsg.split(reg(['ERROR:', trail])).join('');
     // Remove "Internal server error:" (useless)
@@ -155,9 +156,3 @@ function isEquivalentErrorWithCodeSnippet(err1, err2) {
 function isDefinedAndSame(val1, val2) {
     return val1 && val1 === val2;
 }
-function normalizeId(id) {
-    id = toPosixPath(id);
-    // remove query
-    id = id.split('?')[0];
-    return id;
-}

package/dist/esm/node/plugin/shared/loggerNotProd.js

@@ -14,7 +14,7 @@ export { clearLogs };
 import { isAbortError } from '../../../shared/route/abort.js';
 import { getViteConfig } from '../../runtime/globalContext.js';
 import { overwriteRuntimeProductionLogger } from '../../runtime/renderPage/loggerRuntime.js';
-import { assert, assertIsNotProductionRuntime, formatHintLog, getAssertErrMsg, isUserHookError, overwriteAssertProductionLogger, stripAnsi, warnIfErrorIsNotObject } from '../utils.js';
+import { assert, assertIsNotProductionRuntime, formatHintLog, getAssertErrMsg, overwriteAssertProductionLogger, stripAnsi, warnIfErrorIsNotObject } from '../utils.js';
 import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
 import { isErrorDebug } from './isErrorDebug.js';
 import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
@@ -24,6 +24,7 @@ import pc from '@brillout/picocolors';
 import { setAlreadyLogged } from '../../runtime/renderPage/isNewError.js';
 import { isConfigInvalid } from '../../runtime/renderPage/isConfigInvalid.js';
 import { onRuntimeError } from '../../runtime/renderPage/loggerProd.js';
+import { isUserHookError } from '../../../shared/hooks/executeHook.js';
 assertIsNotProductionRuntime();
 overwriteRuntimeProductionLogger(logRuntimeError, logRuntimeInfo);
 overwriteAssertProductionLogger(assertLogger);

package/dist/esm/node/plugin/utils.d.ts

@@ -1,6 +1,5 @@
 export * from '../runtime/utils.js';
 export * from '../../utils/viteIsSSR.js';
-export * from '../../utils/getFilePathAbsolute.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';
@@ -20,3 +19,4 @@ export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/assertVersion.js';
+export * from '../../utils/assertPathIsFilesystemAbsolute.js';

package/dist/esm/node/plugin/utils.js

@@ -6,7 +6,6 @@ onLoad();
 export * from '../runtime/utils.js';
 // Utils only needed by `plugin/*`
 export * from '../../utils/viteIsSSR.js';
-export * from '../../utils/getFilePathAbsolute.js';
 export * from '../../utils/requireResolve.js';
 export * from '../../utils/arrayIncludes.js';
 export * from '../../utils/isDev.js';
@@ -26,3 +25,4 @@ export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/assertVersion.js';
+export * from '../../utils/assertPathIsFilesystemAbsolute.js';

package/dist/esm/node/prerender/runPrerender.js

@@ -5,8 +5,7 @@ export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, isUserHookError, handleNodeEnv_prerender } from './utils.js';
-import { pLimit } from '../../utils/pLimit.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, handleNodeEnv_prerender, pLimit, assertPathIsFilesystemAbsolute } from './utils.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
@@ -20,13 +19,13 @@ import { getConfigValue, getConfigValueFilePathToShowToUser } from '../../shared
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
 import { addUrlComputedProps } from '../../shared/addUrlComputedProps.js';
-import { assertPathIsFilesystemAbsolute } from '../../utils/assertPathIsFilesystemAbsolute.js';
 import { isAbortError } from '../../shared/route/abort.js';
 import { loadUserFilesServerSide } from '../runtime/renderPage/loadUserFilesServerSide.js';
 import { getHookFromPageConfig, getHookFromPageConfigGlobal, getHookTimeoutDefault, setIsPrerenderering } from '../../shared/hooks/getHook.js';
 import { noRouteMatch } from '../../shared/route/noRouteMatch.js';
 import { getVikeConfig } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import { logErrorHint } from '../runtime/renderPage/logErrorHint.js';
+import { executeHook, isUserHookError } from '../../shared/hooks/executeHook.js';
 async function runPrerenderFromAPI(options = {}) {
     await runPrerender(options, 'prerender()');
     // - We purposely propagate the error to the user land, so that the error interrupts the user land. It's also, I guess, a nice-to-have that the user has control over the error.

package/dist/esm/node/prerender/utils.d.ts

@@ -8,6 +8,7 @@ export * from '../../utils/getOutDirs.js';
 export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
-export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/assertNodeEnv.js';
+export * from '../../utils/pLimit.js';
+export * from '../../utils/assertPathIsFilesystemAbsolute.js';

package/dist/esm/node/prerender/utils.js

@@ -10,6 +10,7 @@ export * from '../../utils/getOutDirs.js';
 export * from '../../utils/isPropertyGetter.js';
 export * from '../../utils/filesystemPathHandling.js';
 export * from '../../utils/urlToFile.js';
-export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/isPlainObject.js';
 export * from '../../utils/assertNodeEnv.js';
+export * from '../../utils/pLimit.js';
+export * from '../../utils/assertPathIsFilesystemAbsolute.js';