vike 0.4.165 → 0.4.166-commit-a5e2596

package/dist/cjs/utils/isNpmPackage.js

@@ -1,33 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDistinguishable = exports.parse = exports.isValidPathAlias = exports.getNpmPackageImportPath = exports.getNpmPackageName = exports.isNpmPackageName = exports.isNpmPackageImport = void 0;
+exports.isDistinguishable = exports.parse = exports.isValidPathAlias = exports.assertIsNpmPackageImport = exports.isNpmPackageImport = void 0;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
-function isNpmPackageImport(str) {
+function isNpmPackageImport(str, { cannotBePathAlias }) {
+    // We cannot distinguish path alises that look like npm package imports
+    (0, assert_js_1.assert)(cannotBePathAlias);
     const res = parse(str);
     return res !== null;
 }
 exports.isNpmPackageImport = isNpmPackageImport;
+function assertIsNpmPackageImport(str) {
+    (0, assert_js_1.assert)(isNpmPackageImport(str, {
+        // If `str` is a path alias that looks like an npm package => assertIsNpmPackageImport() is erroneous but that's okay because the assertion will eventually fail for some other user using a disambiguated path alias.
+        cannotBePathAlias: true
+    }));
+}
+exports.assertIsNpmPackageImport = assertIsNpmPackageImport;
 function isNpmPackageName(str) {
     const res = parse(str);
     return res !== null && res.importPath === null;
 }
-exports.isNpmPackageName = isNpmPackageName;
 function getNpmPackageName(str) {
     const res = parse(str);
     if (!res)
         return null;
     return res.pkgName;
 }
-exports.getNpmPackageName = getNpmPackageName;
 function getNpmPackageImportPath(str) {
     const res = parse(str);
     if (!res)
         return null;
     return res.importPath;
 }
-exports.getNpmPackageImportPath = getNpmPackageImportPath;
 function isValidPathAlias(alias) {
     // Cannot be distinguished from npm package names
     if (!isDistinguishable(alias))

package/dist/cjs/utils/parseUrl.js

@@ -10,7 +10,14 @@ exports.isUriWithProtocol = exports.createUrlFromComponents = exports.assertUrlC
 const slice_js_1 = require("./slice.js");
 const assert_js_1 = require("./assert.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const PROTOCOLS = ['http://', 'https://', 'tauri://'];
+const PROTOCOLS = [
+    'http://',
+    'https://',
+    // For [Tauri](https://tauri.app/)
+    'tauri://',
+    // For Electron: https://github.com/vikejs/vike/issues/1557
+    'file://'
+];
 function isParsable(url) {
     // `parseUrl()` works with these URLs
     return (PROTOCOLS.some((p) => url.startsWith(p)) ||

package/dist/cjs/utils/projectInfo.js

@@ -1,13 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
-const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.165';
+const PROJECT_VERSION = '0.4.166-commit-a5e2596';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION
 };
 exports.projectInfo = projectInfo;
-// Trick: since `utils/asserts.ts` depends on this file (`utils/projectInfo.ts`), we can have confidence that this file is always instantiated. So that we don't have to initialize this code snippet at every possible entry. (There are a *lot* of entries: `client/router/`, `client/`, `node/`, `node/plugin/`, `node/cli`, etc.)
-(0, assertSingleInstance_js_1.onProjectInfo)(projectInfo.projectVersion);

package/dist/esm/client/client-routing-runtime/history.d.ts

@@ -2,7 +2,7 @@ export { initHistoryState, getHistoryState, pushHistory, ScrollPosition, saveScr
 type HistoryState = {
     timestamp?: number;
     scrollPosition?: null | ScrollPosition;
-    triggedBy?: 'user' | 'vike' | 'browser';
+    triggeredBy?: 'user' | 'vike' | 'browser';
 };
 type ScrollPosition = {
     x: number;

package/dist/esm/client/client-routing-runtime/history.js

@@ -21,8 +21,8 @@ function initHistoryState() {
         hasModifications = true;
         state.scrollPosition = getScrollPosition();
     }
-    if (!('triggedBy' in state)) {
-        state.triggedBy = 'browser';
+    if (!('triggeredBy' in state)) {
+        state.triggeredBy = 'browser';
     }
     assertState(state);
     if (hasModifications) {
@@ -49,7 +49,7 @@ function saveScrollPosition() {
 function pushHistory(url, overwriteLastHistoryEntry) {
     if (!overwriteLastHistoryEntry) {
         const timestamp = getTimestamp();
-        pushHistoryState({ timestamp, scrollPosition: null, triggedBy: 'vike' }, url);
+        pushHistoryState({ timestamp, scrollPosition: null, triggeredBy: 'vike' }, url);
     }
     else {
         replaceHistoryState(getHistoryState(), url);
@@ -82,8 +82,8 @@ function monkeyPatchHistoryPushState() {
             scrollPosition: getScrollPosition(),
             timestamp: getTimestamp(),
             ...stateFromUser,
-            // Don't allow user to overwrite triggedBy as it would break Vike's handling of the 'popstate' event
-            triggedBy: 'user'
+            // Don't allow user to overwrite triggeredBy as it would break Vike's handling of the 'popstate' event
+            triggeredBy: 'user'
         };
         return pushStateOriginal(state, ...rest);
     };

package/dist/esm/client/client-routing-runtime/onBrowserHistoryNavigation.js

@@ -18,7 +18,7 @@ function onBrowserHistoryNavigation() {
     window.addEventListener('popstate', async () => {
         const currentState = getState();
         const scrollTarget = currentState.historyState.scrollPosition || 'scroll-to-top-or-hash';
-        const isUserLandPushStateNavigation = currentState.historyState.triggedBy === 'user';
+        const isUserLandPushStateNavigation = currentState.historyState.triggeredBy === 'user';
         const isHashNavigation = currentState.urlWithoutHash === globalObject.previousState.urlWithoutHash;
         const isBackwardNavigation = !currentState.historyState.timestamp || !globalObject.previousState.historyState.timestamp
             ? null

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

@@ -34,7 +34,7 @@ function plugin(vikeConfig) {
         ...commonConfig(),
         importUserCode(),
         ...devConfig(),
-        buildConfig(),
+        ...buildConfig(),
         previewConfig(),
         ...autoFullBuild(),
         packageJsonFile(),

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

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

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

@@ -43,10 +43,14 @@ async function copyAssets(filesToCopy, config) {
         return;
     assert(existsSync(assetsDirServer));
     const concurrencyLimit = pLimit(10);
-    await Promise.all(filesToCopy.map((file) => concurrencyLimit(() => fs.cp(path.posix.join(outDirServer, file), path.posix.join(outDirClient, file), {
+    await Promise.all(filesToCopy.map((file) => concurrencyLimit(() => 
+    // TODO: move instead of copying
+    fs.cp(path.posix.join(outDirServer, file), path.posix.join(outDirClient, file), {
         recursive: true
     }))));
-    await fs.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/esm/node/plugin/plugins/buildConfig.d.ts

@@ -5,7 +5,7 @@ export { manifestTempFile };
 import type { ResolvedConfig, Plugin } from 'vite';
 import type { PageConfigBuildTime } from '../../../shared/page-configs/PageConfig.js';
 declare const manifestTempFile = "_temp_manifest.json";
-declare function buildConfig(): Plugin;
+declare function buildConfig(): Plugin[];
 declare function analyzeClientEntries(pageConfigs: PageConfigBuildTime[], config: ResolvedConfig): {
     hasClientRouting: boolean;
     hasServerRouting: boolean;

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

@@ -2,7 +2,7 @@ export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
 export { manifestTempFile };
-import { assert, resolveOutDir, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, injectRollupInputs, normalizeRollupInput, getOutDirs, isNpmPackageImport, assertNodeEnv_build } from '../utils.js';
+import { assert, resolveOutDir, viteIsSSR, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, getOutDirs, assertNodeEnv_build, assertIsNpmPackageImport } from '../utils.js';
 import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValue } from '../../../shared/page-configs/helpers.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
@@ -16,6 +16,7 @@ import path from 'path';
 import { fixServerAssets, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
 import { set_constant_ASSETS_MAP } from './importBuild/index.js';
 import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
+import { getFilePathResolved } from '../shared/getFilePath.js';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
@@ -25,71 +26,81 @@ function buildConfig() {
     let isSsrBuild;
     let outDirs;
     let config;
-    return {
-        name: 'vike:buildConfig',
-        apply: 'build',
-        enforce: 'post',
-        configResolved: {
-            order: 'post',
-            async handler(config_) {
-                config = config_;
-                assertNodeEnv_build();
-                assertRollupInput(config);
-                const entries = await getEntries(config);
-                assert(Object.keys(entries).length > 0);
-                config.build.rollupOptions.input = injectRollupInputs(entries, config);
-                addLogHook();
-                outDirs = getOutDirs(config);
-                {
-                    isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
-                    if (isServerAssetsFixEnabled) {
-                        // https://github.com/vikejs/vike/issues/1339
-                        config.build.ssrEmitAssets = true;
-                        // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
-                        config.build.cssMinify = 'esbuild';
+    return [
+        {
+            name: 'vike:buildConfig:configResolved',
+            apply: 'build',
+            enforce: 'post',
+            configResolved: {
+                order: 'post',
+                async handler(config_) {
+                    config = config_;
+                    assertNodeEnv_build();
+                    assertRollupInput(config);
+                    const entries = await getEntries(config);
+                    assert(Object.keys(entries).length > 0);
+                    config.build.rollupOptions.input = injectRollupInputs(entries, config);
+                    addLogHook();
+                    outDirs = getOutDirs(config);
+                    {
+                        isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
+                        if (isServerAssetsFixEnabled) {
+                            // https://github.com/vikejs/vike/issues/1339
+                            config.build.ssrEmitAssets = true;
+                            // Required if `ssrEmitAssets: true`, see https://github.com/vitejs/vite/pull/11430#issuecomment-1454800934
+                            config.build.cssMinify = 'esbuild';
+                        }
                     }
                 }
+            },
+            config(config) {
+                assertNodeEnv_build();
+                isSsrBuild = viteIsSSR(config);
+                return {
+                    build: {
+                        outDir: resolveOutDir(config),
+                        manifest: manifestTempFile,
+                        copyPublicDir: !isSsrBuild
+                    }
+                };
+            },
+            buildStart() {
+                assertNodeEnv_build();
             }
         },
-        config(config) {
-            assertNodeEnv_build();
-            isSsrBuild = viteIsSSR(config);
-            return {
-                build: {
-                    outDir: resolveOutDir(config),
-                    manifest: manifestTempFile,
-                    copyPublicDir: !isSsrBuild
-                }
-            };
-        },
-        buildStart() {
-            assertNodeEnv_build();
-        },
-        writeBundle: {
-            order: 'post',
-            sequential: true,
-            async handler(options, bundle) {
-                if (isSsrBuild) {
-                    // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
-                    //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
-                    //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
-                    const assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
-                    const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
-                    const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
-                    if (!isServerAssetsFixEnabled) {
-                        await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
-                    }
-                    else {
-                        const clientManifestMod = await fixServerAssets(config);
-                        await fs.writeFile(assetsJsonFilePath, JSON.stringify(clientManifestMod, null, 2), 'utf-8');
+        {
+            name: 'vike:buildConfig:writeBundle',
+            apply: 'build',
+            // Make sure other writeBundle() hooks are called after this writeBundle() hook.
+            //  - set_constant_ASSETS_MAP() needs to be called before dist/server/ code is executed.
+            //    - For example, the writeBundle() hook of vite-plugin-vercel needs to be called after this writeBundle() hook, otherwise: https://github.com/vikejs/vike/issues/1527
+            enforce: 'pre',
+            writeBundle: {
+                order: 'pre',
+                sequential: true,
+                async handler(options, bundle) {
+                    if (isSsrBuild) {
+                        // Ideally we'd move dist/_temp_manifest.json to dist/server/client-assets.json instead of dist/assets.json
+                        //  - But we can't because there is no guarentee whether dist/server/ is generated before or after dist/client/ (generating dist/server/ after dist/client/ erases dist/server/client-assets.json)
+                        //  - We'll able to do so once we replace `$ vite build` with `$ vike build`
+                        const assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
+                        const clientManifestFilePath = path.posix.join(outDirs.outDirClient, manifestTempFile);
+                        const serverManifestFilePath = path.posix.join(outDirs.outDirServer, manifestTempFile);
+                        if (!isServerAssetsFixEnabled) {
+                            await fs.copyFile(clientManifestFilePath, assetsJsonFilePath);
+                        }
+                        else {
+                            const clientManifestMod = await fixServerAssets(config);
+                            await fs.writeFile(assetsJsonFilePath, JSON.stringify(clientManifestMod, null, 2), 'utf-8');
+                        }
+                        await fs.rm(clientManifestFilePath);
+                        await fs.rm(serverManifestFilePath);
+                        await set_constant_ASSETS_MAP(options, bundle);
                     }
-                    await fs.rm(clientManifestFilePath);
-                    await fs.rm(serverManifestFilePath);
-                    await set_constant_ASSETS_MAP(options, bundle);
                 }
             }
         }
-    };
+    ];
 }
 async function getEntries(config) {
     const configVike = await getConfigVike(config);
@@ -190,18 +201,22 @@ async function getPageFileEntries(config, includeAssetsImportedByServer) {
     return pageFileEntries;
 }
 function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
-    if (isNpmPackageImport(clientEntry)) {
+    if (!clientEntry.startsWith('/')) {
+        assertIsNpmPackageImport(clientEntry);
         const entryTarget = clientEntry;
         const entryName = prependEntriesDir(clientEntry);
         return { entryName, entryTarget };
     }
-    const filePath = clientEntry;
-    assertPosixPath(filePath);
-    assert(filePath.startsWith('/'));
-    let entryTarget = getFilePathAbsolute(filePath, config);
+    const filePathAbsoluteUserRootDir = clientEntry;
+    assert(filePathAbsoluteUserRootDir.startsWith('/'));
+    const filePath = getFilePathResolved({
+        filePathAbsoluteUserRootDir,
+        userRootDir: config.root
+    });
+    let entryTarget = filePath.filePathAbsoluteFilesystem;
     if (addExtractAssetsQuery)
         entryTarget = extractAssetsAddQuery(entryTarget);
-    let entryName = filePath;
+    let entryName = filePathAbsoluteUserRootDir;
     if (addExtractAssetsQuery)
         entryName = extractAssetsAddQuery(entryName);
     entryName = removeFileExtention(entryName);

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

@@ -1,8 +1,21 @@
 export { assertResolveAlias };
 import { assert, assertUsage, assertWarning, isValidPathAlias } from '../../utils.js';
 import pc from '@brillout/picocolors';
-// TODO/v1-release: replace assertWarning() with assertUsage()
+// 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
 function assertResolveAlias(config) {
+    // TODO: re-implement warning https://github.com/vikejs/vike/issues/1567
+    return;
     const aliases = getAliases(config);
     const errPrefix = config.configFile || 'Your Vite configuration';
     const errSuffix1 = 'see https://vike.dev/path-aliases#vite';

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

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

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

@@ -1,10 +1,12 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, getFilePathAbsolute, isNpmPackageImport, unique } from '../../utils.js';
+import { assert, assertIsNpmPackageImport, createDebugger, unique } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValueSourcesNotOverriden } from '../../shared/getConfigValueSourcesNotOverriden.js';
 import { analyzeClientEntries } from '../buildConfig.js';
 import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
+import { getFilePathResolved } from '../../shared/getFilePath.js';
+const debug = createDebugger('vike:optimizeDeps');
 async function determineOptimizeDeps(config, isDev) {
     const { pageConfigs } = await getVikeConfig(config, isDev);
     const { entries, include } = await getPageDeps(config, pageConfigs, isDev);
@@ -21,7 +23,11 @@ async function determineOptimizeDeps(config, isDev) {
     */
     config.optimizeDeps.include = [...include, ...normalizeInclude(config.optimizeDeps.include)];
     config.optimizeDeps.entries = [...entries, ...normalizeEntries(config.optimizeDeps.entries)];
-    // console.log('config.optimizeDeps', { entries: config.optimizeDeps.entries, include: config.optimizeDeps.include })
+    if (debug.isEnabled)
+        debug('config.optimizeDeps', {
+            'config.optimizeDeps.entries': config.optimizeDeps.entries,
+            'config.optimizeDeps.include': config.optimizeDeps.include
+        });
 }
 async function getPageDeps(config, pageConfigs, isDev) {
     let entries = [];
@@ -35,7 +41,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;
                     assert(filePathAbsoluteFilesystem);
                     // Surprisingly Vite expects entries to be absolute paths
@@ -44,24 +50,10 @@ async function getPageDeps(config, pageConfigs, isDev) {
                 else {
                     // Adding definedAt.filePathAbsoluteFilesystem doesn't work for npm packages, I guess because of Vite's config.server.fs.allow
                     const { importPathAbsolute } = definedAt;
-                    assert(importPathAbsolute);
-                    // We need to differentiate between npm package imports and path aliases.
-                    // There are path aliases that cannot be distinguished from npm package names.
-                    // We recommend users to use the '#' prefix convention for path aliases, see https://vike.dev/path-aliases#vite and assertResolveAlias()
-                    if (isNpmPackageImport(importPathAbsolute)) {
-                        // isNpmPackageImport() returns false for a path alias like #root/renderer/onRenderClient
-                        assert(!importPathAbsolute.startsWith('#'));
-                        include.push(importPathAbsolute);
-                    }
-                    else {
-                        /* Path aliases, e.g.:
-                         * ```js
-                         * // /renderer/+config.js
-                         * import onRenderClient from '#root/renderer/onRenderClient'
-                         * ```
-                         */
-                        entries.push(importPathAbsolute);
-                    }
+                    assert(importPathAbsolute); // Help TS
+                    // Shouldn't be a path alias, as path aliases would need to be added to config.optimizeDeps.entries instead of config.optimizeDeps.include
+                    assertIsNpmPackageImport(importPathAbsolute);
+                    include.push(importPathAbsolute);
                 }
             });
         });
@@ -69,9 +61,12 @@ async function getPageDeps(config, pageConfigs, isDev) {
     // V0.4 design
     {
         const pageFiles = await findPageFiles(config, ['.page', '.page.client'], isDev);
-        pageFiles.forEach((filePath) => {
-            const entry = getFilePathAbsolute(filePath, config);
-            entries.push(entry);
+        const userRootDir = config.root;
+        pageFiles.forEach((filePathAbsoluteUserRootDir) => {
+            const entry = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
+            const { filePathAbsoluteFilesystem } = entry;
+            assert(filePathAbsoluteFilesystem);
+            entries.push(filePathAbsoluteFilesystem);
         });
     }
     entries = unique(entries);

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

@@ -2,8 +2,9 @@ export { envVarsPlugin };
 // For ./envVars.spec.ts
 export { applyEnvVar };
 import { loadEnv } from 'vite';
-import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, getFilePathRelativeToUserRootDir, lowerFirst } from '../utils.js';
+import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, lowerFirst } from '../utils.js';
 import { sourceMapPassthrough } from '../shared/rollupSourceMap.js';
+import { getModuleFilePath } from '../shared/getFilePath.js';
 function envVarsPlugin() {
     let envsAll;
     let config;
@@ -45,10 +46,10 @@ function envVarsPlugin() {
                     if (isPrivate && isClientSide) {
                         if (!code.includes(envStatement))
                             return;
-                        const filePathToShowToUser = getFilePathRelativeToUserRootDir(id, config.root);
+                        const modulePath = getModuleFilePath(id, config);
                         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`;
+                        const errMsg = `${envStatement} is used in client-side file ${modulePath} 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`;
                         if (isBuild) {
                             assertUsage(false, errMsg);
                         }

package/dist/esm/node/plugin/plugins/extractAssetsPlugin.js

@@ -119,12 +119,6 @@ function extractAssetsPlugin() {
         {
             name: 'vike:extractAssets-3',
             apply: 'build',
-            async configResolved(config_) {
-                configVike = await getConfigVike(config_);
-                config = config_;
-                vikeConfig = await getVikeConfig(config, false);
-                isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
-            },
             load(id) {
                 if (!isVirtualFileId(id))
                     return undefined;
@@ -141,9 +135,15 @@ function extractAssetsPlugin() {
         },
         {
             name: 'vike:extractAssets-4',
-            configResolved(config) {
-                // https://github.com/vikejs/vike/issues/1060
-                assertUsage(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');
+            async configResolved(config_) {
+                configVike = await getConfigVike(config_);
+                config = config_;
+                vikeConfig = await getVikeConfig(config, false);
+                isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
+                if (!isServerAssetsFixEnabled) {
+                    // https://github.com/vikejs/vike/issues/1060
+                    assertUsage(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');
+                }
             }
         }
     ];

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

@@ -1,8 +1,9 @@
 export { fileEnv };
-import { assert, assertUsage, assertWarning, capitalizeFirstLetter, getFilePathRelativeToUserRootDir } from '../utils.js';
+import { assert, assertUsage, assertWarning, capitalizeFirstLetter } from '../utils.js';
 import { extractAssetsRE } from './extractAssetsPlugin.js';
 import { extractExportNamesRE } from './extractExportNamesPlugin.js';
 import pc from '@brillout/picocolors';
+import { getModuleFilePath } from '../shared/getFilePath.js';
 function fileEnv() {
     let config;
     let isDev = false;
@@ -39,11 +40,13 @@ function fileEnv() {
                 // resolved is null when import path is erroneous and doesn't actually point to a file
                 if (!resolved)
                     return;
-                const modulePath = resolved.id.split('?')[0];
+                const moduleId = resolved.id;
+                const modulePath = moduleId.split('?')[0];
                 // `.server.js` and `.client.js` should only apply to user files
                 if (modulePath.includes('/node_modules/'))
                     return;
                 // TODO/v1-release: remove
+                // - I don't remember exactly, but I think I've added `TODO/v1-release: remove` because I vaguely remember that we can remove this after we remove the 0.4 design.
                 if (modulePath.endsWith('.css'))
                     return;
                 const isServerSide = options?.ssr;
@@ -55,7 +58,7 @@ function fileEnv() {
                     return;
                 // Show error message
                 let errMsg;
-                let modulePathPretty = getFilePathRelativeToUserRootDir(modulePath, config.root);
+                let modulePathPretty = getModuleFilePath(moduleId, config);
                 modulePathPretty = modulePathPretty.replaceAll(suffix, pc.bold(suffix));
                 errMsg = `${capitalizeFirstLetter(envExpect)}-only module ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
                 if (importer &&
@@ -63,7 +66,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 = getFilePathRelativeToUserRootDir(importer.split('?')[0], config.root);
+                    const importerPath = getModuleFilePath(importer, config);
                     errMsg += ` by ${importerPath}`;
                 }
                 if (isDev) {

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

@@ -3,12 +3,13 @@ import { normalizePath } from 'vite';
 import { getConfigVike } from '../../../shared/getConfigVike.js';
 import { getVirtualFilePageConfigValuesAll } from './v1-design/getVirtualFilePageConfigValuesAll.js';
 import { getVirtualFileImportUserCode } from './getVirtualFileImportUserCode.js';
-import { assert, assertPosixPath, getFilePathRelativeToUserRootDir, getOutDirs, getVirtualFileId, isDev1, isDev1_onConfigureServer, isVirtualFileId, resolveVirtualFileId } from '../../utils.js';
+import { assert, assertPosixPath, getOutDirs, getVirtualFileId, isDev1, isDev1_onConfigureServer, isVirtualFileId, resolveVirtualFileId } from '../../utils.js';
 import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile } from './v1-design/getVikeConfig.js';
 import pc from '@brillout/picocolors';
 import { logConfigInfo, clearLogs } from '../../shared/loggerNotProd.js';
+import { getFilePathResolved } from '../../shared/getFilePath.js';
 function importUserCode() {
     let config;
     let configVike;
@@ -118,8 +119,11 @@ function isVikeConfigModule(filePathAbsoluteFilesystem) {
 }
 function reloadConfig(filePath, config, op) {
     {
-        const filePathToShowToUser = pc.dim(getFilePathRelativeToUserRootDir(filePath, config.root, true));
-        const msg = `${op} ${filePathToShowToUser}`;
+        const { filePathToShowToUserResolved } = getFilePathResolved({
+            filePathAbsoluteFilesystem: filePath,
+            userRootDir: config.root
+        });
+        const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`;
         logConfigInfo(msg, 'info');
     }
     reloadVikeConfig(config.root, getOutDirs(config).outDirRoot);

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

@@ -58,5 +58,5 @@ type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
 type ConfigDefinitions = Record<string, ConfigDefinitionInternal>;
 type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn, ConfigDefinitionInternal>;
 declare const configDefinitionsBuiltIn: ConfigDefinitionsBuiltIn;
-type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'extensions' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization';
+type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization';
 declare const configDefinitionsBuiltInGlobal: Record<ConfigNameGlobal, ConfigDefinitionInternal>;

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

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