vike 0.4.146 → 0.4.147-commit-f9a91f3

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

@@ -2,10 +2,9 @@ export { getVikeConfig };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
-import { assertPosixPath, assert, isObject, assertUsage, toPosixPath, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, scriptFileExtensions, mergeCumulativeValues, requireResolve, getOutDirs } from '../../../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, arrayIncludes, assertIsNotProductionRuntime, getMostSimilar, isNpmPackageImport, joinEnglish, lowerFirst, mergeCumulativeValues, requireResolve, getOutDirs, deepEqual, assertKeys } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
-import glob from 'fast-glob';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
 import { isTmpFile, transpileAndExecuteFile } from './transpileAndExecuteFile.js';
 import { parseImportData } from './replaceImportStatements.js';
@@ -16,8 +15,9 @@ import { removeSuperfluousViteLog_enable, removeSuperfluousViteLog_disable } fro
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAtString } from '../../../../../shared/page-configs/helpers.js';
 import { assertExportsOfConfigFile, assertExportsOfValueFile } from '../../../../../shared/page-configs/assertExports.js';
-import { getConfigValueSerialized } from './getVirtualFilePageConfigs.js';
 import { getConfigVike } from '../../../../shared/getConfigVike.js';
+import { assertConfigValueIsSerializable } from './getConfigValuesSerialized.js';
+import { crawlPlusFiles } from './getVikeConfig/crawlPlusFiles.js';
 assertIsNotProductionRuntime();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -70,7 +70,7 @@ async function getVikeConfig(config, isDev, tolerateInvalidConfig = false, exten
     return await vikeConfigPromise;
 }
 async function loadInterfaceFiles(userRootDir, outDirRoot, isDev, extensions) {
-    const plusFiles = await findPlusFiles(userRootDir, [outDirRoot], isDev, extensions);
+    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, isDev, extensions);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -151,12 +151,12 @@ async function loadImportedFile(filePath, userRootDir, importedFilesLoaded) {
     return fileExports;
 }
 function isConfigEnv(configDef, configName) {
-    if (configDef.cumulative)
-        return true;
-    if (configDef.env === 'config-only')
-        return true;
-    // TODO: replace with proper `env: { config: boolean }` implementation
-    return configName === 'clientRouting';
+    const configEnv = configDef.env;
+    if (configDef.cumulative) {
+        // In principle we could lift that requirement (but it requires non-trivial modifications)
+        assertUsage(configEnv.config, `Config ${pc.cyan(configName)} needs its ${pc.cyan('env')} to have ${pc.cyan('{ config: true }')} (because ${pc.cyan(configName)} is a ${pc.cyan('cumulative')} config)`);
+    }
+    return !!configEnv.config;
 }
 function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
@@ -509,6 +509,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     else if (interfaceFile.isValueFile) {
         const valueAlreadyLoaded = 'configValue' in conf;
+        assert(valueAlreadyLoaded === !!configEnv.config);
         const configValueSource = {
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
@@ -523,9 +524,6 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         if (valueAlreadyLoaded) {
             configValueSource.value = conf.configValue;
         }
-        else {
-            assert(configEnv !== 'config-only');
-        }
         return configValueSource;
     }
     assert(false);
@@ -537,12 +535,12 @@ function assertFileEnv(filePathForEnvCheck, configEnv, configName) {
     }
     const fileEnv = filesEnv.get(filePathForEnvCheck);
     fileEnv.push({ configEnv, configName });
-    const configDifferentEnv = fileEnv.filter((c) => c.configEnv !== configEnv)[0];
+    const configDifferentEnv = fileEnv.filter((c) => !deepEqual(c.configEnv, configEnv))[0];
     if (configDifferentEnv) {
         assertUsage(false, [
             `${filePathForEnvCheck} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${pc.cyan(c.configName)} which value lives in environment ${pc.cyan(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'
+            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${pc.cyan(c.configName)} which value lives in environment ${pc.cyan(JSON.stringify(c.configEnv))}`),
+            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/header-file'
         ].join('\n'));
     }
 }
@@ -678,30 +676,17 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
             assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}`)} to a value with an invalid type ${pc.cyan(typeof def)}: it should be an object instead.`);
         }
         // env
+        let configEnv;
         {
-            const envValues = [
-                'client-only',
-                'server-only',
-                'server-and-client',
-                'config-only'
-            ];
-            const fix = [
-                `Set the value of ${pc.cyan(`meta.${configName}.env`)} to `,
-                joinEnglish(envValues.map((s) => pc.cyan(`'${s}'`)), 'or'),
-                '.'
-            ].join('');
+            assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
             if (!('env' in def)) {
-                assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                assertUsage(false, `${configMetaDefinedAt} doesn't set ${pc.cyan(`meta.${configName}.env`)} but it's required. ${fix}`);
-            }
-            if (!hasProp(def, 'env', 'string')) {
-                assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.env`)} to an invalid type ${pc.cyan(typeof def.env)}. ${fix}`);
-            }
-            if (!envValues.includes(def.env)) {
-                assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.env`)} to an unknown value ${pc.cyan(`'${def.env}'`)}. ${fix}`);
+                assertUsage(false, `${configMetaDefinedAt} doesn't set ${pc.cyan(`meta.${configName}.env`)} but it's required.`);
             }
+            configEnv = getConfigEnvValue(def.env, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.env`)} to`);
+            // Overwrite deprecated value with valid value
+            // TODO/v1-release: remove once support for the deprecated values is removed
+            if (typeof def.env === 'string')
+                def.env = configEnv;
         }
         // effect
         if ('effect' in def) {
@@ -709,9 +694,9 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
                 assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
                 assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.effect`)} to an invalid type ${pc.cyan(typeof def.effect)}: it should be a function instead`);
             }
-            if (def.env !== 'config-only') {
+            if (!configEnv.config) {
                 assert(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.effect`)} but it's only supported if meta.${configName}.env is ${pc.cyan('config-only')} (but it's ${pc.cyan(def.env)} instead)`);
+                assertUsage(false, `${configMetaDefinedAt} sets ${pc.cyan(`meta.${configName}.effect`)} but it's only supported if meta.${configName}.env has ${pc.cyan('{ config: true }')} (but it's ${pc.cyan(JSON.stringify(configEnv))} instead)`);
             }
         }
     });
@@ -722,8 +707,8 @@ function applyEffectsAll(configValueSources, configDefinitionsRelevant) {
             return;
         // The value needs to be loaded at config time, that's why we only support effect for configs that are config-only for now.
         // (We could support effect for non config-only by always loading its value at config time, regardless of the config's `env` value.)
-        assertUsage(configDef.env === 'config-only', [
-            `Cannot add effect to ${pc.cyan(configName)} because its ${pc.cyan('env')} is ${pc.cyan(configDef.env)}: effects can only be added to configs with an ${pc.cyan('env')} value of ${pc.cyan('config-only')}.`
+        assertUsage(configDef.env.config, [
+            `Cannot add effect to ${pc.cyan(configName)} because its ${pc.cyan('env')} is ${pc.cyan(JSON.stringify(configDef.env))}: effects can only be added to configs with an ${pc.cyan('env')} with ${pc.cyan('{ config: true }')}.`
         ].join(' '));
         const source = configValueSources[configName]?.[0];
         if (!source)
@@ -791,39 +776,9 @@ function getComputed(configValueSources, configDefinitionsRelevant) {
     });
     return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, ignoreDirs, isDev, extensions) {
-    const timeBase = new Date().getTime();
-    assertPosixPath(userRootDir);
-    const ignorePatterns = [];
-    for (const dir of ignoreDirs) {
-        assertPosixPath(dir);
-        ignorePatterns.push(`${path.posix.relative(userRootDir, dir)}/**`);
-    }
-    const result = await glob(`**/+*.${scriptFileExtensions}`, {
-        ignore: [
-            '**/node_modules/**',
-            // Allow:
-            // ```
-            // +Page.js
-            // +Page.telefunc.js
-            // ```
-            '**/*.telefunc.*',
-            ...ignorePatterns
-        ],
-        cwd: userRootDir,
-        dot: false
-    });
-    const time = new Date().getTime() - timeBase;
-    if (isDev) {
-        // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
-        assertWarning(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on Vike's GitHub.`, {
-            onlyOnce: 'slow-page-files-search'
-        });
-    }
-    const plusFiles = result.map((p) => {
-        p = toPosixPath(p);
-        const filePathRelativeToUserRootDir = path.posix.join('/', p);
-        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, p);
+async function findPlusFiles(userRootDir, outDirRoot, isDev, extensions) {
+    const files = await crawlPlusFiles(userRootDir, outDirRoot, isDev);
+    const plusFiles = files.map(({ filePathRelativeToUserRootDir, filePathAbsoluteFilesystem }) => {
         return {
             filePathRelativeToUserRootDir,
             filePathAbsoluteVite: filePathRelativeToUserRootDir,
@@ -1041,7 +996,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
     return { routeFilesystem, isErrorPage: undefined };
 }
 function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName) {
-    assert(configFilesystemRoutingRoot.configEnv === 'config-only');
+    assert(configFilesystemRoutingRoot.configEnv.config);
     // Eagerly loaded since it's config-only
     assert('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
@@ -1137,7 +1092,7 @@ function mergeCumulative(configName, configValueSources) {
         // We could, in principle, also support cumulative for values that aren't loaded at config-time but it isn't completely trivial to implement.
         assert('value' in configValueSource);
         // Make sure configValueSource.value is serializable
-        getConfigValueSerialized(configValueSource.value, configName, getDefinedAt(configValueSource));
+        assertConfigValueIsSerializable(configValueSource.value, configName, getDefinedAt(configValueSource));
         const assertNoMixing = (isSet) => {
             const vals1 = isSet ? valuesSet : valuesArr;
             const t1 = isSet ? 'a Set' : 'an array';
@@ -1178,3 +1133,35 @@ function mergeCumulative(configName, configValueSources) {
     }
     assert(false);
 }
+function getConfigEnvValue(val, errMsgIntro) {
+    const errInvalidValue = `${errMsgIntro} an invalid value ${pc.cyan(JSON.stringify(val))}`;
+    // Legacy outdated values
+    if (typeof val === 'string') {
+        const valConverted = (() => {
+            if (val === 'client-only')
+                return { client: true };
+            if (val === 'server-only')
+                return { server: true };
+            if (val === 'server-and-client')
+                return { server: true, client: true };
+            if (val === 'config-only')
+                return { config: true };
+            if (val === '_routing-lazy')
+                return { server: true, client: 'if-client-routing' };
+            if (val === '_routing-eager')
+                return { server: true, client: 'if-client-routing', eager: true };
+            assertUsage(false, errInvalidValue);
+        })();
+        assertWarning(false, `${errMsgIntro} ${pc.cyan(val)} which is deprecated and will be removed in the next major release`, { onlyOnce: true });
+        return valConverted;
+    }
+    assertUsage(isObject(val), `${errMsgIntro} an invalid type ${pc.cyan(typeof val)}`);
+    assertKeys(val, ['config', 'server', 'client'], `${errInvalidValue}:`);
+    assertUsage(hasProp(val, 'config', 'undefined') || hasProp(val, 'config', 'boolean'), errInvalidValue);
+    assertUsage(hasProp(val, 'server', 'undefined') || hasProp(val, 'server', 'boolean'), errInvalidValue);
+    assertUsage(hasProp(val, 'client', 'undefined') || hasProp(val, 'client', 'boolean'), errInvalidValue);
+    /* Uncomment to allow users to set an eager config. Same for `{ client: 'if-client-routing' }`.
+    assertUsage(hasProp(val, 'eager', 'undefined') || hasProp(val, 'eager', 'boolean'), errInvalidValue)
+    */
+    return val;
+}

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

@@ -5,10 +5,11 @@ import { getVikeConfig } from './getVikeConfig.js';
 import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js';
 import { debug } from './debug.js';
 import { getConfigValue } from '../../../../../shared/page-configs/helpers.js';
-import { getConfigValueSourcesRelevant } from '../../../shared/getConfigValueSourcesRelevant.js';
+import { getConfigValueSourcesNotOverriden } from '../../../shared/getConfigValueSourcesNotOverriden.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
 import { getConfigVike } from '../../../../shared/getConfigVike.js';
+import { getConfigValuesSerialized } from './getConfigValuesSerialized.js';
 async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const result = isVirtualFileIdPageConfigValuesAll(id);
     assert(result);
@@ -28,27 +29,52 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     return code;
 }
 function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
-    const configValue = getConfigValue(pageConfig, 'clientRouting', 'boolean');
-    const isClientRouting = configValue?.value ?? false;
     const lines = [];
     const importStatements = [];
-    lines.push('export default [');
-    const varCounterContainer = { varCounter: 0 };
-    getConfigValueSourcesRelevant(pageConfig).forEach((configValueSource) => {
-        const { valueIsImportedAtRuntime, configEnv, configName } = configValueSource;
-        if (!valueIsImportedAtRuntime)
-            return;
-        if (configValueSource.valueIsFilePath)
-            return;
-        if (!isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: false }))
-            return;
-        const whitespace = '  ';
-        lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
-    });
+    const isClientRouting = getConfigValue(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+    lines.push('export const configValuesImported = [');
+    lines.push(getConfigValuesImported(pageConfig, isForClientSide, isClientRouting, importStatements));
     lines.push('];');
+    lines.push('export const configValuesSerialized = {');
+    lines.push(getConfigValuesSerialized(pageConfig, (configEnv, configValueSource) => isEnvMatch(configEnv, !configValueSource ? false : checkWhetherIsImport(configValueSource), {
+        isImport: false,
+        isForClientSide,
+        isClientRouting
+    })));
+    lines.push('};');
     if (includeAssetsImportedByServer && isForClientSide && !isDev) {
-        lines.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigValuesAll(pageId, false))}'`);
+        importStatements.push(`import '${extractAssetsAddQuery(getVirtualFileIdPageConfigValuesAll(pageId, false))}'`);
     }
     const code = [...importStatements, ...lines].join('\n');
     return code;
 }
+function getConfigValuesImported(pageConfig, isForClientSide, isClientRouting, importStatements) {
+    const lines = [];
+    const varCounterContainer = { varCounter: 0 };
+    getConfigValueSourcesNotOverriden(pageConfig).forEach((configValueSource) => {
+        if (!isEnvMatch(configValueSource.configEnv, checkWhetherIsImport(configValueSource), {
+            isImport: true,
+            isForClientSide,
+            isClientRouting
+        }))
+            return;
+        const whitespace = '  ';
+        lines.push(...serializeConfigValueImported(configValueSource, configValueSource.configName, whitespace, varCounterContainer, importStatements));
+    });
+    const code = lines.join('\n');
+    return code;
+}
+function checkWhetherIsImport(configValueSource) {
+    const { valueIsImportedAtRuntime, valueIsFilePath } = configValueSource;
+    return valueIsImportedAtRuntime && !valueIsFilePath;
+}
+function isEnvMatch(configEnv, isImport, runtime) {
+    // Whether config value is imported or serialized
+    if (isImport !== runtime.isImport)
+        return false;
+    // Runtime match
+    const { isForClientSide, isClientRouting } = runtime;
+    if (!isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: false }))
+        return false;
+    return true;
+}

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

@@ -1,6 +1,3 @@
 export { getVirtualFilePageConfigs };
-export { getConfigValueSerialized };
-import type { DefinedAt } from '../../../../../shared/page-configs/PageConfig.js';
 import type { ResolvedConfig } from 'vite';
 declare function getVirtualFilePageConfigs(isForClientSide: boolean, isDev: boolean, id: string, isClientRouting: boolean, config: ResolvedConfig): Promise<string>;
-declare function getConfigValueSerialized(value: unknown, configName: string, definedAt: DefinedAt): string;

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

@@ -1,15 +1,11 @@
 export { getVirtualFilePageConfigs };
-export { getConfigValueSerialized };
-import { assert, assertUsage, getPropAccessNotation, objectEntries } from '../../../utils.js';
+import { assert, objectEntries } from '../../../utils.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { debug } from './debug.js';
-import { isJsonSerializerError, stringify } from '@brillout/json-serializer/stringify';
-import { getConfigEnv } from './helpers.js';
-import pc from '@brillout/picocolors';
 import { getVikeConfig } from './getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
-import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/helpers.js';
-import { serializeConfigValue, serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
+import { serializeConfigValueImported } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
+import { getConfigValuesSerialized } from './getConfigValuesSerialized.js';
 async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
     const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, isDev, true);
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
@@ -18,15 +14,18 @@ function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isCl
     const lines = [];
     const importStatements = [];
     const varCounterContainer = { varCounter: 0 };
+    lines.push('export const pageConfigsSerialized = [');
     lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, importStatements, varCounterContainer));
+    lines.push('];');
+    lines.push('export const pageConfigGlobalSerialized = {');
     lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isDev, importStatements, varCounterContainer));
+    lines.push('};');
     const code = [...importStatements, ...lines].join('\n');
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }
 function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, importStatements, varCounterContainer) {
     const lines = [];
-    lines.push('export const pageConfigsSerialized = [');
     pageConfigs.forEach((pageConfig) => {
         const { pageId, routeFilesystem, isErrorPage } = pageConfig;
         const virtualFileIdPageConfigValuesAll = getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide);
@@ -34,35 +33,13 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         lines.push(`    pageId: ${JSON.stringify(pageId)},`);
         lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
         lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
-        lines.push(`    loadConfigValuesAll: async () => (await import(${JSON.stringify(virtualFileIdPageConfigValuesAll)})).default,`);
+        lines.push(`    loadConfigValuesAll: () => import(${JSON.stringify(virtualFileIdPageConfigValuesAll)}),`);
+        // Serialized config values
         lines.push(`    configValuesSerialized: {`);
-        Object.entries(pageConfig.configValuesComputed).forEach(([configName, configValuesComputed]) => {
-            const { value, configEnv } = configValuesComputed;
-            if (!isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true }))
-                return;
-            if (pageConfig.configValueSources[configName])
-                return;
-            const configValue = pageConfig.configValues[configName];
-            assert(configValue);
-            const { definedAt } = configValue;
-            const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
-            serializeConfigValue(lines, configName, { definedAt, valueSerialized });
-        });
-        Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
-            const configValue = pageConfig.configValues[configName];
-            if (configValue) {
-                const configEnv = getConfigEnv(pageConfig.configValueSources, configName);
-                assert(configEnv, configName);
-                const isEnvMatch = isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true });
-                if (!isEnvMatch)
-                    return;
-                const { value, definedAt } = configValue;
-                const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
-                serializeConfigValue(lines, configName, { definedAt, valueSerialized });
-            }
-        });
+        lines.push(getConfigValuesSerialized(pageConfig, (configEnv) => isRuntimeEnvMatch(configEnv, { isForClientSide, isClientRouting, isEager: true })));
         lines.push(`    },`);
-        let whitespace = '    ';
+        // Imported config values
+        const whitespace = '    ';
         lines.push(`${whitespace}configValuesImported: [`);
         Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
             const configValue = pageConfig.configValues[configName];
@@ -70,21 +47,18 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
                 return;
             const configValueSource = sources[0];
             assert(configValueSource);
-            if (configValueSource.configEnv !== '_routing-eager')
+            if (!configValueSource.configEnv.eager)
                 return;
             lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
         });
         lines.push(`${whitespace}],`);
-        // pageConfig end
         lines.push(`  },`);
     });
-    lines.push('];');
     const code = lines.join('\n');
     return code;
 }
 function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isDev, importStatements, varCounterContainer) {
     const lines = [];
-    lines.push('export const pageConfigGlobalSerialized = {');
     /* Nothing (yet)
     lines.push(`  configValuesSerialized: {`)
     lines.push(`  },`)
@@ -109,35 +83,6 @@ function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, is
         lines.push(...serializeConfigValueImported(configValueSource, configName, whitespace, varCounterContainer, importStatements));
     });
     lines.push(`  ],`);
-    lines.push('};');
     const code = lines.join('\n');
     return code;
 }
-function getConfigValueSerialized(value, configName, definedAt) {
-    const valueName = `config${getPropAccessNotation(configName)}`;
-    let configValueSerialized;
-    try {
-        configValueSerialized = stringify(value, { valueName, forbidReactElements: true });
-    }
-    catch (err) {
-        let serializationErrMsg = '';
-        if (isJsonSerializerError(err)) {
-            serializationErrMsg = err.messageCore;
-        }
-        else {
-            // When a property getter throws an error
-            console.error('Serialization error:');
-            console.error(err);
-            serializationErrMsg = 'see serialization error printed above';
-        }
-        const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
-        assert(configValueFilePathToShowToUser);
-        assertUsage(false, [
-            `The value of the config ${pc.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,
-            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because its value isn't serializable: ${serializationErrMsg}.)`,
-            `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
-        ].join(' '));
-    }
-    configValueSerialized = JSON.stringify(configValueSerialized);
-    return configValueSerialized;
-}

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

@@ -1,15 +1,18 @@
 export { isRuntimeEnvMatch };
 function isRuntimeEnvMatch(configEnv, runtime) {
-    const { isForClientSide, isClientRouting, isEager } = runtime;
-    if (configEnv === 'config-only')
-        return false;
-    if (configEnv === (isForClientSide ? 'server-only' : 'client-only'))
-        return false;
-    if (configEnv === '_routing-eager' || configEnv === '_routing-lazy') {
-        if (isForClientSide && !isClientRouting)
+    // Runtime
+    if (!runtime.isForClientSide) {
+        if (!configEnv.server)
             return false;
-        if (isEager !== (configEnv === '_routing-eager'))
+    }
+    else {
+        if (!configEnv.client)
+            return false;
+        if (configEnv.client === 'if-client-routing' && !runtime.isClientRouting)
             return false;
     }
+    // Eager
+    if (runtime.isEager !== !!configEnv.eager)
+        return false;
     return true;
 }

package/dist/esm/node/plugin/shared/getConfigValueSourcesNotOverriden.d.ts

@@ -0,0 +1,5 @@
+export { getConfigValueSourcesNotOverriden };
+import type { ConfigValueSource, PageConfigBuildTime } from '../../../shared/page-configs/PageConfig.js';
+declare function getConfigValueSourcesNotOverriden(pageConfig: PageConfigBuildTime): (ConfigValueSource & {
+    configName: string;
+})[];

package/dist/esm/node/plugin/shared/{getConfigValueSourcesRelevant.js → getConfigValueSourcesNotOverriden.js}

@@ -1,7 +1,7 @@
-export { getConfigValueSourcesRelevant };
+export { getConfigValueSourcesNotOverriden };
 import { assert, assertIsNotBrowser } from '../../shared/utils.js';
 assertIsNotBrowser();
-function getConfigValueSourcesRelevant(pageConfig) {
+function getConfigValueSourcesNotOverriden(pageConfig) {
     const configValueSourcesRelevant = Object.entries(pageConfig.configValueSources).map(([configName, sources]) => {
         const configValueSource = sources[0];
         assert(configValueSource);

package/dist/esm/node/plugin/utils.d.ts

@@ -16,3 +16,5 @@ export * from '../../utils/removeEmptyLines.js';
 export * from '../../utils/findUserPackageJsonPath.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
+export * from '../../utils/deepEqual.js';
+export * from '../../utils/assertKeys.js';

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

@@ -22,3 +22,5 @@ export * from '../../utils/removeEmptyLines.js';
 export * from '../../utils/findUserPackageJsonPath.js';
 export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
+export * from '../../utils/deepEqual.js';
+export * from '../../utils/assertKeys.js';