vike 0.4.159 → 0.4.160-commit-a1101c1

package/dist/cjs/node/runtime/renderPage/loadUserFilesServerSide.js

@@ -44,7 +44,7 @@ async function loadUserFilesServerSide(pageContext) {
     // TODO/v1-release: remove
     Object.assign(pageContextAddendum, {
         _getPageAssets: async () => {
-            (0, utils_js_1.assertWarning)(false, 'pageContext._getPageAssets() deprecated, see https://vike.dev/preload', {
+            (0, utils_js_1.assertWarning)(false, 'pageContext._getPageAssets() deprecated, see https://vike.dev/preloading', {
                 onlyOnce: true,
                 showStackTrace: true
             });

package/dist/cjs/shared/page-configs/assertPlusFileExport.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPlusFileExport = void 0;
+const utils_js_1 = require("../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const EXPORTS_IGNORE = [
+    // vite-plugin-solid adds `export { $$registrations }`
+    '$$registrations',
+    // @vitejs/plugin-vue adds `export { _rerender_only }`
+    '_rerender_only'
+];
+// Tolerate `export { frontmatter }` in .mdx files
+const TOLERATE_SIDE_EXPORTS = ['.md', '.mdx'];
+function assertPlusFileExport(fileExports, filePathToShowToUser, configName) {
+    const exportsAll = Object.keys(fileExports).filter((exportName) => !EXPORTS_IGNORE.includes(exportName));
+    const exportsInvalid = exportsAll.filter((e) => e !== 'default' && e !== configName);
+    if (exportsInvalid.length === 0) {
+        if (exportsAll.length === 1) {
+            return;
+        }
+        const exportDefault = picocolors_1.default.cyan('export default');
+        const exportNamed = picocolors_1.default.cyan(`export { ${configName} }`);
+        if (exportsAll.length === 0) {
+            (0, utils_js_1.assertUsage)(false, `${filePathToShowToUser} doesn't export any value, but it should have a ${exportNamed} or ${exportDefault}`);
+        }
+        else {
+            (0, utils_js_1.assert)(exportsAll.length === 2); // because `exportsInvalid.length === 0`
+            (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser} remove ${exportNamed} or ${exportDefault}`, {
+                onlyOnce: true
+            });
+        }
+    }
+    else {
+        if (TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext)))
+            return;
+        exportsInvalid.forEach((exportInvalid) => {
+            (0, utils_js_1.assertWarning)(false, `${filePathToShowToUser} should have only one export: move ${picocolors_1.default.cyan(`export { ${exportInvalid} }`)} to its own +${exportsInvalid}.js file`, { onlyOnce: true });
+        });
+    }
+}
+exports.assertPlusFileExport = assertPlusFileExport;

package/dist/cjs/shared/page-configs/serialize/parseConfigValuesImported.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseConfigValuesImported = void 0;
 const utils_js_1 = require("../../utils.js");
-const assertExports_js_1 = require("../assertExports.js");
+const assertPlusFileExport_js_1 = require("../assertPlusFileExport.js");
 function parseConfigValuesImported(configValuesImported) {
     const configValues = {};
     const addConfigValue = (configName, value, importPath, exportName) => {
@@ -23,7 +23,7 @@ function parseConfigValuesImported(configValuesImported) {
         if (configValueLoaded.isValueFile) {
             const { exportValues, importPath, configName } = configValueLoaded;
             if (configName !== 'client') {
-                (0, assertExports_js_1.assertExportsOfValueFile)(exportValues, importPath, configName);
+                (0, assertPlusFileExport_js_1.assertPlusFileExport)(exportValues, importPath, configName);
             }
             Object.entries(exportValues).forEach(([exportName, exportValue]) => {
                 const isSideExport = exportName !== 'default'; // .md files may have "side-exports" such as `export { frontmatter }`

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

@@ -136,7 +136,7 @@ function logAbortErrorHandled(err, isProduction, pageContext) {
 exports.logAbortErrorHandled = logAbortErrorHandled;
 function assertStatusCode(statusCode, expected, caller) {
     const expectedEnglish = (0, utils_js_1.joinEnglish)(expected.map((s) => s.toString()), 'or');
-    (0, utils_js_1.assertWarning)(expected.includes(statusCode), `Unepexected status code ${statusCode} passed to ${caller}(), we recommend ${expectedEnglish} instead. (Or reach out at ${utils_js_1.projectInfo.githubRepository}/issues/1008 if you believe ${statusCode} should be added.)`, { onlyOnce: true });
+    (0, utils_js_1.assertWarning)(expected.includes(statusCode), `Unepexected status code ${statusCode} passed to ${caller}(), we recommend ${expectedEnglish} instead. (Or reach out at https://github.com/vikejs/vike/issues/1008 if you believe ${statusCode} should be added.)`, { onlyOnce: true });
 }
 function getPageContextFromAllRewrites(pageContextsFromRewrite) {
     assertNoInfiniteLoop(pageContextsFromRewrite);

package/dist/cjs/utils/assert.js

@@ -22,8 +22,8 @@ const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/assert.ts'
     },
     showStackTraceList: new WeakSet()
 });
-const projectTag = `[${projectInfo_js_1.projectInfo.npmPackageName}]`;
-const projectTagWithVersion = `[${projectInfo_js_1.projectInfo.npmPackageName}@${projectInfo_js_1.projectInfo.projectVersion}]`;
+const projectTag = `[vike]`;
+const projectTagWithVersion = `[vike@${projectInfo_js_1.projectInfo.projectVersion}]`;
 const numberOfStackTraceLinesToRemove = 2;
 function assert(condition, debugInfo) {
     if (condition)
@@ -33,12 +33,11 @@ function assert(condition, debugInfo) {
             return null;
         }
         const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
-        return picocolors_1.default.dim(`Debug info (for ${projectInfo_js_1.projectInfo.projectName} maintainers; you can ignore this): ${debugInfoSerialized}`);
+        return picocolors_1.default.dim(`Debug info (for Vike maintainers; you can ignore this): ${debugInfoSerialized}`);
     })();
-    const link = `${projectInfo_js_1.projectInfo.githubRepository}/issues/new`;
     let errMsg = [
-        `You stumbled upon a bug in ${projectInfo_js_1.projectInfo.projectName}'s source code.`,
-        `Go to ${picocolors_1.default.blue(link)} and copy-paste this error. A maintainer will fix the bug (usually under 24 hours).`,
+        `You stumbled upon a Vike bug.`,
+        `Go to ${picocolors_1.default.blue('https://github.com/vikejs/vike/issues/new')} and copy-paste this error. A maintainer will fix the bug (usually under 24 hours).`,
         debugStr
     ]
         .filter(Boolean)

package/dist/cjs/utils/assertIsNotProductionRuntime.js

@@ -1,44 +1,62 @@
 "use strict";
 // Mechanism to ensure code isn't loaded by production runtime
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertEnv = exports.markEnvAsVite = exports.markEnvAsPreview = exports.markEnvAsDev = exports.assertIsNotProductionRuntime = void 0;
+exports.vikeVitePluginLoadedInProductionError = exports.assertEnv = exports.markEnvAsVikePluginLoaded = exports.markEnvAsVitePreview = exports.markEnvAsViteDev = exports.assertIsNotProductionRuntime = void 0;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+const debug_js_1 = require("./debug.js");
 const getGlobalObject_js_1 = require("./getGlobalObject.js");
 const isVitest_js_1 = require("./isVitest.js");
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+const debug = (0, debug_js_1.createDebugger)('vike:setup');
+const vikeVitePluginLoadedInProductionError = `Loading Vike's Vite plugin (the vike/plugin module) is prohibited in production.`;
+exports.vikeVitePluginLoadedInProductionError = vikeVitePluginLoadedInProductionError;
 const env = (0, getGlobalObject_js_1.getGlobalObject)('utils/assertIsNotProductionRuntime.ts', {});
-// Called by *.ts that want to ensure that they aren't loaded by the server runtime in production
+// Called by Vike modules that want to ensure that they aren't loaded by the server runtime in production
 function assertIsNotProductionRuntime() {
-    env.shouldBeVite = true;
+    if (debug.isEnabled)
+        debug('assertIsNotProductionRuntime()', new Error().stack);
+    env.shouldNotBeProduction = true;
 }
 exports.assertIsNotProductionRuntime = assertIsNotProductionRuntime;
 // Called by Vite hook configureServer()
-function markEnvAsDev() {
-    env.isDev = true;
+function markEnvAsViteDev() {
+    if (debug.isEnabled)
+        debug('markEnvAsViteDev()', new Error().stack);
+    env.isViteDev = true;
 }
-exports.markEnvAsDev = markEnvAsDev;
+exports.markEnvAsViteDev = markEnvAsViteDev;
 // Called by Vite hook configurePreviewServer()
-function markEnvAsPreview() {
-    env.isPreview = true;
+function markEnvAsVitePreview() {
+    if (debug.isEnabled)
+        debug('markEnvAsVitePreview()', new Error().stack);
+    env.isVitePreview = true;
 }
-exports.markEnvAsPreview = markEnvAsPreview;
+exports.markEnvAsVitePreview = markEnvAsVitePreview;
 // Called by ../node/plugin/index.ts
-function markEnvAsVite() {
-    env.isVite = true;
+function markEnvAsVikePluginLoaded() {
+    if (debug.isEnabled)
+        debug('markEnvAsVikePluginLoaded()', new Error().stack);
+    env.isVikePluginLoaded = true;
 }
-exports.markEnvAsVite = markEnvAsVite;
+exports.markEnvAsVikePluginLoaded = markEnvAsVikePluginLoaded;
 // Called by ../node/runtime/index.ts
 function assertEnv() {
+    if (debug.isEnabled)
+        debug('assertEnv()', new Error().stack);
     if ((0, isVitest_js_1.isVitest)())
         return;
-    if (env.isDev || env.isPreview) {
-        (0, assert_js_1.assert)(env.isVite);
-        (0, assert_js_1.assert)(env.shouldBeVite);
+    const isProduction = !env.isViteDev && !env.isVitePreview;
+    if (isProduction) {
+        // Seems to be the only reliable way to assert that the user doesn't load Vike's Vite plugin in production. (The other assert() that uses process.env.NODE_ENV doesn't work if the user sets the process.env.NODE_ENV value later.)
+        (0, assert_js_1.assertUsage)(!env.isVikePluginLoaded, vikeVitePluginLoadedInProductionError);
+        // This assert() is the main goal of this file: it ensures assertIsNotProductionRuntime()
+        (0, assert_js_1.assert)(!env.shouldNotBeProduction);
     }
     else {
-        (0, assert_js_1.assert)(!env.isVite);
-        (0, assert_js_1.assert)(!env.shouldBeVite);
+        // This assert() is obious and boring
+        (0, assert_js_1.assert)(env.shouldNotBeProduction);
+        (0, assert_js_1.assert)(env.isVikePluginLoaded);
     }
 }
 exports.assertEnv = assertEnv;

package/dist/cjs/utils/nodeEnv.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setNodeEnvToProduction = exports.getNodeEnv = void 0;
+exports.isNodeEnvDev = exports.setNodeEnvToProduction = exports.getNodeEnv = void 0;
 function getNodeEnv() {
     if (typeof process === 'undefined')
         return null;
@@ -14,3 +14,13 @@ function setNodeEnvToProduction() {
     env.NODE_ENV = 'production';
 }
 exports.setNodeEnvToProduction = setNodeEnvToProduction;
+function isNodeEnvDev() {
+    const nodeEnv = getNodeEnv();
+    if (!nodeEnv)
+        return true;
+    if (['development', 'dev'].includes(nodeEnv))
+        return true;
+    // That's quite aggressive, let's see if some user complains
+    return false;
+}
+exports.isNodeEnvDev = isNodeEnvDev;

package/dist/cjs/utils/projectInfo.js

@@ -2,13 +2,11 @@
 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.159';
+const PROJECT_VERSION = '0.4.160-commit-a1101c1';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',
-    projectVersion: PROJECT_VERSION,
-    npmPackageName: 'vike',
-    githubRepository: 'https://github.com/vikejs/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.)

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

@@ -3,7 +3,7 @@ export { plugin };
 // TODO/v1-release: remove
 export { plugin as ssr };
 export { PROJECT_VERSION as version } from './utils.js';
-import { assertUsage, markEnvAsVite } from './utils.js';
+import { assertUsage, getNodeEnv, isNodeEnvDev, markEnvAsVikePluginLoaded, vikeVitePluginLoadedInProductionError } from './utils.js';
 import { buildConfig } from './plugins/buildConfig.js';
 import { previewConfig } from './plugins/previewConfig.js';
 import { autoFullBuild } from './plugins/autoFullBuild.js';
@@ -24,7 +24,8 @@ import { baseUrls } from './plugins/baseUrls.js';
 import { envVarsPlugin } from './plugins/envVars.js';
 import pc from '@brillout/picocolors';
 import { fileEnv } from './plugins/fileEnv.js';
-markEnvAsVite();
+assertNodeEnv();
+markEnvAsVikePluginLoaded();
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeConfig) {
     const plugins = [
@@ -64,3 +65,21 @@ Object.defineProperty(plugin, 'apply', {
         assertUsage(false, `Add ${pc.cyan('vike()')} instead of ${pc.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
     }
 });
+function assertNodeEnv() {
+    const nodeEnv = getNodeEnv();
+    if (nodeEnv === 'test')
+        return;
+    // We should change this to be a warning if it blocks users (e.g. if a bad-citizen tool sets a wrong process.env.NODE_ENV value).
+    assertUsage(
+    /* We can enable this assertion after Vike's CLI is implemented and using Vite's CLI is deprecated (we can then check whether the context is a `$ vike build`).
+    isNodeEnvDev() || isVikeCliBuild(),
+    /*/
+    isNodeEnvDev() || true, 
+    ///*/
+    [
+        pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`),
+        '(which Vike interprets as a non-development environment https://vike.dev/NODE_ENV)',
+        'while the vike/plugin module is loaded.',
+        vikeVitePluginLoadedInProductionError
+    ].join(' '));
+}

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

@@ -3,7 +3,7 @@ import { determineOptimizeDeps } from './determineOptimizeDeps.js';
 import { determineFsAllowList } from './determineFsAllowList.js';
 import { getConfigVike } from '../../../shared/getConfigVike.js';
 import { addSsrMiddleware } from '../../shared/addSsrMiddleware.js';
-import { markEnvAsDev } from '../../utils.js';
+import { markEnvAsViteDev } from '../../utils.js';
 import { improveViteLogs } from '../../shared/loggerVite.js';
 import { isErrorDebug } from '../../shared/isErrorDebug.js';
 import { installHttpRequestAsyncStore } from '../../shared/getHttpRequestAsyncStore.js';
@@ -64,7 +64,7 @@ function devConfig() {
                 }
             },
             configureServer() {
-                markEnvAsDev();
+                markEnvAsViteDev();
             }
         },
         {

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

@@ -1,6 +1,6 @@
 export { importBuild };
 import { serverEntryPlugin, findServerEntry } from '@brillout/vite-plugin-server-entry/plugin.js';
-import { assert, getOutDirs, projectInfo, toPosixPath, viteIsSSR } from '../../utils.js';
+import { assert, getOutDirs, toPosixPath, viteIsSSR } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';
 import { getConfigVike } from '../../../shared/getConfigVike.js';
@@ -32,7 +32,7 @@ function importBuild() {
             getImporterCode: () => {
                 return getEntryCode(config, configVike);
             },
-            libraryName: projectInfo.projectName
+            libraryName: 'Vike'
         })
     ];
 }

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

@@ -0,0 +1,2 @@
+export { getConfigFileExport };
+declare function getConfigFileExport(fileExports: Record<string, unknown>, filePathToShowToUser: string): Record<string, unknown>;

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

@@ -0,0 +1,12 @@
+export { getConfigFileExport };
+import pc from '@brillout/picocolors';
+import { assertPlusFileExport } from '../../../../../shared/page-configs/assertPlusFileExport.js';
+import { assert, 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 }');
+    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/configDefinitionsBuiltIn.d.ts

@@ -24,12 +24,17 @@ type ConfigDefinition = {
      */
     cumulative?: boolean;
     /**
-     * Define a so-called "Shortcut Config".
+     * Function called when the config value is defined.
      *
      * https://vike.dev/meta
      */
     effect?: ConfigEffect;
 };
+/**
+ * Function called when the config value is defined.
+ *
+ * https://vike.dev/meta
+ */
 type ConfigEffect = (config: {
     /** The config value.
      *

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

@@ -0,0 +1,21 @@
+export { loadImportedFile };
+export { loadValueFile };
+export { loadConfigFile };
+export type { ImportedFilesLoaded };
+export type { ConfigFile };
+import type { FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { InterfaceValueFile } from '../getVikeConfig.js';
+type ImportedFilesLoaded = Record<string, Promise<Record<string, unknown>>>;
+type ConfigFile = {
+    fileExports: Record<string, unknown>;
+    filePath: FilePathResolved;
+    extendsFilePaths: string[];
+};
+declare function loadImportedFile(import_: FilePathResolved & {
+    fileExportName: string;
+}, userRootDir: string, importedFilesLoaded: ImportedFilesLoaded): Promise<unknown>;
+declare function loadValueFile(interfaceValueFile: InterfaceValueFile, configName: string, userRootDir: string): Promise<void>;
+declare function loadConfigFile(configFilePath: FilePathResolved, userRootDir: string, visited: string[], isConfigOfExtension: boolean): Promise<{
+    configFile: ConfigFile;
+    extendsConfigs: ConfigFile[];
+}>;

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

@@ -0,0 +1,123 @@
+// Files loadded at config time:
+export { loadImportedFile };
+export { loadValueFile };
+export { loadConfigFile };
+import { assertPosixPath, assert, assertUsage, assertWarning, hasProp, assertIsNotProductionRuntime, isNpmPackageImport } from '../../../../utils.js';
+import { transpileAndExecuteFile } from './transpileAndExecuteFile.js';
+import { assertPlusFileExport } from '../../../../../../shared/page-configs/assertPlusFileExport.js';
+import pc from '@brillout/picocolors';
+import { parseImportData } from './transformImports.js';
+import { getConfigFileExport } from '../getConfigFileExport.js';
+import { assertImportPath, resolveImportPath } from './resolveImportPath.js';
+assertIsNotProductionRuntime();
+// Load fake import
+async function loadImportedFile(import_, userRootDir, importedFilesLoaded) {
+    const f = import_.filePathAbsoluteFilesystem;
+    if (!importedFilesLoaded[f]) {
+        importedFilesLoaded[f] = transpileAndExecuteFile(import_, true, userRootDir).then((r) => r.fileExports);
+    }
+    const fileExports = await importedFilesLoaded[f];
+    const fileExport = fileExports[import_.fileExportName];
+    return fileExport;
+}
+// Load +{configName}.js
+async function loadValueFile(interfaceValueFile, configName, userRootDir) {
+    const { fileExports } = await transpileAndExecuteFile(interfaceValueFile.filePath, true, userRootDir);
+    const { filePathToShowToUser } = interfaceValueFile.filePath;
+    assertPlusFileExport(fileExports, filePathToShowToUser, configName);
+    Object.entries(fileExports).forEach(([exportName, configValue]) => {
+        const configName_ = exportName === 'default' ? configName : exportName;
+        interfaceValueFile.fileExportsByConfigName[configName_] = { configValue };
+    });
+}
+// Load +config.js, including all its extends fake imports
+async function loadConfigFile(configFilePath, userRootDir, visited, isConfigOfExtension) {
+    const { filePathAbsoluteFilesystem } = configFilePath;
+    assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem);
+    const { fileExports } = await transpileAndExecuteFile(configFilePath, false, userRootDir, isConfigOfExtension);
+    const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
+        ...visited,
+        filePathAbsoluteFilesystem
+    ]);
+    const configFile = {
+        fileExports,
+        filePath: configFilePath,
+        extendsFilePaths
+    };
+    return { configFile, extendsConfigs };
+}
+function assertNoInfiniteLoop(visited, filePathAbsoluteFilesystem) {
+    const idx = visited.indexOf(filePathAbsoluteFilesystem);
+    if (idx === -1)
+        return;
+    const loop = visited.slice(idx);
+    assert(loop[0] === filePathAbsoluteFilesystem);
+    assertUsage(idx === -1, `Infinite extends loop ${[...loop, filePathAbsoluteFilesystem].join('>')}`);
+}
+async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir, visited) {
+    const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
+    const extendsConfigFiles = [];
+    extendsImportData.map((importData) => {
+        const { importPath: importPath } = importData;
+        const filePathAbsoluteFilesystem = resolveImportPath(importData, configFilePath);
+        assertImportPath(filePathAbsoluteFilesystem, importData, configFilePath);
+        warnUserLandExtension(importPath, configFilePath);
+        // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
+        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsoluteFilesystem for added clarity
+        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir);
+        const filePathAbsoluteVite = filePathRelativeToUserRootDir ?? importPath;
+        extendsConfigFiles.push({
+            filePathAbsoluteFilesystem,
+            filePathAbsoluteVite,
+            filePathRelativeToUserRootDir,
+            filePathToShowToUser: filePathAbsoluteVite,
+            importPathAbsolute: importPath
+        });
+    });
+    const extendsConfigs = [];
+    await Promise.all(extendsConfigFiles.map(async (configFilePath) => {
+        const result = await loadConfigFile(configFilePath, userRootDir, visited, true);
+        extendsConfigs.push(result.configFile);
+        extendsConfigs.push(...result.extendsConfigs);
+    }));
+    const extendsFilePaths = extendsConfigFiles.map((f) => f.filePathAbsoluteFilesystem);
+    return { extendsConfigs, extendsFilePaths };
+}
+function determineFilePathRelativeToUserDir(filePathAbsoluteFilesystem, userRootDir) {
+    assertPosixPath(filePathAbsoluteFilesystem);
+    assertPosixPath(userRootDir);
+    if (!filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+        return null;
+    }
+    let filePathRelativeToUserRootDir = filePathAbsoluteFilesystem.slice(userRootDir.length);
+    if (!filePathRelativeToUserRootDir.startsWith('/'))
+        filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir;
+    return filePathRelativeToUserRootDir;
+}
+function warnUserLandExtension(importPath, configFilePath) {
+    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 });
+}
+function getExtendsImportData(configFileExports, configFilePath) {
+    const { filePathToShowToUser } = configFilePath;
+    const configFileExport = getConfigFileExport(configFileExports, filePathToShowToUser);
+    const wrongUsage = `${filePathToShowToUser} sets the config ${pc.cyan('extends')} to an invalid value, see https://vike.dev/extends`;
+    let extendList;
+    if (!('extends' in configFileExport)) {
+        return [];
+    }
+    else if (hasProp(configFileExport, 'extends', 'string')) {
+        extendList = [configFileExport.extends];
+    }
+    else if (hasProp(configFileExport, 'extends', 'string[]')) {
+        extendList = configFileExport.extends;
+    }
+    else {
+        assertUsage(false, wrongUsage);
+    }
+    const extendsImportData = extendList.map((importDataSerialized) => {
+        const importData = parseImportData(importDataSerialized);
+        assertUsage(importData, wrongUsage);
+        return importData;
+    });
+    return extendsImportData;
+}

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

@@ -0,0 +1,12 @@
+export { resolveImport };
+export { resolveImportPath };
+export { assertImportPath };
+export { clearFilesEnvMap };
+import type { ConfigEnvInternal, DefinedAtFileFullInfo, FilePathResolved } from '../../../../../../shared/page-configs/PageConfig.js';
+import { type ImportData } from './transformImports.js';
+declare function resolveImport(configValue: unknown, importerFilePath: FilePathResolved, userRootDir: string, configEnv: ConfigEnvInternal, configName: string): null | (DefinedAtFileFullInfo & {
+    fileExportName: string;
+});
+declare function resolveImportPath(importData: ImportData, importerFilePath: FilePathResolved): string | null;
+declare function assertImportPath(filePathAbsoluteFilesystem: string | null, importData: ImportData, importerFilePath: FilePathResolved): asserts filePathAbsoluteFilesystem is string;
+declare function clearFilesEnvMap(): void;

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

@@ -0,0 +1,133 @@
+export { resolveImport };
+export { resolveImportPath };
+export { assertImportPath };
+export { clearFilesEnvMap };
+import pc from '@brillout/picocolors';
+import { assert, assertPosixPath, assertUsage, deepEqual, requireResolve } from '../../../../utils.js';
+import { parseImportData } from './transformImports.js';
+import path from 'path';
+const filesEnvMap = new Map();
+function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
+    if (typeof configValue !== 'string')
+        return null;
+    const importData = parseImportData(configValue);
+    if (!importData)
+        return null;
+    const { importPath, exportName } = importData;
+    const filePathAbsoluteFilesystem = resolveImportPath(importData, importerFilePath);
+    assertFileEnv(filePathAbsoluteFilesystem ?? importPath, configEnv, configName);
+    const fileExportPathToShowToUser = exportName === 'default' || exportName === configName ? [] : [exportName];
+    if (importPath.startsWith('.')) {
+        // We need to resolve relative paths into absolute paths. Because the import paths are included in virtual files:
+        // ```
+        // [vite] Internal server error: Failed to resolve import "./onPageTransitionHooks" from "virtual:vike:pageConfigValuesAll:client:/pages/index". Does the file exist?
+        // ```
+        assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath);
+        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, importerFilePath, userRootDir);
+        const filePath = {
+            filePathAbsoluteFilesystem,
+            filePathRelativeToUserRootDir,
+            filePathAbsoluteVite: filePathRelativeToUserRootDir,
+            filePathToShowToUser: filePathRelativeToUserRootDir,
+            importPathAbsolute: null
+        };
+        return {
+            ...filePath,
+            fileExportName: exportName,
+            fileExportPathToShowToUser
+        };
+    }
+    else {
+        // importPath can be:
+        //  - an npm package import
+        //  - a path alias
+        const filePath = {
+            filePathAbsoluteFilesystem,
+            filePathRelativeToUserRootDir: null,
+            filePathAbsoluteVite: importPath,
+            filePathToShowToUser: importPath,
+            importPathAbsolute: importPath
+        };
+        return {
+            ...filePath,
+            fileExportName: exportName,
+            fileExportPathToShowToUser
+        };
+    }
+}
+function resolveImportPath_relativeToUserRootDir(filePathAbsoluteFilesystem, importData, configFilePath, userRootDir) {
+    assertPosixPath(userRootDir);
+    let filePathRelativeToUserRootDir;
+    if (filePathAbsoluteFilesystem.startsWith(userRootDir)) {
+        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, userRootDir);
+    }
+    else {
+        assertUsage(false, `${configFilePath.filePathToShowToUser} imports from a relative path ${pc.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
+        // None of the following works. Seems to be a Vite bug?
+        // /*
+        // assert(filePathAbsoluteFilesystem.startsWith('/'))
+        // filePath = `/@fs${filePathAbsoluteFilesystem}`
+        // /*/
+        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsoluteFilesystem)
+        // assert(filePathRelativeToUserRootDir.startsWith('../'))
+        // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
+        // //*/
+    }
+    assertPosixPath(filePathRelativeToUserRootDir);
+    assert(filePathRelativeToUserRootDir.startsWith('/'));
+    return filePathRelativeToUserRootDir;
+}
+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
+    // filePathAbsoluteFilesystem is expected to be null when importData.importPath is a Vite path alias
+    const filePathAbsoluteFilesystem = requireResolve(importData.importPath, cwd);
+    return filePathAbsoluteFilesystem;
+}
+function assertImportPath(filePathAbsoluteFilesystem, importData, importerFilePath) {
+    const { importPath: importPath, importStringWasGenerated, importString } = importData;
+    const { filePathToShowToUser } = importerFilePath;
+    if (!filePathAbsoluteFilesystem) {
+        const importPathString = pc.cyan(`'${importPath}'`);
+        const errIntro = importStringWasGenerated
+            ? `The import path ${importPathString} in ${filePathToShowToUser}`
+            : `The import ${pc.cyan(importString)} defined in ${filePathToShowToUser}`;
+        const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
+        if (importPath.startsWith('.')) {
+            assertUsage(false, `${errIntro2} point to an existing file?`);
+        }
+        else {
+            assertUsage(false, `${errIntro2} exist?`);
+        }
+    }
+}
+function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
+    assertPosixPath(filePathForEnvCheck);
+    if (!filesEnvMap.has(filePathForEnvCheck)) {
+        filesEnvMap.set(filePathForEnvCheck, []);
+    }
+    const fileEnv = filesEnvMap.get(filePathForEnvCheck);
+    fileEnv.push({ configEnv, configName });
+    const configDifferentEnv = fileEnv.filter((c) => !deepEqual(c.configEnv, configEnv))[0];
+    if (configDifferentEnv) {
+        assertUsage(false, [
+            `${filePathForEnvCheck} defines the value of configs living in different environments:`,
+            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${pc.cyan(c.configName)} which value lives in environment ${pc.cyan(JSON.stringify(c.configEnv))}`),
+            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/header-file'
+        ].join('\n'));
+    }
+}
+function clearFilesEnvMap() {
+    filesEnvMap.clear();
+}
+function getVitePathFromAbsolutePath(filePathAbsoluteFilesystem, root) {
+    assertPosixPath(filePathAbsoluteFilesystem);
+    assertPosixPath(root);
+    assert(filePathAbsoluteFilesystem.startsWith(root));
+    let vitePath = path.posix.relative(root, filePathAbsoluteFilesystem);
+    assert(!vitePath.startsWith('/') && !vitePath.startsWith('.'));
+    vitePath = '/' + vitePath;
+    return vitePath;
+}