vike 0.4.142-commit-acfc159 → 0.4.143-commit-f03b42d

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, assertDefaultExportUnknown, assertDefaultExportObject, objectEntries, hasProp, arrayIncludes, objectKeys, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, scriptFileExtensions, mergeCumulativeValues, resolve } 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';
@@ -16,15 +16,17 @@ import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } fro
 import { getFilePathToShowToUser } from './getFilePathToShowToUser.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAtString } from '../../../../../shared/page-configs/utils.js';
+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();
 }
@@ -96,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);
             }
         }
         {
@@ -136,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) {
@@ -156,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 };
     });
@@ -196,8 +197,7 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, extensions,
             const dummyData = {
                 pageConfigs: [],
                 pageConfigGlobal: {
-                    onPrerenderStart: null,
-                    onBeforeRoute: null
+                    configValueSources: {}
                 },
                 globalVikeConfig: {}
             };
@@ -217,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)
@@ -322,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);
@@ -365,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 &&
@@ -375,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);
@@ -392,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);
         });
@@ -430,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);
@@ -470,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;
@@ -498,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) {
@@ -520,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'));
@@ -547,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);
@@ -705,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 = {
@@ -821,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,
@@ -870,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;
@@ -968,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) {
@@ -986,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');
@@ -1006,22 +1012,22 @@ function determineIsErrorPage(routeFilesystem) {
     assertPosixPath(routeFilesystem);
     return routeFilesystem.split('/').includes('_error');
 }
-function resolveImport(importData, importerFilePath) {
-    const { filePathAbsolute } = importerFilePath;
-    assertPosixPath(filePathAbsolute);
-    const plusConfigFilDirPathAbsolute = path.posix.dirname(filePathAbsolute);
-    const importedFile = resolve(importData.importFilePath, plusConfigFilDirPathAbsolute);
-    assertImport(importedFile, importData, importerFilePath);
-    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?`);
@@ -1072,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[];

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

@@ -1,4 +1,5 @@
 export { getVirtualFilePageConfigValuesAll };
+export { serializeConfigValueImported };
 import { assert, assertPosixPath } from '../../../utils.js';
 import { generateEagerImport } from '../generateEagerImport.js';
 import { getVirtualFileIdPageConfigValuesAll, isVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
@@ -7,7 +8,7 @@ import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js'
 import { debug } from './debug.js';
 import path from 'path';
 import { getConfigValue } from '../../../../../shared/page-configs/utils.js';
-import { getConfigValueSourcesRelevant } from '../../../shared/getConfigValueSource.js';
+import { getConfigValueSourcesRelevant } from '../../../shared/getConfigValueSourcesRelevant.js';
 import { isConfigEnvMatch } from './isConfigEnvMatch.js';
 async function getVirtualFilePageConfigValuesAll(id, userRootDir, isDev, configVike) {
     const result = isVirtualFileIdPageConfigValuesAll(id);
@@ -32,37 +33,17 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const lines = [];
     const importStatements = [];
     lines.push('export default [');
-    let varCounter = 0;
+    const varCounterContainer = { varCounter: 0 };
     getConfigValueSourcesRelevant(pageConfig).forEach((configValueSource) => {
-        const { valueIsImportedAtRuntime, configName, configEnv, definedAtInfo } = configValueSource;
+        const { valueIsImportedAtRuntime, configEnv, configName } = configValueSource;
         if (!valueIsImportedAtRuntime)
             return;
         if (configValueSource.valueIsFilePath)
             return;
         if (!isConfigEnvMatch(configEnv, isForClientSide, isClientRouting))
             return;
-        const { filePath, fileExportPath } = definedAtInfo;
-        assertPosixPath(filePath);
-        const fileName = path.posix.basename(filePath);
-        const isPlusFile = fileName.startsWith('+');
-        const fileExportName = fileExportPath[0];
-        assert(!configValueSource.valueIsFilePath);
-        assert(fileExportName);
-        const { importVar, importStatement } = 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},`);
-            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) {
@@ -71,3 +52,32 @@ function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAsse
     const code = [...importStatements, ...lines].join('\n');
     return code;
 }
+function serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements) {
+    assert(whitespace.replaceAll(' ', '').length === 0);
+    const { valueIsImportedAtRuntime, definedAtInfo } = configValueSource;
+    assert(valueIsImportedAtRuntime);
+    const { filePath, fileExportPath } = definedAtInfo;
+    assertPosixPath(filePath);
+    const fileName = path.posix.basename(filePath);
+    const isValueFile = fileName.startsWith('+');
+    const fileExportName = fileExportPath[0];
+    assert(!configValueSource.valueIsFilePath);
+    assert(fileExportName);
+    const { importName, importStatement } = 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},`);
+        assert(fileExportName);
+        lines.push(`    exportName: ${JSON.stringify(fileExportName)},`);
+    }
+    lines.push(`  },`);
+    return lines;
+}

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

@@ -1,3 +1,6 @@
 export { getVirtualFilePageConfigs };
+export { getConfigValueSerialized };
+import type { DefinedAtInfo } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ConfigVikeResolved } from '../../../../../shared/ConfigVike.js';
 declare function getVirtualFilePageConfigs(userRootDir: string, isForClientSide: boolean, isDev: boolean, id: string, configVike: ConfigVikeResolved, isClientRouting: boolean): Promise<string>;
+declare function getConfigValueSerialized(value: unknown, configName: string, definedAtInfo: null | DefinedAtInfo): string;