vike 0.4.165-commit-b3cc3cb → 0.4.165-commit-8eba585

package/dist/cjs/node/plugin/plugins/baseUrls.js

@@ -10,7 +10,7 @@ function baseUrls(configVike) {
     return {
         name: 'vike:baseUrls',
         enforce: 'post',
-        config: (config) => {
+        async config(config) {
             const bases = (0, resolveBase_js_1.resolveBaseFromUserConfig)(config, configVike);
             baseServer = bases.baseServer;
             baseAssets = bases.baseAssets;

package/dist/cjs/node/plugin/plugins/buildConfig/fixServerAssets.js

@@ -49,10 +49,14 @@ async function copyAssets(filesToCopy, config) {
         return;
     (0, utils_js_1.assert)((0, fs_1.existsSync)(assetsDirServer));
     const concurrencyLimit = (0, utils_js_1.pLimit)(10);
-    await Promise.all(filesToCopy.map((file) => concurrencyLimit(() => promises_1.default.cp(path_1.default.posix.join(outDirServer, file), path_1.default.posix.join(outDirClient, file), {
+    await Promise.all(filesToCopy.map((file) => concurrencyLimit(() => 
+    // TODO: move instead of copying
+    promises_1.default.cp(path_1.default.posix.join(outDirServer, file), path_1.default.posix.join(outDirClient, file), {
         recursive: true
     }))));
-    await promises_1.default.rm(assetsDirServer, { recursive: true });
+    /* We cannot do that because, with some edge case Rollup settings (outputing JavaScript chunks and static assets to the same directoy), this removes JavaScript chunks, see https://github.com/vikejs/vike/issues/1154#issuecomment-1975762404
+    await fs.rm(assetsDirServer, { recursive: true })
+    */
 }
 // Add serverManifest resources to clientManifest
 function addServerAssets(clientManifest, serverManifest) {

package/dist/cjs/node/plugin/plugins/buildConfig.js

@@ -213,7 +213,7 @@ function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
     const filePath = clientEntry;
     (0, utils_js_1.assertPosixPath)(filePath);
     (0, utils_js_1.assert)(filePath.startsWith('/'));
-    let entryTarget = (0, utils_js_1.getFilePathAbsolute)(filePath, config);
+    let entryTarget = (0, utils_js_1.getFilePathAbsoluteFilesystem)(filePath, config);
     if (addExtractAssetsQuery)
         entryTarget = (0, extractAssetsQuery_js_1.extractAssetsAddQuery)(entryTarget);
     let entryName = filePath;

package/dist/cjs/node/plugin/plugins/commonConfig/assertResolveAlias.js

@@ -6,6 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertResolveAlias = void 0;
 const utils_js_1 = require("../../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+// Recommend users to avoid un-distinguishable path aliases.
+// There are a lot of libraries that don't or cannot follow that recommendation, for example:
+// - Nx
+//   - Not sure why, but Nx seems to add a path alias for each monorepo package
+//   - https://github.com/vikejs/vike/discussions/1134
+// - MUI
+//   - https://mui.com/material-ui/guides/minimizing-bundle-size/#how-to-use-custom-bundles
+//   - https://github.com/vikejs/vike/discussions/1549#discussioncomment-8789002
+// - @preact/preset-vite
+//   - Aliases react imports
+// - @vitejs/plugin-vue2
+//   - https://github.com/vikejs/vike/issues/1329
 // TODO/v1-release: replace assertWarning() with assertUsage()
 function assertResolveAlias(config) {
     const aliases = getAliases(config);

package/dist/cjs/node/plugin/plugins/config/index.js

@@ -26,7 +26,7 @@ async function getConfigVikPromise(vikeConfig, config) {
     const fromPluginOptions = (vikeConfig ?? {});
     const fromViteConfig = (config.vike ?? {});
     const configs = [fromPluginOptions, fromViteConfig];
-    const { globalVikeConfig: fromPlusConfigFile } = await (0, getVikeConfig_js_1.getVikeConfig)(config, (0, utils_js_1.isDev2)(config), false);
+    const { globalVikeConfig: fromPlusConfigFile } = await (0, getVikeConfig_js_1.getVikeConfig)(config, (0, utils_js_1.isDev2)(config));
     configs.push(fromPlusConfigFile);
     (0, assertVikeConfig_js_1.assertVikeConfig)(fromPlusConfigFile, ({ prop, errMsg }) => {
         // TODO: add config file path ?

package/dist/cjs/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -38,7 +38,7 @@ async function getPageDeps(config, pageConfigs, isDev) {
                 const { definedAt, configEnv } = configValueSource;
                 if (!configEnv.client)
                     return;
-                if (definedAt.filePathRelativeToUserRootDir !== null) {
+                if (definedAt.filePathAbsoluteUserRootDir !== null) {
                     const { filePathAbsoluteFilesystem } = definedAt;
                     (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
                     // Surprisingly Vite expects entries to be absolute paths
@@ -73,7 +73,7 @@ async function getPageDeps(config, pageConfigs, isDev) {
     {
         const pageFiles = await (0, findPageFiles_js_1.findPageFiles)(config, ['.page', '.page.client'], isDev);
         pageFiles.forEach((filePath) => {
-            const entry = (0, utils_js_1.getFilePathAbsolute)(filePath, config);
+            const entry = (0, utils_js_1.getFilePathAbsoluteFilesystem)(filePath, config);
             entries.push(entry);
         });
     }

package/dist/cjs/node/plugin/plugins/envVars.js

@@ -45,7 +45,7 @@ function envVarsPlugin() {
                     if (isPrivate && isClientSide) {
                         if (!code.includes(envStatement))
                             return;
-                        const filePathToShowToUser = (0, utils_js_1.getFilePathRelativeToUserRootDir)(id, config.root);
+                        const filePathToShowToUser = (0, utils_js_1.getFilePathAbsoluteUserRootDir)(id, config.root);
                         const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
                         const keyPublic = `${publicPrefix}${envName}`;
                         const errMsg = `${envStatement} is used in client-side file ${filePathToShowToUser} which means that the environment variable ${envName} will be included in client-side bundles and, therefore, ${envName} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${envStatement} only in server-side files, or rename ${envName} to ${keyPublic}, see https://vike.dev/env`;

package/dist/cjs/node/plugin/plugins/fileEnv.js

@@ -60,7 +60,7 @@ function fileEnv() {
                     return;
                 // Show error message
                 let errMsg;
-                let modulePathPretty = (0, utils_js_1.getFilePathRelativeToUserRootDir)(modulePath, config.root);
+                let modulePathPretty = (0, utils_js_1.getFilePathAbsoluteUserRootDir)(modulePath, config.root);
                 modulePathPretty = modulePathPretty.replaceAll(suffix, picocolors_1.default.bold(suffix));
                 errMsg = `${(0, utils_js_1.capitalizeFirstLetter)(envExpect)}-only module ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
                 if (importer &&
@@ -68,7 +68,7 @@ function fileEnv() {
                     !importer.includes('virtual:vike:') &&
                     // I don't know why and who sets importer to '<stdin>' (I guess Vite?)
                     importer !== '<stdin>') {
-                    const importerPath = (0, utils_js_1.getFilePathRelativeToUserRootDir)(importer.split('?')[0], config.root);
+                    const importerPath = (0, utils_js_1.getFilePathAbsoluteUserRootDir)(importer.split('?')[0], config.root);
                     errMsg += ` by ${importerPath}`;
                 }
                 if (isDev) {

package/dist/cjs/node/plugin/plugins/importUserCode/index.js

@@ -124,7 +124,7 @@ function isVikeConfigModule(filePathAbsoluteFilesystem) {
 }
 function reloadConfig(filePath, config, op) {
     {
-        const filePathToShowToUser = picocolors_1.default.dim((0, utils_js_1.getFilePathRelativeToUserRootDir)(filePath, config.root, true));
+        const filePathToShowToUser = picocolors_1.default.dim((0, utils_js_1.getFilePathAbsoluteUserRootDir)(filePath, config.root, true));
         const msg = `${op} ${filePathToShowToUser}`;
         (0, loggerNotProd_js_1.logConfigInfo)(msg, 'info');
     }

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

@@ -105,7 +105,6 @@ const configDefinitionsBuiltInGlobal = {
     prerender: {
         env: { config: true }
     },
-    extensions: { env: { config: true } },
     disableAutoFullBuild: { env: { config: true } },
     includeAssetsImportedByServer: { env: { config: true } },
     baseAssets: { env: { config: true } },

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

@@ -11,9 +11,9 @@ const child_process_1 = require("child_process");
 const util_1 = require("util");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const execA = (0, util_1.promisify)(child_process_1.exec);
-const globalObject = (0, utils_js_1.getGlobalObject)('crawlPlusFiles.ts', {
-    gitIsMissing: false
-});
+(0, utils_js_1.assertIsNotProductionRuntime)();
+(0, utils_js_1.assertIsSingleModuleInstance)('crawlPlusFiles.ts');
+let gitIsNotUsable = false;
 async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
     (0, utils_js_1.assertPosixPath)(userRootDir);
     (0, utils_js_1.assertPosixPath)(outDirAbsoluteFilesystem);
@@ -48,15 +48,15 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
     const plusFiles = files.map((p) => {
         p = (0, utils_js_1.toPosixPath)(p);
         (0, utils_js_1.assert)(!p.startsWith(userRootDir));
-        const filePathRelativeToUserRootDir = path_1.default.posix.join('/', p);
-        return { filePathRelativeToUserRootDir };
+        const filePathAbsoluteUserRootDir = path_1.default.posix.join('/', p);
+        return { filePathAbsoluteUserRootDir };
     });
     return plusFiles;
 }
 exports.crawlPlusFiles = crawlPlusFiles;
 // 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);
@@ -74,14 +74,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;
@@ -125,24 +125,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;
+        (0, utils_js_1.assert)(stderr === '');
+        const prefix = 'git version ';
+        (0, utils_js_1.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 (!(0, utils_js_1.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;
+        (0, utils_js_1.assert)(stderr === '');
+        (0, utils_js_1.assert)(stdout === 'true');
+        return false;
     }
-    const { stdout, stderr } = res;
-    (0, utils_js_1.assert)(stderr.toString().trim() === '');
-    (0, utils_js_1.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/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js

@@ -10,10 +10,10 @@ const utils_js_1 = require("../../../../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) {
-    (0, utils_js_1.assertPosixPath)(filePathRelativeToUserRootDir);
-    (0, utils_js_1.assert)(filePathRelativeToUserRootDir.startsWith('/'));
-    const locationId = removeFilename(filePathRelativeToUserRootDir);
+filePathAbsoluteUserRootDir) {
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteUserRootDir);
+    (0, utils_js_1.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];
         (0, utils_js_1.assert)(filename.includes('.'));

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

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilePathUnresolved = exports.getFilePathResolved = void 0;
+const path_1 = __importDefault(require("path"));
+const utils_js_1 = require("../../../../utils.js");
+function getFilePathUnresolved(args) {
+    const { filePathAbsoluteFilesystem, filePathAbsoluteUserRootDir } = args;
+    let filePathAbsoluteVite;
+    if (args.filePathAbsoluteUserRootDir !== null) {
+        filePathAbsoluteVite = args.filePathAbsoluteUserRootDir;
+    }
+    else {
+        (0, utils_js_1.assert)(args.importPathAbsolute !== null); // Help TS
+        filePathAbsoluteVite = args.importPathAbsolute;
+    }
+    return {
+        ...args,
+        filePathAbsoluteVite,
+        filePathToShowToUser: filePathAbsoluteVite,
+        filePathToShowToUserResolved: filePathAbsoluteUserRootDir || filePathAbsoluteFilesystem
+    };
+}
+exports.getFilePathUnresolved = getFilePathUnresolved;
+function getFilePathResolved(args) {
+    const { userRootDir, importPathAbsolute } = args;
+    let filePathAbsoluteFilesystem;
+    let filePathAbsoluteUserRootDir;
+    if ('filePathAbsoluteFilesystem' in args) {
+        filePathAbsoluteFilesystem = args.filePathAbsoluteFilesystem;
+        filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir });
+    }
+    else {
+        filePathAbsoluteUserRootDir = args.filePathAbsoluteUserRootDir;
+        filePathAbsoluteFilesystem = getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir });
+    }
+    let filePathResolved;
+    const common = {
+        filePathAbsoluteUserRootDir,
+        filePathAbsoluteFilesystem,
+        importPathAbsolute,
+        userRootDir
+    };
+    if (importPathAbsolute) {
+        filePathResolved = getFilePathUnresolved({
+            ...common,
+            importPathAbsolute
+        });
+    }
+    else {
+        (0, utils_js_1.assert)(filePathAbsoluteUserRootDir);
+        filePathResolved = getFilePathUnresolved({
+            ...common,
+            filePathAbsoluteUserRootDir
+        });
+    }
+    (0, utils_js_1.assert)(filePathAbsoluteFilesystem);
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(filePathResolved, 'filePathAbsoluteFilesystem', 'string'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(filePathResolved, 'filePathToShowToUserResolved', 'string'));
+    return filePathResolved;
+}
+exports.getFilePathResolved = getFilePathResolved;
+function getFilePathAbsoluteUserFilesystem({ filePathAbsoluteUserRootDir, userRootDir }) {
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteUserRootDir);
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    const filePathAbsoluteFilesystem = path_1.default.posix.join(userRootDir, filePathAbsoluteUserRootDir);
+    return filePathAbsoluteFilesystem;
+}
+function getFilePathAbsoluteUserRootDir({ filePathAbsoluteFilesystem, userRootDir }) {
+    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
+    (0, utils_js_1.assertPosixPath)(userRootDir);
+    let filePathAbsoluteUserRootDir = null;
+    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+        {
+            let filePathAbsoluteUserRootDir1 = filePathAbsoluteFilesystem.slice(userRootDir.length);
+            if (!filePathAbsoluteUserRootDir1.startsWith('/'))
+                filePathAbsoluteUserRootDir1 = '/' + filePathAbsoluteUserRootDir1;
+            filePathAbsoluteUserRootDir = filePathAbsoluteUserRootDir1;
+        }
+        {
+            let filePathAbsoluteUserRootDir2 = path_1.default.posix.relative(userRootDir, filePathAbsoluteFilesystem);
+            (0, utils_js_1.assert)(!filePathAbsoluteUserRootDir2.startsWith('.') && !filePathAbsoluteUserRootDir2.startsWith('/'));
+            filePathAbsoluteUserRootDir2 = '/' + filePathAbsoluteUserRootDir2;
+            (0, utils_js_1.assert)(filePathAbsoluteFilesystem === filePathAbsoluteUserRootDir2);
+        }
+    }
+    return filePathAbsoluteUserRootDir;
+}

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

@@ -12,6 +12,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const transformFileImports_js_1 = require("./transformFileImports.js");
 const getConfigFileExport_js_1 = require("../getConfigFileExport.js");
 const resolveImportPath_js_1 = require("./resolveImportPath.js");
+const getFilePath_js_1 = require("./getFilePath.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 // Load fake import
 async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
@@ -64,21 +65,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 = (0, resolveImportPath_js_1.resolveImportPath)(importData, configFilePath);
         (0, resolveImportPath_js_1.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 = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteFilesystem, userRootDir, importPathAbsolute });
+        extendsConfigFiles.push(filePath);
     });
     const extendsConfigs = [];
     await Promise.all(extendsConfigFiles.map(async (configFilePath) => {
@@ -89,17 +81,6 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
     return { extendsConfigs, extendsFilePaths };
 }
-function determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir) {
-    (0, utils_js_1.assertPosixPath)(filePathAbsoluteFilesystem);
-    (0, utils_js_1.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) {
     (0, utils_js_1.assertWarning)((0, utils_js_1.isNpmPackageImport)(importPath), `${configFilePath.filePathToShowToUser} uses ${picocolors_1.default.cyan('extends')} to inherit from ${picocolors_1.default.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 });
 }

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("./getFilePath.js");
 const filesEnvMap = new Map();
 function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
     if (typeof configValue !== 'string')
@@ -25,14 +26,8 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         // [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
-        };
+        const filePathAbsoluteUserRootDir = resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
+        const filePath = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir, importPathAbsolute: null });
         return {
             ...filePath,
             fileExportName: exportName,
@@ -43,13 +38,11 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         // importPath can be:
         //  - an npm package import
         //  - a path alias
-        const filePath = {
+        const filePath = (0, getFilePath_js_1.getFilePathUnresolved)({
             filePathAbsoluteFilesystem,
-            filePathRelativeToUserRootDir: null,
-            filePathAbsoluteVite: importPath,
-            filePathToShowToUser: importPath,
+            filePathAbsoluteUserRootDir: null,
             importPathAbsolute: importPath
-        };
+        });
         return {
             ...filePath,
             fileExportName: exportName,
@@ -58,11 +51,11 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
     }
 }
 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,14 +64,14 @@ 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;

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;
 }
@@ -298,19 +296,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;
-}