vike 0.4.165 → 0.4.166-commit-6a8acaa

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

@@ -8,6 +8,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const utils_js_1 = require("../../../../utils.js");
 const transformFileImports_js_1 = require("./transformFileImports.js");
 const path_1 = __importDefault(require("path"));
+const getFilePath_js_1 = require("../../../../shared/getFilePath.js");
 const filesEnvMap = new Map();
 function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
     if (typeof configValue !== 'string')
@@ -19,50 +20,45 @@ 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 = (0, getFilePath_js_1.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 = (0, getFilePath_js_1.getFilePathResolved)({
+                userRootDir,
+                filePathAbsoluteFilesystem,
+                importPathAbsolute: importPath
+            });
+        }
+        else {
+            filePath = (0, getFilePath_js_1.getFilePathUnresolved)({
+                importPathAbsolute: importPath
+            });
+        }
     }
+    return {
+        ...filePath,
+        fileExportName: exportName,
+        fileExportPathToShowToUser
+    };
 }
 exports.resolveImport = resolveImport;
-function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
+function resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
     (0, utils_js_1.assertPosixPath)(userRootDir);
-    let filePathRelativeToUserRootDir;
+    let filePathAbsoluteUserRootDir;
     if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
-        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
+        filePathAbsoluteUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
     }
     else {
         (0, utils_js_1.assertUsage)(false, `${configFilePath.filePathToShowToUser} imports from a relative path ${picocolors_1.default.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`);
@@ -71,20 +67,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
         // //*/
     }
-    (0, utils_js_1.assertPosixPath)(filePathRelativeToUserRootDir);
-    (0, utils_js_1.assert)(filePathRelativeToUserRootDir.startsWith('/'));
-    return filePathRelativeToUserRootDir;
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteUserRootDir);
+    (0, utils_js_1.assert)(filePathAbsoluteUserRootDir.startsWith('/'));
+    return filePathAbsoluteUserRootDir;
 }
 function resolveImportPath(importData, importerFilePath) {
     const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     (0, utils_js_1.assertPosixPath)(importerFilePathAbsolute);
     const cwd = path_1.default.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 = (0, utils_js_1.requireResolve)(importData.importPath, cwd);
     return filePathAbsoluteFilesystem;

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

@@ -16,13 +16,12 @@ require("source-map-support/register.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 const debug = (0, utils_js_1.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);
-    (0, utils_js_1.assertUsage)((0, utils_js_1.isJavaScriptFile)(filePathAbsoluteFilesystem), `${filePathToShowToUser2} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isJavaScriptFile)(filePathAbsoluteFilesystem), `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`);
     const isHeader = isHeaderFile(filePathAbsoluteFilesystem);
     if (isHeader) {
-        (0, utils_js_1.assertWarning)(false, `${picocolors_1.default.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUser2} to ${removeHeaderFileExtension(filePathToShowToUser2)} is usually enough, although you may occasionally need to use ${picocolors_1.default.cyan("with { type: 'pointer' }")} as explained at https://vike.dev/config#pointer-imports`, { onlyOnce: true });
+        (0, utils_js_1.assertWarning)(false, `${picocolors_1.default.cyan('.h.js')} files are deprecated: simply renaming ${filePathToShowToUserResolved} to ${removeHeaderFileExtension(filePathToShowToUserResolved)} is usually enough, although you may occasionally need to use ${picocolors_1.default.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
@@ -38,28 +37,27 @@ async function transpileAndExecuteFile(filePath, userRootDir, isConfigFile) {
 }
 exports.transpileAndExecuteFile = transpileAndExecuteFile;
 async function transpileFile(filePath, transformImports, userRootDir) {
-    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
-    const { filePathAbsoluteFilesystem } = filePath;
+    const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
     getVikeConfig_js_1.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 = (0, transformFileImports_js_1.transformFileImports)(code, filePathToShowToUser2, pointerImports);
+        const codeMod = (0, transformFileImports_js_1.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;
 }
@@ -75,7 +73,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         outfile: path_1.default.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',
@@ -107,10 +105,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 = (0, utils_js_1.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');
@@ -125,14 +123,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;
+                        (0, utils_js_1.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;
@@ -298,19 +297,12 @@ function triggerPrepareStackTrace(err) {
     }
 }
 function getErrIntroMsg(operation, filePath) {
-    const filePathToShowToUser2 = getFilePathToShowToUser2(filePath);
+    const { filePathToShowToUserResolved } = filePath;
     const msg = [
         // prettier ignore
         picocolors_1.default.red(`Failed to ${operation}`),
-        picocolors_1.default.bold(picocolors_1.default.red(filePathToShowToUser2)),
+        picocolors_1.default.bold(picocolors_1.default.red(filePathToShowToUserResolved)),
         picocolors_1.default.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;
-    (0, utils_js_1.assert)(filePathToShowToUser2);
-    return filePathToShowToUser2;
-}

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

@@ -20,7 +20,7 @@ const crawlPlusFiles_js_1 = require("./getVikeConfig/crawlPlusFiles.js");
 const getConfigFileExport_js_1 = require("./getConfigFileExport.js");
 const loadFileAtConfigTime_js_1 = require("./getVikeConfig/loadFileAtConfigTime.js");
 const resolveImportPath_js_1 = require("./getVikeConfig/resolveImportPath.js");
-const resolveFilePath_js_1 = require("./getVikeConfig/resolveFilePath.js");
+const getFilePath_js_1 = require("../../../shared/getFilePath.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -65,7 +65,7 @@ async function handleReloadSideEffects() {
         }
     }
 }
-async function getVikeConfig(config, isDev, tolerateInvalidConfig = false) {
+async function getVikeConfig(config, isDev, tolerateInvalidConfig) {
     const { outDirRoot } = (0, utils_js_1.getOutDirs)(config);
     const userRootDir = config.root;
     if (!vikeConfigPromise) {
@@ -97,11 +97,11 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
     await Promise.all([
         // Config files
         ...configFiles.map(async (filePath) => {
-            const { filePathRelativeToUserRootDir } = filePath;
-            (0, utils_js_1.assert)(filePathRelativeToUserRootDir);
+            const { filePathAbsoluteUserRootDir } = filePath;
+            (0, utils_js_1.assert)(filePathAbsoluteUserRootDir);
             const { configFile, extendsConfigs } = await (0, loadFileAtConfigTime_js_1.loadConfigFile)(filePath, userRootDir, [], false);
-            (0, utils_js_1.assert)(filePath.filePathRelativeToUserRootDir);
-            const locationId = (0, filesystemRouting_js_1.getLocationId)(filePathRelativeToUserRootDir);
+            (0, utils_js_1.assert)(filePath.filePathAbsoluteUserRootDir);
+            const locationId = (0, filesystemRouting_js_1.getLocationId)(filePathAbsoluteUserRootDir);
             const interfaceFile = getInterfaceFileFromConfigFile(configFile, false, locationId);
             interfaceFilesByLocationId[locationId] = interfaceFilesByLocationId[locationId] ?? [];
             interfaceFilesByLocationId[locationId].push(interfaceFile);
@@ -150,11 +150,11 @@ async function loadInterfaceFiles(userRootDir, outDirRoot, isDev) {
         }),
         // Value files
         ...valueFiles.map(async (filePath) => {
-            const { filePathRelativeToUserRootDir } = filePath;
-            (0, utils_js_1.assert)(filePathRelativeToUserRootDir);
-            const configName = getConfigName(filePathRelativeToUserRootDir);
+            const { filePathAbsoluteUserRootDir } = filePath;
+            (0, utils_js_1.assert)(filePathAbsoluteUserRootDir);
+            const configName = getConfigName(filePathAbsoluteUserRootDir);
             (0, utils_js_1.assert)(configName);
-            const locationId = (0, filesystemRouting_js_1.getLocationId)(filePathRelativeToUserRootDir);
+            const locationId = (0, filesystemRouting_js_1.getLocationId)(filePathAbsoluteUserRootDir);
             const interfaceFile = {
                 locationId,
                 filePath,
@@ -353,9 +353,9 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
         const interfaceFilesGlobalPaths = [];
         (0, utils_js_1.objectEntries)(interfaceFilesGlobal).forEach(([locationId, interfaceFiles]) => {
             (0, utils_js_1.assert)((0, filesystemRouting_js_1.isGlobalLocation)(locationId, locationIds));
-            interfaceFiles.forEach(({ filePath: { filePathRelativeToUserRootDir } }) => {
-                if (filePathRelativeToUserRootDir) {
-                    interfaceFilesGlobalPaths.push(filePathRelativeToUserRootDir);
+            interfaceFiles.forEach(({ filePath: { filePathAbsoluteUserRootDir } }) => {
+                if (filePathAbsoluteUserRootDir) {
+                    interfaceFilesGlobalPaths.push(filePathAbsoluteUserRootDir);
                 }
             });
         });
@@ -464,10 +464,10 @@ async function resolveConfigValueSources(configName, configDef, interfaceFilesRe
 }
 function makeOrderDeterministic(interfaceFile1, interfaceFile2) {
     return (0, utils_js_1.lowerFirst)((interfaceFile) => {
-        const { filePathRelativeToUserRootDir } = interfaceFile.filePath;
+        const { filePathAbsoluteUserRootDir } = interfaceFile.filePath;
         (0, utils_js_1.assert)(isInterfaceFileUserLand(interfaceFile));
-        (0, utils_js_1.assert)(filePathRelativeToUserRootDir);
-        return filePathRelativeToUserRootDir.length;
+        (0, utils_js_1.assert)(filePathAbsoluteUserRootDir);
+        return filePathAbsoluteUserRootDir.length;
     })(interfaceFile1, interfaceFile2);
 }
 function warnOverridenConfigValues(interfaceFileWinner, interfaceFilesOverriden, configName) {
@@ -541,6 +541,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
                 configName !== 'extends') {
                 if (import_.filePathAbsoluteFilesystem) {
                     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(import_, 'filePathAbsoluteFilesystem', 'string')); // Help TS
+                    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(import_, 'filePathToShowToUserResolved', 'string')); // Help TS
                     const fileExport = await (0, loadFileAtConfigTime_js_1.loadImportedFile)(import_, userRootDir, importedFilesLoaded);
                     configValueSource.value = fileExport;
                 }
@@ -744,7 +745,7 @@ function getComputed(configValueSources, configDefinitions) {
 }
 async function findPlusFiles(userRootDir, outDirRoot, isDev) {
     const files = await (0, crawlPlusFiles_js_1.crawlPlusFiles)(userRootDir, outDirRoot, isDev);
-    const plusFiles = files.map(({ filePathRelativeToUserRootDir }) => (0, resolveFilePath_js_1.resolveFilePathRelativeToUserRootDir)(filePathRelativeToUserRootDir, userRootDir));
+    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }
 function getConfigName(filePath) {
@@ -834,9 +835,9 @@ function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName)
     const configDefinedAt = (0, helpers_js_1.getConfigDefinedAtString)('Config', configName, configFilesystemRoutingRoot);
     (0, utils_js_1.assertUsage)(typeof value === 'string', `${configDefinedAt} should be a string`);
     (0, utils_js_1.assertUsage)(value.startsWith('/'), `${configDefinedAt} is ${picocolors_1.default.cyan(value)} but it should start with a leading slash ${picocolors_1.default.cyan('/')}`);
-    const { filePathRelativeToUserRootDir } = configFilesystemRoutingRoot.definedAt;
-    (0, utils_js_1.assert)(filePathRelativeToUserRootDir);
-    const before = (0, filesystemRouting_js_1.getFilesystemRouteString)((0, filesystemRouting_js_1.getLocationId)(filePathRelativeToUserRootDir));
+    const { filePathAbsoluteUserRootDir } = configFilesystemRoutingRoot.definedAt;
+    (0, utils_js_1.assert)(filePathAbsoluteUserRootDir);
+    const before = (0, filesystemRouting_js_1.getFilesystemRouteString)((0, filesystemRouting_js_1.getLocationId)(filePathAbsoluteUserRootDir));
     const after = value;
     const filesystemRoutingRootEffect = { before, after };
     return { filesystemRoutingRootEffect, filesystemRoutingRootDefinedAt: configDefinedAt };
@@ -1012,7 +1013,11 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
         // Sort after whether the config value was defined by an npm package
         .sort((0, utils_js_1.makeFirst)(([, [source]]) => {
         const { importPathAbsolute } = source.definedAt;
-        return !!importPathAbsolute && (0, utils_js_1.isNpmPackageImport)(importPathAbsolute);
+        return (!!importPathAbsolute &&
+            (0, utils_js_1.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]]) => (0, utils_js_1.reverse)((0, filesystemRouting_js_1.sortAfterInheritanceOrder)(source1.locationId, source2.locationId, locationIdPage))));

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

@@ -0,0 +1,142 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanFilePathUnkown = exports.getFilePathToShowToUserFromUnkown = exports.getModuleFilePath = exports.getFilePathUnresolved = exports.getFilePathResolved = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_js_1 = require("../utils.js");
+function getFilePathUnresolved({ importPathAbsolute }) {
+    return getFilePath({ importPathAbsolute, filePathAbsoluteUserRootDir: null });
+}
+exports.getFilePathUnresolved = getFilePathUnresolved;
+function getFilePathResolved(args) {
+    const { userRootDir } = args;
+    const importPathAbsolute = args.importPathAbsolute ?? null;
+    let filePathAbsoluteFilesystem;
+    let filePathAbsoluteUserRootDir;
+    if ('filePathAbsoluteFilesystem' in args) {
+        filePathAbsoluteFilesystem = args.filePathAbsoluteFilesystem;
+        filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir });
+    }
+    else {
+        filePathAbsoluteUserRootDir = args.filePathAbsoluteUserRootDir;
+        filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir });
+    }
+    let filePath;
+    const common = {
+        filePathAbsoluteUserRootDir,
+        importPathAbsolute,
+        userRootDir
+    };
+    if (importPathAbsolute) {
+        filePath = getFilePath({
+            ...common,
+            importPathAbsolute
+        });
+    }
+    else {
+        (0, utils_js_1.assert)(filePathAbsoluteUserRootDir);
+        filePath = getFilePath({
+            ...common,
+            filePathAbsoluteUserRootDir
+        });
+    }
+    (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(filePathAbsoluteFilesystem);
+    const filePathToShowToUserResolved = filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem;
+    (0, utils_js_1.assert)(filePathToShowToUserResolved);
+    const filePathResolved = {
+        ...filePath,
+        filePathAbsoluteFilesystem,
+        filePathToShowToUserResolved
+    };
+    return filePathResolved;
+}
+exports.getFilePathResolved = getFilePathResolved;
+function getFilePath(args) {
+    let filePathAbsoluteVite;
+    if (args.filePathAbsoluteUserRootDir !== null) {
+        filePathAbsoluteVite = args.filePathAbsoluteUserRootDir;
+    }
+    else {
+        (0, utils_js_1.assert)(args.importPathAbsolute !== null); // Help TS
+        filePathAbsoluteVite = args.importPathAbsolute;
+    }
+    const filePathToShowToUser = filePathAbsoluteVite;
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return {
+        ...args,
+        filePathAbsoluteFilesystem: null,
+        filePathAbsoluteVite,
+        filePathToShowToUser
+    };
+}
+function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir }) {
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteUserRootDir);
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(userRootDir);
+    const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, filePathAbsoluteUserRootDir);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(userRootDir);
+    return filePathAbsoluteFilesystem;
+}
+function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }) {
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(userRootDir);
+    const filePathRelative = path_1.default.posix.relative(userRootDir, filePathAbsoluteFilesystem);
+    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+        (0, utils_js_1.assert)(filePathRelative.startsWith('../'));
+        return null;
+    }
+    (0, utils_js_1.assert)(!filePathRelative.startsWith('.') && !filePathRelative.startsWith('/'));
+    const filePathAbsoluteUserRootDir = `/${filePathRelative}`;
+    (0, utils_js_1.assert)(filePathAbsoluteUserRootDir === getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir));
+    return filePathAbsoluteUserRootDir;
+}
+function getModuleFilePath(moduleId, config) {
+    const userRootDir = config.root;
+    (0, utils_js_1.assertPosixPath)(moduleId);
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    const filePathAbsoluteFilesystem = cleanModuleId(moduleId);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(filePathAbsoluteFilesystem);
+    const filePath = getFilePathResolved({ filePathAbsoluteFilesystem, userRootDir });
+    return filePath.filePathToShowToUserResolved;
+}
+exports.getModuleFilePath = getModuleFilePath;
+function getFilePathToShowToUserFromUnkown(
+// We don't have any guarentee about filePath, e.g. about whether is filePathAbsoluteFilesystem or filePathAbsoluteUserRootDir
+filePathUnkown, userRootDir) {
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(userRootDir);
+    filePathUnkown = cleanFilePathUnkown(filePathUnkown);
+    if (!filePathUnkown.startsWith(userRootDir)) {
+        return filePathUnkown;
+    }
+    else {
+        return getFilePathAbsoluteUserRootDir2(filePathUnkown, userRootDir);
+    }
+}
+exports.getFilePathToShowToUserFromUnkown = getFilePathToShowToUserFromUnkown;
+function getFilePathAbsoluteUserRootDir2(filePathAbsoluteFilesystem, userRootDir) {
+    (0, utils_js_1.assert)(filePathAbsoluteFilesystem.startsWith(userRootDir));
+    let filePathAbsoluteUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
+    if (!filePathAbsoluteUserRootDir.startsWith('/'))
+        filePathAbsoluteUserRootDir = '/' + filePathAbsoluteUserRootDir;
+    return filePathAbsoluteUserRootDir;
+}
+function cleanFilePathUnkown(filePathUnknown) {
+    filePathUnknown = (0, utils_js_1.toPosixPath)(filePathUnknown);
+    filePathUnknown = cleanModuleId(filePathUnknown);
+    return filePathUnknown;
+}
+exports.cleanFilePathUnkown = cleanFilePathUnkown;
+function cleanModuleId(moduleId) {
+    // remove query
+    const parts = moduleId.split('?');
+    if (parts.length > 1)
+        parts.pop();
+    (0, utils_js_1.assert)(parts.length >= 1);
+    return parts.join('?');
+}

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

@@ -9,6 +9,7 @@ exports.getPrettyErrMessage = exports.isEquivalentErrorWithCodeSnippet = exports
 // Copied & adapted from https://github.com/vitejs/vite/blob/9c114c5c72a6af87e3330d5573362554b4511265/packages/vite/src/node/server/middlewares/error.ts
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const utils_js_1 = require("../../utils.js");
+const getFilePath_js_1 = require("../getFilePath.js");
 function isErrorWithCodeSnippet(err) {
     if (!(0, utils_js_1.isObject)(err)) {
         return false;
@@ -48,7 +49,7 @@ function getPrettyErrorWithCodeSnippet(err, userRootDir) {
     let { id, frame } = err;
     const msgFirstLine = [
         picocolors_1.default.red('Failed to transpile'),
-        picocolors_1.default.bold(picocolors_1.default.red((0, utils_js_1.getFilePathRelativeToUserRootDir)(normalizeId(id), userRootDir))),
+        picocolors_1.default.bold(picocolors_1.default.red((0, getFilePath_js_1.getFilePathToShowToUserFromUnkown)(id, userRootDir))),
         picocolors_1.default.red('because:')
     ].join(' ');
     const errMsg = getPrettyErrMessage(err);
@@ -88,7 +89,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([(0, getFilePath_js_1.cleanFilePathUnkown)(id), pos, pos, trail], 'gi')).join('');
     // Remove "ERROR:" (useless)
     errMsg = errMsg.split(reg(['ERROR:', trail])).join('');
     // Remove "Internal server error:" (useless)
@@ -160,9 +161,3 @@ exports.isEquivalentErrorWithCodeSnippet = isEquivalentErrorWithCodeSnippet;
 function isDefinedAndSame(val1, val2) {
     return val1 && val1 === val2;
 }
-function normalizeId(id) {
-    id = (0, utils_js_1.toPosixPath)(id);
-    // remove query
-    id = id.split('?')[0];
-    return id;
-}

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

@@ -23,6 +23,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isNewError_js_1 = require("../../runtime/renderPage/isNewError.js");
 const isConfigInvalid_js_1 = require("../../runtime/renderPage/isConfigInvalid.js");
 const loggerProd_js_1 = require("../../runtime/renderPage/loggerProd.js");
+const executeHook_js_1 = require("../../../shared/hooks/executeHook.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 (0, loggerRuntime_js_1.overwriteRuntimeProductionLogger)(logRuntimeError, logRuntimeInfo);
 (0, utils_js_1.overwriteAssertProductionLogger)(assertLogger);
@@ -99,7 +100,7 @@ function logErr(err, httpRequestId = null, errorComesFromVite) {
         }
     }
     // Needs to be after assertion messages handling, because user hooks may throw an assertion error
-    const hook = (0, utils_js_1.isUserHookError)(err);
+    const hook = (0, executeHook_js_1.isUserHookError)(err);
     if (hook) {
         const { hookName, hookFilePath } = hook;
         (0, log_js_1.logWithVikeTag)(picocolors_1.default.red(`Following error was thrown by the ${hookName}() hook defined at ${hookFilePath}`), 'error', category);

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

@@ -22,7 +22,6 @@ const onLoad_js_1 = require("./onLoad.js");
 __exportStar(require("../runtime/utils.js"), exports);
 // Utils only needed by `plugin/*`
 __exportStar(require("../../utils/viteIsSSR.js"), exports);
-__exportStar(require("../../utils/getFilePathAbsolute.js"), exports);
 __exportStar(require("../../utils/requireResolve.js"), exports);
 __exportStar(require("../../utils/arrayIncludes.js"), exports);
 __exportStar(require("../../utils/isDev.js"), exports);
@@ -42,3 +41,4 @@ __exportStar(require("../../utils/injectRollupInputs.js"), exports);
 __exportStar(require("../../utils/humanizeTime.js"), exports);
 __exportStar(require("../../utils/pLimit.js"), exports);
 __exportStar(require("../../utils/assertVersion.js"), exports);
+__exportStar(require("../../utils/assertPathIsFilesystemAbsolute.js"), exports);

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

@@ -31,7 +31,6 @@ require("../runtime/page-files/setup.js");
 const path_1 = __importDefault(require("path"));
 const index_js_1 = require("../../shared/route/index.js");
 const utils_js_1 = require("./utils.js");
-const pLimit_js_1 = require("../../utils/pLimit.js");
 const renderPageAlreadyRouted_js_1 = require("../runtime/renderPage/renderPageAlreadyRouted.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const os_1 = require("os");
@@ -45,13 +44,13 @@ const helpers_js_1 = require("../../shared/page-configs/helpers.js");
 const loadConfigValues_js_1 = require("../../shared/page-configs/loadConfigValues.js");
 const error_page_js_1 = require("../../shared/error-page.js");
 const addUrlComputedProps_js_1 = require("../../shared/addUrlComputedProps.js");
-const assertPathIsFilesystemAbsolute_js_1 = require("../../utils/assertPathIsFilesystemAbsolute.js");
 const abort_js_1 = require("../../shared/route/abort.js");
 const loadUserFilesServerSide_js_1 = require("../runtime/renderPage/loadUserFilesServerSide.js");
 const getHook_js_1 = require("../../shared/hooks/getHook.js");
 const noRouteMatch_js_1 = require("../../shared/route/noRouteMatch.js");
 const getVikeConfig_js_1 = require("../plugin/plugins/importUserCode/v1-design/getVikeConfig.js");
 const logErrorHint_js_1 = require("../runtime/renderPage/logErrorHint.js");
+const executeHook_js_1 = require("../../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.
@@ -103,8 +102,8 @@ async function runPrerender(options, manuallyTriggered) {
         });
     }
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
-    const concurrencyLimit = (0, pLimit_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, os_1.cpus)().length : parallel);
-    (0, assertPathIsFilesystemAbsolute_js_1.assertPathIsFilesystemAbsolute)(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
+    const concurrencyLimit = (0, utils_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, os_1.cpus)().length : parallel);
+    (0, utils_js_1.assertPathIsFilesystemAbsolute)(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
     await (0, globalContext_js_1.initGlobalContext)(true, outDirRoot);
     const renderContext = await (0, renderPageAlreadyRouted_js_1.getRenderContext)();
     renderContext.pageFilesAll.forEach(assertExportNames);
@@ -245,7 +244,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
             return;
         }
-        const prerenderResult = await (0, utils_js_1.executeHook)(() => hookFn(), { hookName, hookFilePath, hookTimeout });
+        const prerenderResult = await (0, executeHook_js_1.executeHook)(() => hookFn(), { hookName, hookFilePath, hookTimeout });
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         result.forEach(({ url, pageContext }) => {
             {
@@ -410,7 +409,7 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
         pageContext._urlOriginalBeforeHook = pageContext.urlOriginal;
     });
     const docLink = 'https://vike.dev/i18n#pre-rendering';
-    let result = await (0, utils_js_1.executeHook)(() => hookFn({
+    let result = await (0, executeHook_js_1.executeHook)(() => hookFn({
         pageContexts: prerenderContext.pageContexts,
         // TODO/v1-release: remove warning
         get prerenderPageContexts() {
@@ -734,7 +733,7 @@ function assertIsNotAbort(err, urlOr404) {
     if (!(0, abort_js_1.isAbortError)(err))
         return;
     const pageContextAbort = err._pageContextAbort;
-    const hookLoc = (0, utils_js_1.isUserHookError)(err);
+    const hookLoc = (0, executeHook_js_1.isUserHookError)(err);
     (0, utils_js_1.assert)(hookLoc);
     const thrownBy = ` by ${picocolors_1.default.cyan(`${hookLoc.hookName}()`)} hook defined at ${hookLoc.hookFilePath}`;
     const abortCaller = pageContextAbort._abortCaller;

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

@@ -26,6 +26,7 @@ __exportStar(require("../../utils/getOutDirs.js"), exports);
 __exportStar(require("../../utils/isPropertyGetter.js"), exports);
 __exportStar(require("../../utils/filesystemPathHandling.js"), exports);
 __exportStar(require("../../utils/urlToFile.js"), exports);
-__exportStar(require("../../shared/hooks/executeHook.js"), exports);
 __exportStar(require("../../utils/isPlainObject.js"), exports);
 __exportStar(require("../../utils/assertNodeEnv.js"), exports);
+__exportStar(require("../../utils/pLimit.js"), exports);
+__exportStar(require("../../utils/assertPathIsFilesystemAbsolute.js"), exports);

package/dist/cjs/node/runtime/html/injectAssets/getHtmlTags.js

@@ -144,6 +144,7 @@ async function mergeScriptEntries(pageAssets, isProduction) {
 function getPageContextJsonScriptTag(pageContext) {
     const pageContextSerialized = (0, sanitizeJson_js_1.sanitizeJson)((0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext));
     const htmlTag = `<script id="vike_pageContext" type="application/json">${pageContextSerialized}</script>`;
+    // Used by contra.com https://github.com/gajus
     // @ts-expect-error
     pageContext._pageContextHtmlTag = htmlTag;
     return htmlTag;