vike 0.4.166 → 0.4.167

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;
 };

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

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

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

@@ -76,7 +76,11 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     return { extendsConfigs, extendsFilePaths };
 }
 function warnUserLandExtension(importPath, configFilePath) {
-    assertWarning(isNpmPackageImport(importPath), `${configFilePath.filePathToShowToUser} uses ${pc.cyan('extends')} to inherit from ${pc.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this.`, { onlyOnce: true });
+    // We preserve this feature because we may need it for eject
+    assertWarning(isNpmPackageImport(importPath, {
+        // Vike config files don't support path aliases. (If they do one day, then Vike will/should be able to resolve path aliases.)
+        cannotBePathAlias: true
+    }) || importPath.includes('/node_modules/'), `${configFilePath.filePathToShowToUser} uses ${pc.cyan('extends')} to inherit from ${pc.cyan(importPath)} which is a user-land file: this is experimental and may be remove at any time. Reach out to a maintainer if you need this.`, { onlyOnce: true });
 }
 function getExtendsImportData(configFileExports, configFilePath) {
     const { filePathToShowToUser } = configFilePath;

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

@@ -18,6 +18,7 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
     const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
     assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
     const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
+    let filePath;
     if (importPath.startsWith('.')) {
         // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
         // ```
@@ -25,28 +26,30 @@ function resolveImport(configValue, importerFilePath, userRootDir, configEnv, co
         // ```
         assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
         const filePathAbsoluteUserRootDir = resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
-        const filePath = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir, importPathAbsolute: null });
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
+        filePath = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
     }
     else {
         // importPath can be:
         //  - an npm package import
         //  - a path alias
-        const filePath = getFilePathUnresolved({
-            filePathAbsoluteFilesystem,
-            filePathAbsoluteUserRootDir: null,
-            importPathAbsolute: importPath
-        });
-        return {
-            ...filePath,
-            fileExportName: exportName,
-            fileExportPathToShowToUser
-        };
+        if (filePathAbsoluteFilesystem) {
+            filePath = getFilePathResolved({
+                userRootDir,
+                filePathAbsoluteFilesystem,
+                importPathAbsolute: importPath
+            });
+        }
+        else {
+            filePath = getFilePathUnresolved({
+                importPathAbsolute: importPath
+            });
+        }
     }
+    return {
+        ...filePath,
+        fileExportName: exportName,
+        fileExportPathToShowToUser
+    };
 }
 function resolveImportPath_absoluteUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
     assertPosixPath(userRootDir);
@@ -74,7 +77,8 @@ function resolveImportPath(importData, importerFilePath) {
     const importerFilePathAbsolute = importerFilePath.filePathAbsoluteFilesystem;
     assertPosixPath(importerFilePathAbsolute);
     const cwd = path.posix.dirname(importerFilePathAbsolute);
-    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer): https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
+    // We can't use import.meta.resolve() as of Junary 2023 (and probably for a lot longer)
+    // https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment137174954_62272600:~:text=But%20the%20argument%20parent%20(aka%20cwd)%20still%20requires%20a%20flag
     // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
     const filePathAbsoluteFilesystem = requireResolve(importData.importPath, cwd);
     return filePathAbsoluteFilesystem;

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

@@ -37,10 +37,10 @@ async function transpileFile(filePath, transformImports, userRootDir) {
     const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath;
     assertPosixPath(filePathAbsoluteFilesystem);
     vikeConfigDependencies.add(filePathAbsoluteFilesystem);
-    if (debug.isEnabled)
+    if (debug.isActivated)
         debug('transpile', filePathToShowToUserResolved);
     let { code, pointerImports } = await transpileWithEsbuild(filePath, userRootDir, transformImports);
-    if (debug.isEnabled)
+    if (debug.isActivated)
         debug(`code, post esbuild (${filePathToShowToUserResolved})`, code);
     let isImportTransformed = false;
     if (transformImports) {
@@ -48,12 +48,12 @@ async function transpileFile(filePath, transformImports, userRootDir) {
         if (codeMod) {
             code = codeMod;
             isImportTransformed = true;
-            if (debug.isEnabled)
+            if (debug.isActivated)
                 debug(`code, post transformImports() (${filePathToShowToUserResolved})`, code);
         }
     }
     if (!isImportTransformed) {
-        if (debug.isEnabled)
+        if (debug.isActivated)
             debug(`code, no transformImports() (${filePathToShowToUserResolved})`);
     }
     return code;
@@ -70,7 +70,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
         outfile: path.posix.join(
         // Needed for correct inline source map
         entryFileDir, 
-        // `write: false` => no file is actually be emitted
+        // `write: false` => no file is actually emitted
         'NEVER_EMITTED.js'),
         logLevel: 'silent',
         format: 'esm',
@@ -102,10 +102,10 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                             return;
                         if (args.pluginData?.[useEsbuildResolver])
                             return;
-                        const isImportAbsolute = !args.path.startsWith('.');
                         const { path, ...opts } = args;
                         opts.pluginData = { [useEsbuildResolver]: true };
                         const resolved = await build.resolve(path, opts);
+                        resolved.path = toPosixPath(resolved.path);
                         // vike-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
                         //  - This is temporary, see comment below.
                         const isVikeExtensionConfigImport = resolved.path.endsWith('+config.js');
@@ -120,14 +120,15 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports) {
                             //  - For example if esbuild cannot resolve a path alias while Vite can.
                             //    - When tsconfig.js#compilerOptions.paths is set, then esbuild is able to resolve the path alias.
                             resolved.errors.length > 0;
-                        pointerImports_[args.path] = isPointerImport;
+                        pointerImports_[resolved.path] = isPointerImport;
+                        assertPosixPath(resolved.path);
                         const isExternal = isPointerImport ||
-                            // npm package imports that aren't pointer imports (e.g. Vite plugin import)
-                            isImportAbsolute;
-                        if (debug.isEnabled)
+                            // npm package imports that aren't pointer imports (e.g. importing a Vite plugin)
+                            resolved.path.includes('/node_modules/');
+                        if (debug.isActivated)
                             debug('onResolved()', { args, resolved, isPointerImport, isExternal });
                         if (isExternal) {
-                            return { external: true, path: args.path };
+                            return { external: true, path: resolved.path };
                         }
                         else {
                             return resolved;

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

@@ -740,7 +740,7 @@ function getComputed(configValueSources, configDefinitions) {
 }
 async function findPlusFiles(userRootDir, outDirRoot, isDev) {
     const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
-    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir, importPathAbsolute: null }));
+    const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }
 function getConfigName(filePath) {
@@ -1007,7 +1007,11 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
         // Sort after whether the config value was defined by an npm package
         .sort(makeFirst(([, [source]]) => {
         const { importPathAbsolute } = source.definedAt;
-        return !!importPathAbsolute && isNpmPackageImport(importPathAbsolute);
+        return (!!importPathAbsolute &&
+            isNpmPackageImport(importPathAbsolute, {
+                // Vike config files don't support path aliases. (If they do one day, then Vike will/should be able to resolve path aliases.)
+                cannotBePathAlias: true
+            }));
     }))
         // Sort after the filesystem inheritance of the config value
         .sort(([, [source1]], [, [source2]]) => reverse(sortAfterInheritanceOrder(source1.locationId, source2.locationId, locationIdPage))));