vike 0.4.142 → 0.4.143-commit-dc6fea0

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

@@ -17,21 +17,19 @@ const loggerNotProd_js_1 = require("../../../shared/loggerNotProd.js");
 const removeSuperfluousViteLog_js_1 = require("../../../shared/loggerVite/removeSuperfluousViteLog.js");
 const getFilePathToShowToUser_js_1 = require("./getFilePathToShowToUser.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-const module_1 = require("module");
 const utils_js_2 = require("../../../../../shared/page-configs/utils.js");
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
-const importMetaUrl = `file://${__filename}`;
-const require_ = (0, module_1.createRequire)(importMetaUrl);
+const assertExports_js_1 = require("../../../../../shared/page-configs/assertExports.js");
+const getVirtualFilePageConfigs_js_1 = require("./getVirtualFilePageConfigs.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
 let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
 exports.vikeConfigDependencies = vikeConfigDependencies;
-const codeFilesEnv = new Map();
+const filesEnv = new Map();
 function reloadVikeConfig(userRootDir, extensions) {
     vikeConfigDependencies.clear();
-    codeFilesEnv.clear();
+    filesEnv.clear();
     vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, extensions, true);
     handleReloadSideEffects();
 }
@@ -91,7 +89,8 @@ async function loadInterfaceFiles(userRootDir, isDev, extensions) {
     await Promise.all(configFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
         const configFilePath = {
             filePathAbsolute: filePathAbsolute,
-            filePathRelativeToUserRootDir: filePathRelativeToUserRootDir
+            filePathRelativeToUserRootDir: filePathRelativeToUserRootDir,
+            importPathAbsolute: null
         };
         const { configFile, extendsConfigs } = await loadConfigFile(configFilePath, userRootDir, []);
         const interfaceFile = getInterfaceFileFromConfigFile(configFile, false);
@@ -105,27 +104,28 @@ async function loadInterfaceFiles(userRootDir, isDev, extensions) {
     }));
     // Value files
     await Promise.all(valueFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
-        const configNameDefault = getConfigName(filePathRelativeToUserRootDir);
-        (0, utils_js_1.assert)(configNameDefault);
+        const configName = getConfigName(filePathRelativeToUserRootDir);
+        (0, utils_js_1.assert)(configName);
         const interfaceFile = {
             filePath: {
                 filePathRelativeToUserRootDir,
-                filePathAbsolute
+                filePathAbsolute,
+                importPathAbsolute: null
             },
             configMap: {
-                [configNameDefault]: {}
+                [configName]: {}
             },
             isConfigFile: false,
             isValueFile: true,
-            configNameDefault
+            configName
         };
         {
             // We don't have access to custom config definitions yet
-            //  - We load +someCustomConifg.js later
+            //  - We load +{configName}.js later
             //  - But we do need to eagerly load +meta.js (to get all the custom config definitions)
-            const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn, configNameDefault);
+            const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn, configName);
             if (configDef?.env === 'config-only') {
-                await loadValueFile(interfaceFile, configNameDefault, userRootDir);
+                await loadValueFile(interfaceFile, configName, userRootDir);
             }
         }
         {
@@ -145,14 +145,13 @@ function getConfigDefinition(configDefinitionsRelevant, configName, definedByFil
 function getConfigDefinitionOptional(configDefinitions, configName) {
     return configDefinitions[configName] ?? null;
 }
-async function loadValueFile(interfaceValueFile, configNameDefault, userRootDir) {
+async function loadValueFile(interfaceValueFile, configName, userRootDir) {
     const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(interfaceValueFile.filePath, true, userRootDir);
-    (0, utils_js_1.assertDefaultExportUnknown)(fileExports, (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(interfaceValueFile.filePath));
-    Object.entries(fileExports).forEach(([configName, configValue]) => {
-        if (configName === 'default') {
-            configName = configNameDefault;
-        }
-        interfaceValueFile.configMap[configName] = { configValue };
+    const filePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(interfaceValueFile.filePath);
+    (0, assertExports_js_1.assertExportsOfValueFile)(fileExports, filePathToShowToUser, configName);
+    Object.entries(fileExports).forEach(([exportName, configValue]) => {
+        const configName_ = exportName === 'default' ? configName : exportName;
+        interfaceValueFile.configMap[configName_] = { configValue };
     });
 }
 function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
@@ -165,8 +164,8 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
         isConfigExtend,
         extendsFilePaths
     };
-    const interfaceFilePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(filePath);
-    (0, utils_js_1.assertDefaultExportObject)(fileExports, interfaceFilePathToShowToUser);
+    const filePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(filePath);
+    (0, assertExports_js_1.assertExportsOfConfigFile)(fileExports, filePathToShowToUser);
     Object.entries(fileExports.default).forEach(([configName, configValue]) => {
         interfaceFile.configMap[configName] = { configValue };
     });
@@ -205,8 +204,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, extensions,
             const dummyData = {
                 pageConfigs: [],
                 pageConfigGlobal: {
-                    onPrerenderStart: null,
-                    onBeforeRoute: null
+                    configValueSources: {}
                 },
                 globalVikeConfig: {}
             };
@@ -226,18 +224,18 @@ async function loadVikeConfig(userRootDir, isDev, extensions) {
         await Promise.all(getInterfaceFileList(interfaceFilesRelevant).map(async (interfaceFile) => {
             if (!interfaceFile.isValueFile)
                 return;
-            const { configNameDefault } = interfaceFile;
-            if (isGlobalConfig(configNameDefault))
+            const { configName } = interfaceFile;
+            if (isGlobalConfig(configName))
                 return;
-            const configDef = getConfigDefinition(configDefinitionsRelevant, configNameDefault, (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(interfaceFile.filePath));
+            const configDef = getConfigDefinition(configDefinitionsRelevant, configName, (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(interfaceFile.filePath));
             if (configDef.env !== 'config-only')
                 return;
             const isAlreadyLoaded = interfacefileIsAlreaydLoaded(interfaceFile);
             if (isAlreadyLoaded)
                 return;
             // Value files for built-in confg-only configs should have already been loaded at loadInterfaceFiles()
-            (0, utils_js_1.assert)(!(configNameDefault in configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn));
-            await loadValueFile(interfaceFile, configNameDefault, userRootDir);
+            (0, utils_js_1.assert)(!(configName in configDefinitionsBuiltIn_js_1.configDefinitionsBuiltIn));
+            await loadValueFile(interfaceFile, configName, userRootDir);
         }));
         const configValueSources = {};
         (0, utils_js_1.objectEntries)(configDefinitionsRelevant)
@@ -331,17 +329,16 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
     }
     const globalVikeConfig = {};
     const pageConfigGlobal = {
-        onBeforeRoute: null,
-        onPrerenderStart: null
+        configValueSources: {}
     };
     (0, utils_js_1.objectEntries)(configDefinitionsBuiltIn_js_1.configDefinitionsBuiltInGlobal).forEach(([configName, configDef]) => {
         const sources = resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir);
         const configValueSource = sources?.[0];
         if (!configValueSource)
             return;
-        if ((0, utils_js_1.arrayIncludes)((0, utils_js_1.objectKeys)(pageConfigGlobal), configName)) {
+        if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
             (0, utils_js_1.assert)(!('value' in configValueSource));
-            pageConfigGlobal[configName] = configValueSource;
+            pageConfigGlobal.configValueSources[configName] = [configValueSource];
         }
         else {
             (0, utils_js_1.assert)('value' in configValueSource);
@@ -374,7 +371,7 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
             const interfaceValueFiles = interfaceFilesDefiningConfig
                 .filter((interfaceFile) => interfaceFile.isValueFile &&
                 // We consider side-effect exports (e.g. `export { frontmatter }` of .mdx files) later (i.e. with less priority)
-                interfaceFile.configNameDefault === configName)
+                interfaceFile.configName === configName)
                 .sort(makeOrderDeterministic);
             const interfaceConfigFiles = interfaceFilesDefiningConfig
                 .filter((interfaceFile) => interfaceFile.isConfigFile &&
@@ -384,9 +381,9 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
             const interfaceValueFile = interfaceValueFiles[0];
             const interfaceConfigFile = interfaceConfigFiles[0];
             // Make this value:
-            //   /pages/some-page/+someConfig.js > `export default`
+            //   /pages/some-page/+{configName}.js > `export default`
             // override that value:
-            //   /pages/some-page/+config > `export default { someConfig }`
+            //   /pages/some-page/+config.h.js > `export default { someConfig }`
             const interfaceFileWinner = interfaceValueFile ?? interfaceConfigFile;
             if (interfaceFileWinner) {
                 const interfaceFilesOverriden = [...interfaceValueFiles, ...interfaceConfigFiles].filter((f) => f !== interfaceFileWinner);
@@ -401,7 +398,7 @@ function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant
         interfaceFilesDefiningConfig
             .filter((interfaceFile) => interfaceFile.isValueFile &&
             // Is side-effect export
-            interfaceFile.configNameDefault !== configName)
+            interfaceFile.configName !== configName)
             .forEach((interfaceValueFileSideEffect) => {
             add(interfaceValueFileSideEffect);
         });
@@ -439,22 +436,22 @@ function isInterfaceFileUserLand(interfaceFile) {
 }
 function getConfigValueSource(configName, interfaceFile, configDef, userRootDir) {
     // TODO: rethink file paths of ConfigElement
-    const configFilePath = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
+    const filePathToShowToUser = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
     const conf = interfaceFile.configMap[configName];
     (0, utils_js_1.assert)(conf);
     const configEnv = configDef.env;
     const definedAtInfoConfigFile = {
-        filePath: configFilePath,
+        filePath: filePathToShowToUser,
         fileExportPath: ['default', configName]
     };
     if (configDef._valueIsFilePath) {
         let filePath;
         if (interfaceFile.isConfigFile) {
             const { configValue } = conf;
-            const import_ = getImport(configValue, interfaceFile.filePath, userRootDir);
+            const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
             const configDefinedAt = (0, utils_js_2.getConfigDefinedAtString)(configName, { definedAtInfo: definedAtInfoConfigFile }, true);
             (0, utils_js_1.assertUsage)(import_, `${configDefinedAt} should be an import`);
-            filePath = import_.importFilePath;
+            filePath = import_.filePathToShowToUser;
         }
         else {
             (0, utils_js_1.assert)(interfaceFile.isValueFile);
@@ -479,17 +476,16 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
     if (interfaceFile.isConfigFile) {
         (0, utils_js_1.assert)('configValue' in conf);
         const { configValue } = conf;
-        const import_ = getImport(configValue, interfaceFile.filePath, userRootDir);
+        const import_ = resolveImport(configValue, interfaceFile.filePath, userRootDir, configEnv, configName);
         if (import_) {
-            const { importFilePath, importFileExportName } = import_;
-            assertCodeFileEnv(importFilePath, configEnv, configName);
+            const { filePathToShowToUser, fileExportName: exportName } = import_;
             const configValueSource = {
                 configEnv,
                 valueIsImportedAtRuntime: true,
                 isComputed: false,
                 definedAtInfo: {
-                    filePath: importFilePath,
-                    fileExportPath: [importFileExportName]
+                    filePath: filePathToShowToUser,
+                    fileExportPath: [exportName]
                 }
             };
             return configValueSource;
@@ -507,16 +503,16 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
     }
     else if (interfaceFile.isValueFile) {
         // TODO: rethink file paths of ConfigElement
-        const importFilePath = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
-        const importFileExportName = configName === interfaceFile.configNameDefault ? 'default' : configName;
+        const importPath = interfaceFile.filePath.filePathRelativeToUserRootDir ?? interfaceFile.filePath.filePathAbsolute;
+        const exportName = configName === interfaceFile.configName ? 'default' : configName;
         const valueAlreadyLoaded = 'configValue' in conf;
         const configValueSource = {
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
             isComputed: false,
             definedAtInfo: {
-                filePath: importFilePath,
-                fileExportPath: [importFileExportName]
+                filePath: importPath,
+                fileExportPath: [exportName]
             }
         };
         if (valueAlreadyLoaded) {
@@ -529,16 +525,17 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
     }
     (0, utils_js_1.assert)(false);
 }
-function assertCodeFileEnv(importFilePath, configEnv, configName) {
-    if (!codeFilesEnv.has(importFilePath)) {
-        codeFilesEnv.set(importFilePath, []);
+function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
+    (0, utils_js_1.assertPosixPath)(filePathForEnvCheck);
+    if (!filesEnv.has(filePathForEnvCheck)) {
+        filesEnv.set(filePathForEnvCheck, []);
     }
-    const codeFileEnv = codeFilesEnv.get(importFilePath);
-    codeFileEnv.push({ configEnv, configName });
-    const configDifferentEnv = codeFileEnv.filter((c) => c.configEnv !== configEnv)[0];
+    const fileEnv = filesEnv.get(filePathForEnvCheck);
+    fileEnv.push({ configEnv, configName });
+    const configDifferentEnv = fileEnv.filter((c) => c.configEnv !== configEnv)[0];
     if (configDifferentEnv) {
         (0, utils_js_1.assertUsage)(false, [
-            `${importFilePath} defines the value of configs living in different environments:`,
+            `${filePathForEnvCheck} defines the value of configs living in different environments:`,
             ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.cyan(c.configName)} which value lives in environment ${picocolors_1.default.cyan(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/import-from-same-file'
         ].join('\n'));
@@ -556,53 +553,60 @@ function isDefiningPage(interfaceFiles) {
 function isDefiningPageConfig(configName) {
     return ['Page', 'route'].includes(configName);
 }
-function getImport(configValue, configFilePath, userRootDir) {
+function resolveImport(configValue, importerFilePath, userRootDir, configEnv, configName) {
     if (typeof configValue !== 'string')
         return null;
     const importData = (0, replaceImportStatements_js_1.parseImportData)(configValue);
     if (!importData)
         return null;
-    let { importFilePath, importFileExportName } = importData;
-    if (importFilePath.startsWith('.')) {
+    const { importPath, exportName } = importData;
+    const filePathAbsolute = resolveImportPath(importData, importerFilePath);
+    let filePathToShowToUser;
+    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?
         // ```
-        importFilePath = resolveRelativeCodeFilePath(importData, configFilePath, userRootDir);
+        assertImportPath(filePathAbsolute, importData, importerFilePath);
+        const filePathRelativeToUserRootDir = resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, importerFilePath, userRootDir);
+        filePathToShowToUser = filePathRelativeToUserRootDir;
     }
     else {
-        // importFilePath can be:
+        // importPath can be:
         //  - an npm package import
         //  - a path alias
+        filePathToShowToUser = importPath;
+    }
+    {
+        const filePathForEnvCheck = filePathAbsolute ?? importPath;
+        assertFileEnv(filePathForEnvCheck, configEnv, configName);
     }
     return {
-        importFilePath,
-        importFileExportName
+        filePathToShowToUser,
+        fileExportName: exportName
     };
 }
-function resolveRelativeCodeFilePath(importData, configFilePath, userRootDir) {
-    let importFilePath = resolveImport(importData, configFilePath);
-    // Make it a Vite path
+function resolveImportPath_relativeToUserRootDir(filePathAbsolute, importData, configFilePath, userRootDir) {
     (0, utils_js_1.assertPosixPath)(userRootDir);
-    (0, utils_js_1.assertPosixPath)(importFilePath);
-    if (importFilePath.startsWith(userRootDir)) {
-        importFilePath = getVitePathFromAbsolutePath(importFilePath, userRootDir);
+    let filePathRelativeToUserRootDir;
+    if (filePathAbsolute.startsWith(userRootDir)) {
+        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsolute, userRootDir);
     }
     else {
-        (0, utils_js_1.assertUsage)(false, `${(0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(configFilePath)} imports from a relative path ${picocolors_1.default.cyan(importData.importFilePath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
+        (0, utils_js_1.assertUsage)(false, `${(0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(configFilePath)} imports from a relative path ${picocolors_1.default.cyan(importData.importPath)} outside of ${userRootDir} which is forbidden: import from a relative path inside ${userRootDir}, or import from a dependency's package.json#exports entry instead`);
         // None of the following works. Seems to be a Vite bug?
         // /*
-        // assert(importFilePath.startsWith('/'))
-        // importFilePath = `/@fs${importFilePath}`
+        // assert(filePathAbsolute.startsWith('/'))
+        // filePath = `/@fs${filePathAbsolute}`
         // /*/
-        // importFilePath = path.posix.relative(userRootDir, importFilePath)
-        // assert(importFilePath.startsWith('../'))
-        // importFilePath = '/' + importFilePath
+        // filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsolute)
+        // assert(filePathRelativeToUserRootDir.startsWith('../'))
+        // filePathRelativeToUserRootDir = '/' + filePathRelativeToUserRootDir
         // //*/
     }
-    (0, utils_js_1.assertPosixPath)(importFilePath);
-    (0, utils_js_1.assert)(importFilePath.startsWith('/'));
-    return importFilePath;
+    (0, utils_js_1.assertPosixPath)(filePathRelativeToUserRootDir);
+    (0, utils_js_1.assert)(filePathRelativeToUserRootDir.startsWith('/'));
+    return filePathRelativeToUserRootDir;
 }
 function getVitePathFromAbsolutePath(filePathAbsolute, root) {
     (0, utils_js_1.assertPosixPath)(filePathAbsolute);
@@ -714,10 +718,9 @@ function applyEffect(configModFromEffect, configValueEffectSource, configValueSo
 function applyComputed(pageConfig, configDefinitionsRelevant) {
     (0, utils_js_1.objectEntries)(configDefinitionsRelevant).forEach(([configName, configDef]) => {
         var _a;
-        const computed = configDef._computed;
-        if (!computed)
+        if (!configDef._computed)
             return;
-        const value = computed(pageConfig);
+        const value = configDef._computed(pageConfig);
         if (value === undefined)
             return;
         const configValueSource = {
@@ -801,7 +804,7 @@ function assertNoUnexpectedPlusSign(filePath, fileName) {
     (0, utils_js_1.assertUsage)(!fileName.slice(1).includes('+'), `Character '+' is only allowed at the beginning of filenames: make sure ${filePath} doesn't contain any '+' in its filename other than its first letter`);
 }
 async function loadConfigFile(configFilePath, userRootDir, visited) {
-    const { filePathAbsolute, filePathRelativeToUserRootDir } = configFilePath;
+    const { filePathAbsolute } = configFilePath;
     assertNoInfiniteLoop(visited, filePathAbsolute);
     const { fileExports } = await (0, transpileAndExecuteFile_js_1.transpileAndExecuteFile)(configFilePath, false, userRootDir);
     const { extendsConfigs, extendsFilePaths } = await loadExtendsConfigs(fileExports, configFilePath, userRootDir, [
@@ -810,10 +813,7 @@ async function loadConfigFile(configFilePath, userRootDir, visited) {
     ]);
     const configFile = {
         fileExports,
-        filePath: {
-            filePathRelativeToUserRootDir,
-            filePathAbsolute
-        },
+        filePath: configFilePath,
         extendsFilePaths
     };
     return { configFile, extendsConfigs };
@@ -830,16 +830,20 @@ async function loadExtendsConfigs(configFileExports, configFilePath, userRootDir
     const extendsImportData = getExtendsImportData(configFileExports, configFilePath);
     const extendsConfigFiles = [];
     extendsImportData.map((importData) => {
-        const { importFilePath: importPath } = importData;
+        const { importPath: importPath } = importData;
         // TODO
         //  - validate extends configs
-        const filePathAbsolute = resolveImport(importData, configFilePath);
+        const filePathAbsolute = resolveImportPath(importData, configFilePath);
+        assertImportPath(filePathAbsolute, importData, configFilePath);
         assertExtendsImportPath(importPath, filePathAbsolute, configFilePath);
+        // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
+        // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsolute for added clarity
+        const filePathRelativeToUserRootDir = determineFilePathRelativeToUserDir(filePathAbsolute, userRootDir);
         extendsConfigFiles.push({
             filePathAbsolute,
-            // - filePathRelativeToUserRootDir has no functionality beyond nicer error messages for user
-            // - Using importPath would be visually nicer but it's ambigous => we rather pick filePathAbsolute for added clarity
-            filePathRelativeToUserRootDir: determineFilePathRelativeToUserDir(filePathAbsolute, userRootDir)
+            // TODO: fix type cast
+            filePathRelativeToUserRootDir: filePathRelativeToUserRootDir,
+            importPathAbsolute: importPath
         });
     });
     const extendsConfigs = [];
@@ -879,7 +883,7 @@ function assertExtendsImportPath(importPath, filePath, configFilePath) {
 }
 function getExtendsImportData(configFileExports, configFilePath) {
     const filePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(configFilePath);
-    (0, utils_js_1.assertDefaultExportObject)(configFileExports, filePathToShowToUser);
+    (0, assertExports_js_1.assertExportsOfConfigFile)(configFileExports, filePathToShowToUser);
     const defaultExports = configFileExports.default;
     const wrongUsage = `${filePathToShowToUser} sets the config 'extends' to an invalid value, see https://vike.dev/extends`;
     let extendList;
@@ -959,13 +963,16 @@ function handleUnknownConfig(configName, configNames, definedByFile) {
     else {
         configNameSimilar = (0, utils_js_1.getMostSimilar)(configName, configNames);
     }
-    if (configNameSimilar) {
+    if (configNameSimilar || configName === 'page') {
+        (0, utils_js_1.assert)(configNameSimilar);
         (0, utils_js_1.assert)(configNameSimilar !== configName);
         errMsg += `, did you mean to define ${picocolors_1.default.cyan(configNameSimilar)} instead?`;
+        if (configName === 'page') {
+            errMsg += ` (The name of the config ${picocolors_1.default.cyan('Page')} starts with a capital letter ${picocolors_1.default.cyan('P')} because it usually defines a UI component: a ubiquitous JavaScript convention is to start the name of UI components with a capital letter.)`;
+        }
     }
-    if (configName === 'page') {
-        (0, utils_js_1.assert)(configNameSimilar === 'Page');
-        errMsg += ` (The name of the config ${picocolors_1.default.cyan('Page')} starts with a capital letter ${picocolors_1.default.cyan('P')} because it usually defines a UI component: a ubiquitous JavaScript convention is to start the name of UI components with a capital letter.)`;
+    else {
+        errMsg += `, you need to define the config ${picocolors_1.default.cyan(configName)} by using ${picocolors_1.default.cyan('config.meta')} https://vike.dev/meta`;
     }
     (0, utils_js_1.assertUsage)(false, errMsg);
 }
@@ -974,7 +981,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
     const configFilesystemRoutingRoot = configValueSources[configName]?.[0];
     let filesystemRouteString = (0, filesystemRouting_js_1.getFilesystemRouteString)(locationId);
     if (determineIsErrorPage(filesystemRouteString)) {
-        return { isErrorPage: true, routeFilesystem: null };
+        return { isErrorPage: true, routeFilesystem: undefined };
     }
     let filesystemRouteDefinedBy = (0, filesystemRouting_js_1.getFilesystemRouteDefinedBy)(locationId); // for log404()
     if (configFilesystemRoutingRoot) {
@@ -992,7 +999,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
         routeString: filesystemRouteString,
         definedBy: filesystemRouteDefinedBy
     };
-    return { routeFilesystem, isErrorPage: false };
+    return { routeFilesystem, isErrorPage: undefined };
 }
 function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName) {
     (0, utils_js_1.assert)(configFilesystemRoutingRoot.configEnv === 'config-only');
@@ -1012,33 +1019,22 @@ function determineIsErrorPage(routeFilesystem) {
     (0, utils_js_1.assertPosixPath)(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
-function resolveImport(importData, importerFilePath) {
-    const { filePathAbsolute } = importerFilePath;
-    (0, utils_js_1.assertPosixPath)(filePathAbsolute);
-    let plusConfigFilDirPathAbsolute = path_1.default.posix.dirname(filePathAbsolute);
-    const clean = (0, utils_js_1.addFileExtensionsToRequireResolve)();
-    let importedFile;
-    try {
-        importedFile = require_.resolve(importData.importFilePath, { paths: [plusConfigFilDirPathAbsolute] });
-    }
-    catch {
-        importedFile = null;
-    }
-    finally {
-        clean();
-    }
-    assertImport(importedFile, importData, importerFilePath);
-    importedFile = (0, utils_js_1.toPosixPath)(importedFile);
-    return importedFile;
+function resolveImportPath(importData, importerFilePath) {
+    const importerFilePathAbsolute = importerFilePath.filePathAbsolute;
+    (0, utils_js_1.assertPosixPath)(importerFilePathAbsolute);
+    const cwd = path_1.default.posix.dirname(importerFilePathAbsolute);
+    // filePathAbsolute is expected to be null when importData.importPath is a Vite path alias
+    const filePathAbsolute = (0, utils_js_1.requireResolve)(importData.importPath, cwd);
+    return filePathAbsolute;
 }
-function assertImport(importedFile, importData, importerFilePath) {
-    const { importFilePath: importPath, importWasGenerated, importDataString } = importData;
+function assertImportPath(filePathAbsolute, importData, importerFilePath) {
+    const { importPath: importPath, importStringWasGenerated, importString } = importData;
     const filePathToShowToUser = (0, getFilePathToShowToUser_js_1.getFilePathToShowToUser)(importerFilePath);
-    if (!importedFile) {
+    if (!filePathAbsolute) {
         const importPathString = picocolors_1.default.cyan(`'${importPath}'`);
-        const errIntro = importWasGenerated
+        const errIntro = importStringWasGenerated
             ? `The import path ${importPathString} in ${filePathToShowToUser}`
-            : `The import ${picocolors_1.default.cyan(importDataString)} defined in ${filePathToShowToUser}`;
+            : `The import ${picocolors_1.default.cyan(importString)} defined in ${filePathToShowToUser}`;
         const errIntro2 = `${errIntro} couldn't be resolved: does ${importPathString}`;
         if (importPath.startsWith('.')) {
             (0, utils_js_1.assertUsage)(false, `${errIntro2} point to an existing file?`);
@@ -1090,6 +1086,8 @@ function mergeCumulative(configName, configValueSources) {
         /* This is more confusing than adding value. For example, this explanation shouldn't be shown for the passToClient config.
         const explanation = `(Because the values of ${configNameColored} are cumulative and therefore merged together.)` as const
         */
+        // Make sure configValueSource.value is serializable
+        (0, getVirtualFilePageConfigs_js_1.getConfigValueSerialized)(configValueSource.value, configName, configValueSource.definedAtInfo);
         const assertNoMixing = (isSet) => {
             const vals1 = isSet ? valuesSet : valuesArr;
             const t1 = isSet ? 'a Set' : 'an array';

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

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVirtualFilePageConfigValuesAll = void 0;
+exports.serializeConfigValueImported = exports.getVirtualFilePageConfigValuesAll = void 0;
 const utils_js_1 = require("../../../utils.js");
 const generateEagerImport_js_1 = require("../generateEagerImport.js");
 const virtualFilePageConfigValuesAll_js_1 = require("../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
@@ -12,7 +12,7 @@ const extractAssetsQuery_js_1 = require("../../../../shared/extractAssetsQuery.j
 const debug_js_1 = require("./debug.js");
 const path_1 = __importDefault(require("path"));
 const utils_js_2 = require("../../../../../shared/page-configs/utils.js");
-const getConfigValueSource_js_1 = require("../../../shared/getConfigValueSource.js");
+const getConfigValueSourcesRelevant_js_1 = require("../../../shared/getConfigValueSourcesRelevant.js");
 const isConfigEnvMatch_js_1 = require("./isConfigEnvMatch.js");
 async function getVirtualFilePageConfigValuesAll(id, userRootDir, isDev, configVike) {
     const result = (0, virtualFilePageConfigValuesAll_js_1.isVirtualFileIdPageConfigValuesAll)(id);
@@ -38,37 +38,17 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const lines = [];
     const importStatements = [];
     lines.push('export default [');
-    let varCounter = 0;
-    (0, getConfigValueSource_js_1.getConfigValueSourcesRelevant)(pageConfig).forEach((configValueSource) => {
-        const { valueIsImportedAtRuntime, configName, configEnv, definedAtInfo } = configValueSource;
+    const varCounterContainer = { varCounter: 0 };
+    (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(pageConfig).forEach((configValueSource) => {
+        const { valueIsImportedAtRuntime, configEnv, configName } = configValueSource;
         if (!valueIsImportedAtRuntime)
             return;
         if (configValueSource.valueIsFilePath)
             return;
         if (!(0, isConfigEnvMatch_js_1.isConfigEnvMatch)(configEnv, isForClientSide, isClientRouting))
             return;
-        const { filePath, fileExportPath } = definedAtInfo;
-        (0, utils_js_1.assertPosixPath)(filePath);
-        const fileName = path_1.default.posix.basename(filePath);
-        const isPlusFile = fileName.startsWith('+');
-        const fileExportName = fileExportPath[0];
-        (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
-        (0, utils_js_1.assert)(fileExportName);
-        const { importVar, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(filePath, varCounter++, isPlusFile ? undefined : fileExportName);
-        importStatements.push(importStatement);
-        lines.push(`  {`);
-        lines.push(`    configName: '${configName}',`);
-        lines.push(`    importFilePath: '${filePath}',`);
-        lines.push(`    isPlusFile: ${JSON.stringify(isPlusFile)},`);
-        if (isPlusFile) {
-            lines.push(`    importFileExports: ${importVar},`);
-        }
-        else {
-            lines.push(`    importFileExportValue: ${importVar},`);
-            (0, utils_js_1.assert)(fileExportName);
-            lines.push(`    importFileExportName: ${JSON.stringify(fileExportName)},`);
-        }
-        lines.push(`  },`);
+        const whitespace = '  ';
+        lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
     });
     lines.push('];');
     if (includeAssetsImportedByServer && isForClientSide && !isDev) {
@@ -77,3 +57,33 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const code = [...importStatements, ...lines].join('\n');
     return code;
 }
+function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
+    (0, utils_js_1.assert)(whitespace.replaceAll(' ', '').length === 0);
+    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
+    (0, utils_js_1.assert)(valueIsImportedAtRuntime);
+    const { filePath, fileExportPath } = definedAtInfo;
+    (0, utils_js_1.assertPosixPath)(filePath);
+    const fileName = path_1.default.posix.basename(filePath);
+    const isValueFile = fileName.startsWith('+');
+    const fileExportName = fileExportPath[0];
+    (0, utils_js_1.assert)(!configValueSource.valueIsFilePath);
+    (0, utils_js_1.assert)(fileExportName);
+    const { importName, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(filePath, varCounterContainer.varCounter++, isValueFile ? undefined : fileExportName);
+    importStatements.push(importStatement);
+    const lines = [];
+    lines.push(`  {`);
+    lines.push(`    configName: '${configName}',`);
+    lines.push(`    importPath: '${filePath}',`);
+    lines.push(`    isValueFile: ${JSON.stringify(isValueFile)},`);
+    if (isValueFile) {
+        lines.push(`    importFileExports: ${importName},`);
+    }
+    else {
+        lines.push(`    importFileExportValue: ${importName},`);
+        (0, utils_js_1.assert)(fileExportName);
+        lines.push(`    exportName: ${JSON.stringify(fileExportName)},`);
+    }
+    lines.push(`  },`);
+    return lines;
+}
+exports.serializeConfigValueImported = serializeConfigValueImported;