vike 0.4.142 → 0.4.143-commit-f03b42d

package/dist/esm/node/plugin/plugins/importUserCode/generateEagerImport.d.ts

@@ -1,5 +1,16 @@
 export { generateEagerImport };
-declare function generateEagerImport(importPath: string, varCounter?: number, importName?: string): {
-    importVar: string;
+/**
+ * Naming:
+ *   `import { someExport as someImport } from './some-file'`
+ * <=>
+ *   `{`
+ *      `importPath: './some-file',`
+ *      `exportName: 'someExport',`
+ *      `importName: 'someImport',`
+ *    `}`
+ * We discard the information that the import variable is called `someImport` because we don't need it.
+ */
+declare function generateEagerImport(importPath: string, varCounter?: number, exportName?: string): {
+    importName: string;
     importStatement: string;
 };

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

@@ -1,18 +1,29 @@
 export { generateEagerImport };
 let varCounterGlobal = 0;
-function generateEagerImport(importPath, varCounter, importName) {
+/**
+ * Naming:
+ *   `import { someExport as someImport } from './some-file'`
+ * <=>
+ *   `{`
+ *      `importPath: './some-file',`
+ *      `exportName: 'someExport',`
+ *      `importName: 'someImport',`
+ *    `}`
+ * We discard the information that the import variable is called `someImport` because we don't need it.
+ */
+function generateEagerImport(importPath, varCounter, exportName) {
     if (varCounter === undefined)
         varCounter = varCounterGlobal++;
-    const importVar = `import_${varCounter}`;
+    const importName = `import_${varCounter}`;
     const importLiteral = (() => {
-        if (!importName || importName === '*') {
-            return `* as ${importVar}`;
+        if (!exportName || exportName === '*') {
+            return `* as ${importName}`;
         }
-        if (importName === 'default') {
-            return importVar;
+        if (exportName === 'default') {
+            return importName;
         }
-        return `{ ${importName} as ${importVar} }`;
+        return `{ ${exportName} as ${importName} }`;
     })();
     const importStatement = `import ${importLiteral} from '${importPath}';`;
-    return { importVar, importStatement };
+    return { importName, importStatement };
 }

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

@@ -121,9 +121,9 @@ function addImport(importPath, fileType, exportNames, isBuild) {
             return `() => import('${importPath}${query}')`;
         }
         else {
-            const { importVar, importStatement } = generateEagerImport(`${importPath}${query}`);
+            const { importName, importStatement } = generateEagerImport(`${importPath}${query}`);
             fileContent += importStatement + '\n';
-            return importVar;
+            return importName;
         }
     })();
     fileContent += `${mapVar}['${importPath}'] = ${value};\n`;

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

@@ -3,7 +3,7 @@ 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, getFilePathVite, getVirtualFileId, isDev1, isDev1_onConfigureServer, isVirtualFileId, resolveVirtualFileId } from '../../utils.js';
+import { assert, assertPosixPath, getFilePathRelativeToUserRootDir, 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';
@@ -116,7 +116,7 @@ function isVikeConfigModule(filePathAbsolute) {
 }
 function reloadConfig(filePath, config, configVike, op) {
     {
-        const filePathToShowToUser = pc.dim(getFilePathVite(filePath, config.root, true));
+        const filePathToShowToUser = pc.dim(getFilePathRelativeToUserRootDir(filePath, config.root, true));
         const msg = `${op} ${filePathToShowToUser}`;
         logConfigInfo(msg, 'info');
     }

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

@@ -1,7 +1,15 @@
 export { getFilePathToShowToUser };
 export type { FilePath };
 type FilePath = {
+    /** The file's path relative to the filesystem root.
+     *
+     * Example: `/home/rom/code/my-app/pages/some-page/Page.js`
+     */
     filePathAbsolute: string;
+    /** The file's path relative to the Vite's root (i.e. the user's project root directory).
+     *
+     * Example: `/pages/some-page/Page.js`
+     */
     filePathRelativeToUserRootDir: null | string;
 };
 declare function getFilePathToShowToUser(filePath: FilePath): string;

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

@@ -2,11 +2,11 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import type { PageConfigGlobalData, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
+import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ExtensionResolved } from '../../../../../shared/ConfigVike.js';
 type VikeConfig = {
     pageConfigs: PageConfigBuildTime[];
-    pageConfigGlobal: PageConfigGlobalData;
+    pageConfigGlobal: PageConfigGlobalBuildTime;
     globalVikeConfig: Record<string, unknown>;
 };
 declare const vikeConfigDependencies: Set<string>;

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

@@ -2,7 +2,7 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import { assertPosixPath, assert, isObject, assertUsage, toPosixPath, assertWarning, addFileExtensionsToRequireResolve, assertDefaultExportUnknown, assertDefaultExportObject, objectEntries, hasProp, arrayIncludes, objectKeys, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, scriptFileExtensions, mergeCumulativeValues } from '../../../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, toPosixPath, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, scriptFileExtensions, mergeCumulativeValues, requireResolve } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import glob from 'fast-glob';
@@ -15,20 +15,18 @@ import { logConfigError, logConfigErrorRecover } from '../../../shared/loggerNot
 import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } from '../../../shared/loggerVite/removeSuperfluousViteLog.js';
 import { getFilePathToShowToUser } from './getFilePathToShowToUser.js';
 import pc from '@brillout/picocolors';
-import { createRequire } from 'module';
 import { getConfigDefinedAtString } from '../../../../../shared/page-configs/utils.js';
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
-const importMetaUrl = import.meta.url;
-const require_ = createRequire(importMetaUrl);
+import { assertExportsOfConfigFile, assertExportsOfValueFile } from '../../../../../shared/page-configs/assertExports.js';
+import { getConfigValueSerialized } from './getVirtualFilePageConfigs.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
 let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
-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();
 }
@@ -100,27 +98,27 @@ async function loadInterfaceFiles(userRootDir, isDev, extensions) {
     }));
     // Value files
     await Promise.all(valueFiles.map(async ({ filePathAbsolute, filePathRelativeToUserRootDir }) => {
-        const configNameDefault = getConfigName(filePathRelativeToUserRootDir);
-        assert(configNameDefault);
+        const configName = getConfigName(filePathRelativeToUserRootDir);
+        assert(configName);
         const interfaceFile = {
             filePath: {
                 filePathRelativeToUserRootDir,
                 filePathAbsolute
             },
             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, configNameDefault);
+            const configDef = getConfigDefinitionOptional(configDefinitionsBuiltIn, configName);
             if (configDef?.env === 'config-only') {
-                await loadValueFile(interfaceFile, configNameDefault, userRootDir);
+                await loadValueFile(interfaceFile, configName, userRootDir);
             }
         }
         {
@@ -140,14 +138,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 transpileAndExecuteFile(interfaceValueFile.filePath, true, userRootDir);
-    assertDefaultExportUnknown(fileExports, getFilePathToShowToUser(interfaceValueFile.filePath));
-    Object.entries(fileExports).forEach(([configName, configValue]) => {
-        if (configName === 'default') {
-            configName = configNameDefault;
-        }
-        interfaceValueFile.configMap[configName] = { configValue };
+    const filePathToShowToUser = getFilePathToShowToUser(interfaceValueFile.filePath);
+    assertExportsOfValueFile(fileExports, filePathToShowToUser, configName);
+    Object.entries(fileExports).forEach(([exportName, configValue]) => {
+        const configName_ = exportName === 'default' ? configName : exportName;
+        interfaceValueFile.configMap[configName_] = { configValue };
     });
 }
 function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
@@ -160,8 +157,8 @@ function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
         isConfigExtend,
         extendsFilePaths
     };
-    const interfaceFilePathToShowToUser = getFilePathToShowToUser(filePath);
-    assertDefaultExportObject(fileExports, interfaceFilePathToShowToUser);
+    const filePathToShowToUser = getFilePathToShowToUser(filePath);
+    assertExportsOfConfigFile(fileExports, filePathToShowToUser);
     Object.entries(fileExports.default).forEach(([configName, configValue]) => {
         interfaceFile.configMap[configName] = { configValue };
     });
@@ -200,8 +197,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, extensions,
             const dummyData = {
                 pageConfigs: [],
                 pageConfigGlobal: {
-                    onPrerenderStart: null,
-                    onBeforeRoute: null
+                    configValueSources: {}
                 },
                 globalVikeConfig: {}
             };
@@ -221,18 +217,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, getFilePathToShowToUser(interfaceFile.filePath));
+            const configDef = getConfigDefinition(configDefinitionsRelevant, configName, 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()
-            assert(!(configNameDefault in configDefinitionsBuiltIn));
-            await loadValueFile(interfaceFile, configNameDefault, userRootDir);
+            assert(!(configName in configDefinitionsBuiltIn));
+            await loadValueFile(interfaceFile, configName, userRootDir);
         }));
         const configValueSources = {};
         objectEntries(configDefinitionsRelevant)
@@ -326,17 +322,16 @@ function getGlobalConfigs(interfaceFilesByLocationId, userRootDir) {
     }
     const globalVikeConfig = {};
     const pageConfigGlobal = {
-        onBeforeRoute: null,
-        onPrerenderStart: null
+        configValueSources: {}
     };
     objectEntries(configDefinitionsBuiltInGlobal).forEach(([configName, configDef]) => {
         const sources = resolveConfigValueSources(configName, configDef, interfaceFilesGlobal, userRootDir);
         const configValueSource = sources?.[0];
         if (!configValueSource)
             return;
-        if (arrayIncludes(objectKeys(pageConfigGlobal), configName)) {
+        if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
             assert(!('value' in configValueSource));
-            pageConfigGlobal[configName] = configValueSource;
+            pageConfigGlobal.configValueSources[configName] = [configValueSource];
         }
         else {
             assert('value' in configValueSource);
@@ -369,7 +364,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 &&
@@ -379,9 +374,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);
@@ -396,7 +391,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);
         });
@@ -434,22 +429,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];
     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 = getConfigDefinedAtString(configName, { definedAtInfo: definedAtInfoConfigFile }, true);
             assertUsage(import_, `${configDefinedAt} should be an import`);
-            filePath = import_.importFilePath;
+            filePath = import_.filePathToShowToUser;
         }
         else {
             assert(interfaceFile.isValueFile);
@@ -474,17 +469,16 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
     if (interfaceFile.isConfigFile) {
         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;
@@ -502,16 +496,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) {
@@ -524,16 +518,17 @@ function getConfigValueSource(configName, interfaceFile, configDef, userRootDir)
     }
     assert(false);
 }
-function assertCodeFileEnv(importFilePath, configEnv, configName) {
-    if (!codeFilesEnv.has(importFilePath)) {
-        codeFilesEnv.set(importFilePath, []);
+function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
+    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) {
         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 ${pc.cyan(c.configName)} which value lives in environment ${pc.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'));
@@ -551,53 +546,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 = 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) {
     assertPosixPath(userRootDir);
-    assertPosixPath(importFilePath);
-    if (importFilePath.startsWith(userRootDir)) {
-        importFilePath = getVitePathFromAbsolutePath(importFilePath, userRootDir);
+    let filePathRelativeToUserRootDir;
+    if (filePathAbsolute.startsWith(userRootDir)) {
+        filePathRelativeToUserRootDir = getVitePathFromAbsolutePath(filePathAbsolute, userRootDir);
     }
     else {
-        assertUsage(false, `${getFilePathToShowToUser(configFilePath)} imports from a relative path ${pc.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`);
+        assertUsage(false, `${getFilePathToShowToUser(configFilePath)} 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(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
         // //*/
     }
-    assertPosixPath(importFilePath);
-    assert(importFilePath.startsWith('/'));
-    return importFilePath;
+    assertPosixPath(filePathRelativeToUserRootDir);
+    assert(filePathRelativeToUserRootDir.startsWith('/'));
+    return filePathRelativeToUserRootDir;
 }
 function getVitePathFromAbsolutePath(filePathAbsolute, root) {
     assertPosixPath(filePathAbsolute);
@@ -709,10 +711,9 @@ function applyEffect(configModFromEffect, configValueEffectSource, configValueSo
 function applyComputed(pageConfig, configDefinitionsRelevant) {
     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 = {
@@ -825,10 +826,11 @@ 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);
         extendsConfigFiles.push({
             filePathAbsolute,
@@ -874,7 +876,7 @@ function assertExtendsImportPath(importPath, filePath, configFilePath) {
 }
 function getExtendsImportData(configFileExports, configFilePath) {
     const filePathToShowToUser = getFilePathToShowToUser(configFilePath);
-    assertDefaultExportObject(configFileExports, filePathToShowToUser);
+    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;
@@ -954,13 +956,16 @@ function handleUnknownConfig(configName, configNames, definedByFile) {
     else {
         configNameSimilar = getMostSimilar(configName, configNames);
     }
-    if (configNameSimilar) {
+    if (configNameSimilar || configName === 'page') {
+        assert(configNameSimilar);
         assert(configNameSimilar !== configName);
         errMsg += `, did you mean to define ${pc.cyan(configNameSimilar)} instead?`;
+        if (configName === 'page') {
+            errMsg += ` (The name of the config ${pc.cyan('Page')} starts with a capital letter ${pc.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') {
-        assert(configNameSimilar === 'Page');
-        errMsg += ` (The name of the config ${pc.cyan('Page')} starts with a capital letter ${pc.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 ${pc.cyan(configName)} by using ${pc.cyan('config.meta')} https://vike.dev/meta`;
     }
     assertUsage(false, errMsg);
 }
@@ -969,7 +974,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
     const configFilesystemRoutingRoot = configValueSources[configName]?.[0];
     let filesystemRouteString = getFilesystemRouteString(locationId);
     if (determineIsErrorPage(filesystemRouteString)) {
-        return { isErrorPage: true, routeFilesystem: null };
+        return { isErrorPage: true, routeFilesystem: undefined };
     }
     let filesystemRouteDefinedBy = getFilesystemRouteDefinedBy(locationId); // for log404()
     if (configFilesystemRoutingRoot) {
@@ -987,7 +992,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
         routeString: filesystemRouteString,
         definedBy: filesystemRouteDefinedBy
     };
-    return { routeFilesystem, isErrorPage: false };
+    return { routeFilesystem, isErrorPage: undefined };
 }
 function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName) {
     assert(configFilesystemRoutingRoot.configEnv === 'config-only');
@@ -1007,33 +1012,22 @@ function determineIsErrorPage(routeFilesystem) {
     assertPosixPath(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
-function resolveImport(importData, importerFilePath) {
-    const { filePathAbsolute } = importerFilePath;
-    assertPosixPath(filePathAbsolute);
-    let plusConfigFilDirPathAbsolute = path.posix.dirname(filePathAbsolute);
-    const clean = addFileExtensionsToRequireResolve();
-    let importedFile;
-    try {
-        importedFile = require_.resolve(importData.importFilePath, { paths: [plusConfigFilDirPathAbsolute] });
-    }
-    catch {
-        importedFile = null;
-    }
-    finally {
-        clean();
-    }
-    assertImport(importedFile, importData, importerFilePath);
-    importedFile = toPosixPath(importedFile);
-    return importedFile;
+function resolveImportPath(importData, importerFilePath) {
+    const importerFilePathAbsolute = importerFilePath.filePathAbsolute;
+    assertPosixPath(importerFilePathAbsolute);
+    const cwd = path.posix.dirname(importerFilePathAbsolute);
+    // filePathAbsolute is expected to be null when importData.importPath is a Vite path alias
+    const filePathAbsolute = 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 = getFilePathToShowToUser(importerFilePath);
-    if (!importedFile) {
+    if (!filePathAbsolute) {
         const importPathString = pc.cyan(`'${importPath}'`);
-        const errIntro = importWasGenerated
+        const errIntro = importStringWasGenerated
             ? `The import path ${importPathString} in ${filePathToShowToUser}`
-            : `The import ${pc.cyan(importDataString)} defined 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?`);
@@ -1084,6 +1078,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
+        getConfigValueSerialized(configValueSource.value, configName, configValueSource.definedAtInfo);
         const assertNoMixing = (isSet) => {
             const vals1 = isSet ? valuesSet : valuesArr;
             const t1 = isSet ? 'a Set' : 'an array';

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

@@ -1,3 +1,8 @@
 export { getVirtualFilePageConfigValuesAll };
+export { serializeConfigValueImported };
+import type { ConfigValueSource } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ConfigVikeResolved } from '../../../../../shared/ConfigVike.js';
 declare function getVirtualFilePageConfigValuesAll(id: string, userRootDir: string, isDev: boolean, configVike: ConfigVikeResolved): Promise<string>;
+declare function serializeConfigValueImported(configValueSource: ConfigValueSource, configName: string, whitespace: string, varCounterContainer: {
+    varCounter: number;
+}, importStatements: string[]): string[];