vike 0.4.166 → 0.4.167-commit-14e4b5e

package/dist/cjs/shared/route/index.js

@@ -39,9 +39,8 @@ async function route(pageContextForRoute) {
     (0, utils_js_1.objectAssign)(pageContext, pageContextFromOnBeforeRouteHook);
     // Vike's routing
     const allPageIds = pageContext._allPageIds;
-    (0, utils_js_1.assert)(allPageIds.length >= 0);
-    (0, utils_js_1.assertUsage)(pageContext._pageFilesAll.length > 0 || pageContext._pageConfigs.length > 0, 'No *.page.js file found. You must create at least one *.page.js file.');
-    (0, utils_js_1.assertUsage)(allPageIds.length > 0, "You must create at least one *.page.js file that isn't _default.page.*");
+    (0, utils_js_1.assertUsage)(allPageIds.length > 0, 'No page found. You must create at least one page.');
+    (0, utils_js_1.assert)(pageContext._pageFilesAll.length > 0 || pageContext._pageConfigs.length > 0);
     const { urlPathname } = pageContext;
     (0, utils_js_1.assert)(urlPathname.startsWith('/'));
     const routeMatches = [];

package/dist/cjs/shared/route/utils.js

@@ -35,7 +35,6 @@ __exportStar(require("../../utils/isStringRecord.js"), exports);
 __exportStar(require("../../utils/unique.js"), exports);
 __exportStar(require("../../utils/isBrowser.js"), exports);
 __exportStar(require("../../utils/parseUrl.js"), exports);
-__exportStar(require("../hooks/executeHook.js"), exports);
 __exportStar(require("../../utils/checkType.js"), exports);
 __exportStar(require("../../utils/joinEnglish.js"), exports);
 __exportStar(require("../../utils/projectInfo.js"), exports);

package/dist/cjs/utils/assertIsNotProductionRuntime.js

@@ -14,35 +14,35 @@ exports.vikeVitePluginLoadedInProductionError = vikeVitePluginLoadedInProduction
 const env = (0, getGlobalObject_js_1.getGlobalObject)('utils/assertIsNotProductionRuntime.ts', {});
 // Called by Vike modules that want to ensure that they aren't loaded by the server runtime in production
 function assertIsNotProductionRuntime() {
-    if (debug.isEnabled)
+    if (debug.isActivated)
         debug('assertIsNotProductionRuntime()', new Error().stack);
     env.shouldNotBeProduction = true;
 }
 exports.assertIsNotProductionRuntime = assertIsNotProductionRuntime;
 // Called by Vite hook configureServer()
 function markEnvAsViteDev() {
-    if (debug.isEnabled)
+    if (debug.isActivated)
         debug('markEnvAsViteDev()', new Error().stack);
     env.isViteDev = true;
 }
 exports.markEnvAsViteDev = markEnvAsViteDev;
 // Called by Vite hook configurePreviewServer()
 function markEnvAsVitePreview() {
-    if (debug.isEnabled)
+    if (debug.isActivated)
         debug('markEnvAsVitePreview()', new Error().stack);
     env.isVitePreview = true;
 }
 exports.markEnvAsVitePreview = markEnvAsVitePreview;
 // Called by ../node/plugin/index.ts
 function markEnvAsVikePluginLoaded() {
-    if (debug.isEnabled)
+    if (debug.isActivated)
         debug('markEnvAsVikePluginLoaded()', new Error().stack);
     env.isVikePluginLoaded = true;
 }
 exports.markEnvAsVikePluginLoaded = markEnvAsVikePluginLoaded;
 // Called by ../node/runtime/index.ts
 function assertEnv() {
-    if (debug.isEnabled)
+    if (debug.isActivated)
         debug('assertEnv()', new Error().stack);
     if ((0, isVitest_js_1.isVitest)())
         return;

package/dist/cjs/utils/assertPathIsFilesystemAbsolute.js

@@ -10,6 +10,7 @@ const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
 /** Assert path is absolute from the filesystem root */
 function assertPathIsFilesystemAbsolute(p) {
     (0, filesystemPathHandling_js_1.assertPosixPath)(p);
+    (0, assert_js_1.assert)(!p.startsWith('/@fs/'));
     if (process.platform === 'win32') {
         (0, assert_js_1.assert)(path_1.default.win32.isAbsolute(p));
     }

package/dist/cjs/utils/debug.js

@@ -1,17 +1,39 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDebugEnabled = exports.createDebugger = void 0;
+exports.isDebugActivated = exports.createDebugger = void 0;
 const isBrowser_js_1 = require("./isBrowser.js");
 const isCallable_js_1 = require("./isCallable.js");
 const objectAssign_js_1 = require("./objectAssign.js");
 const assert_js_1 = require("./assert.js");
 const checkType_js_1 = require("./checkType.js");
 const getTerminWidth_js_1 = require("./getTerminWidth.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 // Avoid this to be loaded in the browser. For isomorphic code: instead of `import { createDebugger } from './utils.js'`, use `globalThis.createDebugger()`.
 (0, assert_js_1.assert)(!(0, isBrowser_js_1.isBrowser)());
 globalThis.__brillout_debug_createDebugger = createDebugger;
+const flags = [
+    'vike:error',
+    'vike:extractAssets',
+    'vike:extractExportNames',
+    'vike:glob',
+    'vike:log',
+    'vike:optimizeDeps',
+    'vike:outDir',
+    'vike:pageFiles',
+    'vike:pointer-imports',
+    'vike:routing',
+    'vike:setup',
+    'vike:stream',
+    'vike:virtual-files'
+];
+const flagRegex = /\bvike:[a-zA-Z-]+/g;
+assertDEBUG();
 function createDebugger(flag, optionsGlobal) {
     (0, checkType_js_1.checkType)(flag);
+    (0, assert_js_1.assert)(flags.includes(flag));
     const debugWithOptions = (optionsLocal) => {
         return (...msgs) => {
             const options = { ...optionsGlobal, ...optionsLocal };
@@ -19,12 +41,12 @@ function createDebugger(flag, optionsGlobal) {
         };
     };
     const debug = (...msgs) => debugWithOptions({})(...msgs);
-    (0, objectAssign_js_1.objectAssign)(debug, { options: debugWithOptions, isEnabled: isDebugEnabled(flag) });
+    (0, objectAssign_js_1.objectAssign)(debug, { options: debugWithOptions, isActivated: isDebugActivated(flag) });
     return debug;
 }
 exports.createDebugger = createDebugger;
 function debug_(flag, options, ...msgs) {
-    if (!isDebugEnabled(flag))
+    if (!isDebugActivated(flag))
         return;
     let [msgFirst, ...msgsRest] = msgs;
     const padding = ' '.repeat(flag.length + 1);
@@ -49,19 +71,14 @@ function debug_(flag, options, ...msgs) {
         console.log(msg);
     });
 }
-function isDebugEnabled(flag) {
+function isDebugActivated(flag) {
     (0, checkType_js_1.checkType)(flag);
-    let DEBUG;
-    // - `process` can be undefined in edge workers
-    // - We want bundlers to be able to statically replace `process.env.*`
-    try {
-        DEBUG = process.env.DEBUG;
-    }
-    catch { }
-    const isEnabled = DEBUG?.includes(flag) ?? false;
-    return isEnabled;
+    (0, assert_js_1.assert)(flags.includes(flag));
+    const DEBUG = getDEBUG();
+    const isActivated = DEBUG?.includes(flag) ?? false;
+    return isActivated;
 }
-exports.isDebugEnabled = isDebugEnabled;
+exports.isDebugActivated = isDebugActivated;
 function formatMsg(info, options, padding, position) {
     if (info === undefined) {
         return undefined;
@@ -122,3 +139,20 @@ function replaceFunctionSerializer(_key, value) {
     }
     return value;
 }
+function assertDEBUG() {
+    const DEBUG = getDEBUG() ?? '';
+    const flagsActivated = DEBUG.match(flagRegex) ?? [];
+    flagsActivated.forEach((flag) => {
+        (0, assert_js_1.assertUsage)(flags.includes(flag), `Unknown DEBUG flag ${picocolors_1.default.cyan(flag)}. Valid flags:\n${flags.map((f) => `  ${picocolors_1.default.cyan(f)}`).join('\n')}`);
+    });
+}
+function getDEBUG() {
+    let DEBUG;
+    // - `process` can be undefined in edge workers
+    // - We want bundlers to be able to statically replace `process.env.*`
+    try {
+        DEBUG = process.env.DEBUG;
+    }
+    catch { }
+    return DEBUG;
+}

package/dist/cjs/utils/isNpmPackage.js

@@ -1,14 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDistinguishable = exports.parse = exports.isValidPathAlias = 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;

package/dist/cjs/utils/projectInfo.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
-const PROJECT_VERSION = '0.4.166';
+const PROJECT_VERSION = '0.4.167-commit-14e4b5e';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/cjs/utils/trackLogs.js

@@ -7,7 +7,7 @@ const debug_js_1 = require("./debug.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
-if ((0, debug_js_1.isDebugEnabled)('vike:log')) {
+if ((0, debug_js_1.isDebugActivated)('vike:log')) {
     trackLogs();
 }
 // https://stackoverflow.com/questions/45395369/how-to-get-console-log-line-numbers-shown-in-nodejs/75109905#75109905

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

@@ -22,7 +22,7 @@ async function renderPageClientSide(renderArgs) {
     const { scrollTarget, urlOriginal = getCurrentUrl(), overwriteLastHistoryEntry = false, isBackwardNavigation, pageContextsFromRewrite = [], redirectCount = 0, isUserLandPushStateNavigation, isClientSideNavigation = true } = renderArgs;
     // isHydrationRender <=> the first render attempt
     const { isRenderOutdated, setHydrationCanBeAborted, isHydrationRender } = getIsRenderOutdated();
-    assert(isClientSideNavigation === !isHydrationRender);
+    assert(isClientSideNavigation === !isHydrationRender); // isHydrationRender === (renderNumber === 1)
     assertNoInfiniteAbortLoop(pageContextsFromRewrite.length, redirectCount);
     if (globalObject.clientRoutingIsDisabled) {
         serverSideRouteTo(urlOriginal);
@@ -37,6 +37,31 @@ async function renderPageClientSide(renderArgs) {
         const pageContext = await getPageContextBegin();
         if (isRenderOutdated())
             return;
+        // onPageTransitionStart()
+        if (globalObject.isFirstRenderDone) {
+            const { previousPageContext } = globalObject;
+            assert(previousPageContext);
+            // We use the hook of the previous page in order to be able to call onPageTransitionStart() before fetching the files of the next page.
+            // https://github.com/vikejs/vike/issues/1560
+            assertHook(previousPageContext, 'onPageTransitionStart');
+            if (!globalObject.isTransitioning) {
+                globalObject.isTransitioning = true;
+                const onPageTransitionStartHook = getHook(previousPageContext, 'onPageTransitionStart');
+                if (onPageTransitionStartHook) {
+                    const hook = onPageTransitionStartHook;
+                    const { hookFn } = hook;
+                    try {
+                        await executeHook(() => hookFn(pageContext), hook);
+                    }
+                    catch (err) {
+                        await onError(err);
+                        return;
+                    }
+                    if (isRenderOutdated())
+                        return;
+                }
+            }
+        }
         // Route
         let pageContextRouted;
         if (isHydrationRender) {
@@ -104,27 +129,6 @@ async function renderPageClientSide(renderArgs) {
         // There wasn't any `await` but result may change because we just called setHydrationCanBeAborted()
         if (isRenderOutdated())
             return;
-        // onPageTransitionStart()
-        if (!isHydrationRender) {
-            assertHook(pageContext, 'onPageTransitionStart');
-            if (!globalObject.isTransitioning) {
-                globalObject.isTransitioning = true;
-                const onPageTransitionStartHook = getHook(pageContext, 'onPageTransitionStart');
-                if (onPageTransitionStartHook) {
-                    const hook = onPageTransitionStartHook;
-                    const { hookFn } = hook;
-                    try {
-                        await executeHook(() => hookFn(pageContext), hook);
-                    }
-                    catch (err) {
-                        await onError(err);
-                        return;
-                    }
-                    if (isRenderOutdated())
-                        return;
-                }
-            }
-        }
         // Get pageContext from hooks (fetched from server, and/or directly called on the client-side)
         if (isHydrationRender) {
             assert(hasProp(pageContext, '_hasPageContextFromServer', 'true'));
@@ -328,6 +332,7 @@ async function renderPageClientSide(renderArgs) {
                 onRenderClientError = err;
             }
             globalObject.onRenderClientPromise = undefined;
+            globalObject.isFirstRenderDone = true;
             return onRenderClientError;
         })();
         const onRenderClientError = await globalObject.onRenderClientPromise;
@@ -365,8 +370,10 @@ async function renderPageClientSide(renderArgs) {
         // onPageTransitionEnd()
         if (globalObject.isTransitioning) {
             globalObject.isTransitioning = undefined;
-            assertHook(pageContext, 'onPageTransitionEnd');
-            const hook = getHook(pageContext, 'onPageTransitionEnd');
+            const { previousPageContext } = globalObject;
+            assert(previousPageContext);
+            assertHook(previousPageContext, 'onPageTransitionEnd');
+            const hook = getHook(previousPageContext, 'onPageTransitionEnd');
             if (hook) {
                 const { hookFn } = hook;
                 try {

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

@@ -2,7 +2,7 @@ export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
 export { manifestTempFile };
-import { assert, resolveOutDir, viteIsSSR, getFilePathAbsoluteFilesystem, 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);
@@ -200,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 = getFilePathAbsoluteFilesystem(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

@@ -13,8 +13,9 @@ import pc from '@brillout/picocolors';
 //   - Aliases react imports
 // - @vitejs/plugin-vue2
 //   - https://github.com/vikejs/vike/issues/1329
-// TODO/v1-release: replace assertWarning() with assertUsage()
 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/devConfig/determineOptimizeDeps.js

@@ -1,10 +1,12 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
-import { assert, getFilePathAbsoluteFilesystem, 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.isActivated)
+        debug('config.optimizeDeps', {
+            'config.optimizeDeps.entries': config.optimizeDeps.entries,
+            'config.optimizeDeps.include': config.optimizeDeps.include
+        });
 }
 async function getPageDeps(config, pageConfigs, isDev) {
     let entries = [];
@@ -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 = getFilePathAbsoluteFilesystem(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, getFilePathAbsoluteUserRootDir, 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 = getFilePathAbsoluteUserRootDir(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

@@ -6,7 +6,7 @@
 //  - This appraoch supports import path aliases `vite.config.js#resolve.alias` https://vitejs.dev/config/#resolve-alias
 export { extractAssetsPlugin };
 export { extractAssetsRE };
-import { viteIsSSR_options, assert, assertPosixPath, styleFileRE, createDebugger, isDebugEnabled, isScriptFile, resolveVirtualFileId, isVirtualFileId, getVirtualFileId, assertUsage } from '../utils.js';
+import { viteIsSSR_options, assert, assertPosixPath, styleFileRE, createDebugger, isScriptFile, resolveVirtualFileId, isVirtualFileId, getVirtualFileId, assertUsage } from '../utils.js';
 import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { getConfigVike } from '../../shared/getConfigVike.js';
 import { isAsset } from '../shared/isAsset.js';
@@ -20,9 +20,7 @@ const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
 const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
 const EMPTY_MODULE_ID = 'virtual:vike:empty-module';
-const debugNamespace = 'vike:extractAssets';
-const debug = createDebugger(debugNamespace);
-const debugEnabled = isDebugEnabled(debugNamespace);
+const debug = createDebugger('vike:extractAssets');
 function extractAssetsPlugin() {
     let config;
     let configVike;
@@ -119,12 +117,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;
@@ -134,16 +126,22 @@ function extractAssetsPlugin() {
                 }
             },
             config() {
-                if (debugEnabled) {
+                if (debug.isActivated) {
                     return { logLevel: 'silent' };
                 }
             }
         },
         {
             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/extractExportNamesPlugin.js

@@ -1,13 +1,11 @@
 export { extractExportNamesPlugin };
 export { isUsingClientRouter };
 export { extractExportNamesRE };
-import { assert, getFileExtension, viteIsSSR_options, createDebugger, isDebugEnabled, getGlobalObject, assertUsage } from '../utils.js';
+import { assert, getFileExtension, viteIsSSR_options, createDebugger, getGlobalObject, assertUsage } from '../utils.js';
 import { getExportNames } from '../shared/parseEsModule.js';
 import { sourceMapRemove } from '../shared/rollupSourceMap.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
-const debugNamespace = 'vike:extractExportNames';
-const debug = createDebugger(debugNamespace);
-const debugEnabled = isDebugEnabled(debugNamespace);
+const debug = createDebugger('vike:extractExportNames');
 const globalObject = getGlobalObject('extractExportNamesPlugin.ts', {});
 function extractExportNamesPlugin() {
     let isDev = false;
@@ -26,7 +24,7 @@ function extractExportNamesPlugin() {
             isDev = true;
         },
         config() {
-            if (debugEnabled) {
+            if (debug.isActivated) {
                 return { logLevel: 'silent' };
             }
         }

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

@@ -1,8 +1,9 @@
 export { fileEnv };
-import { assert, assertUsage, assertWarning, capitalizeFirstLetter, getFilePathAbsoluteUserRootDir } 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 = getFilePathAbsoluteUserRootDir(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 = getFilePathAbsoluteUserRootDir(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, getFilePathAbsoluteUserRootDir, 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(getFilePathAbsoluteUserRootDir(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/debug.d.ts

@@ -4,5 +4,5 @@ export declare const debug: ((...msgs: unknown[]) => void) & {
             emptyArray?: string | undefined;
         } | undefined;
     }) => (...msgs: unknown[]) => void;
-    isEnabled: boolean;
+    isActivated: boolean;
 };