vike 0.4.146-commit-701e2e5 → 0.4.147

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

@@ -3,9 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ssr = exports.plugin = void 0;
+exports.version = exports.ssr = exports.plugin = void 0;
 exports.default = plugin;
-const utils_js_1 = require("./utils.js");
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return utils_js_1.PROJECT_VERSION; } });
+const utils_js_2 = require("./utils.js");
 const buildConfig_js_1 = require("./plugins/buildConfig.js");
 const previewConfig_js_1 = require("./plugins/previewConfig.js");
 const autoFullBuild_js_1 = require("./plugins/autoFullBuild.js");
@@ -26,7 +28,7 @@ const extensionsAssets_js_1 = require("./plugins/extensionsAssets.js");
 const baseUrls_js_1 = require("./plugins/baseUrls.js");
 const envVars_js_1 = require("./plugins/envVars.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-(0, utils_js_1.markEnvAsVite)();
+(0, utils_js_2.markEnvAsVite)();
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeConfig) {
     const plugins = [
@@ -65,6 +67,6 @@ catch { }
 Object.defineProperty(plugin, 'apply', {
     enumerable: true,
     get: () => {
-        (0, utils_js_1.assertUsage)(false, `Add ${picocolors_1.default.cyan('vike()')} instead of ${picocolors_1.default.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
+        (0, utils_js_2.assertUsage)(false, `Add ${picocolors_1.default.cyan('vike()')} instead of ${picocolors_1.default.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
     }
 });

package/dist/cjs/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -4,7 +4,7 @@ exports.determineOptimizeDeps = void 0;
 const findPageFiles_js_1 = require("../../shared/findPageFiles.js");
 const utils_js_1 = require("../../utils.js");
 const getVikeConfig_js_1 = require("../importUserCode/v1-design/getVikeConfig.js");
-const getConfigValueSourcesRelevant_js_1 = require("../../shared/getConfigValueSourcesRelevant.js");
+const getConfigValueSourcesNotOverriden_js_1 = require("../../shared/getConfigValueSourcesNotOverriden.js");
 const buildConfig_js_1 = require("../buildConfig.js");
 const virtualFileImportUserCode_js_1 = require("../../../shared/virtual-files/virtualFileImportUserCode.js");
 async function determineOptimizeDeps(config, configVike, isDev) {
@@ -33,12 +33,11 @@ async function getPageDeps(config, pageConfigs, isDev) {
     // V1 design
     {
         pageConfigs.forEach((pageConfig) => {
-            const configValueSourcesRelevant = (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(pageConfig);
-            configValueSourcesRelevant.forEach((configValueSource) => {
+            (0, getConfigValueSourcesNotOverriden_js_1.getConfigValueSourcesNotOverriden)(pageConfig).forEach((configValueSource) => {
                 if (!configValueSource.valueIsImportedAtRuntime)
                     return;
                 const { definedAt, configEnv } = configValueSource;
-                if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
+                if (!configEnv.client)
                     return;
                 if (definedAt.filePathRelativeToUserRootDir !== null) {
                     const { filePathAbsoluteFilesystem } = definedAt;

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

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertConfigValueIsSerializable = exports.getConfigValuesSerialized = void 0;
+const utils_js_1 = require("../../../utils.js");
+const stringify_1 = require("@brillout/json-serializer/stringify");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
+const serializeConfigValue_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValue.js");
+const getConfigValueSourcesNotOverriden_js_1 = require("../../../shared/getConfigValueSourcesNotOverriden.js");
+function getConfigValuesSerialized(pageConfig, isEnvMatch) {
+    const lines = [];
+    Object.entries(pageConfig.configValuesComputed).forEach(([configName, configValuesComputed]) => {
+        const { value, configEnv } = configValuesComputed;
+        if (!isEnvMatch(configEnv))
+            return;
+        // configValeSources has higher precedence
+        if (pageConfig.configValueSources[configName])
+            return;
+        const configValue = pageConfig.configValues[configName];
+        (0, utils_js_1.assert)(configValue);
+        const { definedAt } = configValue;
+        const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+        (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, { definedAt, valueSerialized });
+    });
+    (0, getConfigValueSourcesNotOverriden_js_1.getConfigValueSourcesNotOverriden)(pageConfig).forEach((configValueSource) => {
+        const { configName, configEnv } = configValueSource;
+        const configValue = pageConfig.configValues[configName];
+        if (!configValue)
+            return;
+        if (!isEnvMatch(configEnv, configValueSource)) {
+            return;
+        }
+        const { value, definedAt } = configValue;
+        const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+        (0, serializeConfigValue_js_1.serializeConfigValue)(lines, configName, { definedAt, valueSerialized });
+    });
+    const code = lines.join('\n');
+    return code;
+}
+exports.getConfigValuesSerialized = getConfigValuesSerialized;
+function assertConfigValueIsSerializable(value, configName, definedAt) {
+    // Contains asserts
+    getConfigValueSerialized(value, configName, definedAt);
+}
+exports.assertConfigValueIsSerializable = assertConfigValueIsSerializable;
+function getConfigValueSerialized(value, configName, definedAt) {
+    const valueName = `config${(0, utils_js_1.getPropAccessNotation)(configName)}`;
+    let configValueSerialized;
+    try {
+        configValueSerialized = (0, stringify_1.stringify)(value, { valueName, forbidReactElements: true });
+    }
+    catch (err) {
+        let serializationErrMsg = '';
+        if ((0, stringify_1.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 = (0, helpers_js_1.getConfigValueFilePathToShowToUser)({ definedAt });
+        (0, utils_js_1.assert)(configValueFilePathToShowToUser);
+        (0, utils_js_1.assertUsage)(false, [
+            `The value of the config ${picocolors_1.default.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/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -1,101 +1,122 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configDefinitionsBuiltInGlobal = exports.configDefinitionsBuiltIn = void 0;
-const helpers_js_1 = require("../helpers.js");
+const utils_js_1 = require("../../../../utils.js");
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
-        env: 'server-only'
+        env: { server: true }
     },
     onRenderClient: {
-        env: 'client-only'
+        env: { client: true }
     },
     onHydrationEnd: {
-        env: 'client-only'
+        env: { client: true }
     },
     onPageTransitionStart: {
-        env: 'client-only'
+        env: { client: true }
     },
     onPageTransitionEnd: {
-        env: 'client-only'
+        env: { client: true }
     },
     onBeforeRender: {
-        env: 'server-only'
+        env: { server: true }
     },
     onBeforePrerenderStart: {
-        env: 'server-only'
+        env: { server: true }
     },
     Page: {
-        env: 'server-and-client'
+        env: { server: true, client: true }
     },
     passToClient: {
-        env: 'server-only',
+        env: { server: true, config: true },
         cumulative: true
     },
     route: {
-        env: '_routing-eager'
+        env: { server: true, client: 'if-client-routing', eager: true }
     },
     guard: {
-        env: '_routing-lazy'
+        env: { server: true, client: 'if-client-routing' }
     },
     iKnowThePerformanceRisksOfAsyncRouteFunctions: {
-        env: '_routing-eager'
+        env: { server: true, client: 'if-client-routing', eager: true }
     },
     filesystemRoutingRoot: {
-        env: 'config-only'
+        env: { config: true }
     },
     client: {
         // The value of the client config is merely the file path to the client entry file, which is only needed on the sever-side
-        env: 'server-only',
+        env: { server: true },
         _valueIsFilePath: true
     },
     clientRouting: {
-        // We could make it 'server-only' (we don't yet because of some legacy V0.4 design code)
-        env: 'server-and-client'
+        // We could make it { client: false } but we don't yet because of some legacy V0.4 design code
+        env: { server: true, client: true, config: true, eager: true }
     },
     prerender: {
-        env: 'config-only'
+        env: { config: true }
     },
     hydrationCanBeAborted: {
-        env: 'client-only'
+        env: { client: true }
     },
     prefetchStaticAssets: {
-        env: 'client-only'
+        env: { client: true }
     },
     extends: {
-        env: 'config-only'
+        env: { config: true }
     },
     meta: {
-        env: 'config-only'
+        env: { config: true }
     },
     isClientSideRenderable: {
-        env: 'server-and-client',
-        _computed: (configValueSources) => (0, helpers_js_1.isConfigSet)(configValueSources, 'onRenderClient') &&
-            (0, helpers_js_1.isConfigSet)(configValueSources, 'Page') &&
-            (0, helpers_js_1.getConfigEnv)(configValueSources, 'Page') !== 'server-only'
+        env: { server: true, client: true, eager: true },
+        _computed: (configValueSources) => isConfigSet(configValueSources, 'onRenderClient') &&
+            isConfigSet(configValueSources, 'Page') &&
+            !!getConfigEnv(configValueSources, 'Page')?.client
     },
     onBeforeRenderEnv: {
-        env: 'client-only',
-        _computed: (configValueSources) => !(0, helpers_js_1.isConfigSet)(configValueSources, 'onBeforeRender') ? null : (0, helpers_js_1.getConfigEnv)(configValueSources, 'onBeforeRender')
+        env: { client: true },
+        _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
     }
 };
 exports.configDefinitionsBuiltIn = configDefinitionsBuiltIn;
 const configDefinitionsBuiltInGlobal = {
     onPrerenderStart: {
-        env: 'server-only'
+        env: { server: true }
     },
     onBeforeRoute: {
-        env: '_routing-eager'
+        env: { server: true, client: 'if-client-routing', eager: true }
     },
     prerender: {
-        env: 'config-only'
-    },
-    extensions: { env: 'config-only' },
-    disableAutoFullBuild: { env: 'config-only' },
-    includeAssetsImportedByServer: { env: 'config-only' },
-    baseAssets: { env: 'config-only' },
-    baseServer: { env: 'config-only' },
-    redirects: { env: 'server-only' },
-    trailingSlash: { env: 'server-only' },
-    disableUrlNormalization: { env: 'server-only' }
+        env: { config: true }
+    },
+    extensions: { env: { config: true } },
+    disableAutoFullBuild: { env: { config: true } },
+    includeAssetsImportedByServer: { env: { config: true } },
+    baseAssets: { env: { config: true } },
+    baseServer: { env: { config: true } },
+    redirects: { env: { server: true } },
+    trailingSlash: { env: { server: true } },
+    disableUrlNormalization: { env: { server: true } }
 };
 exports.configDefinitionsBuiltInGlobal = configDefinitionsBuiltInGlobal;
+function getConfigEnv(configValueSources, configName) {
+    const configValueSource = getConfigValueSource(configValueSources, configName);
+    if (!configValueSource)
+        return null;
+    return configValueSource.configEnv;
+}
+function isConfigSet(configValueSources, configName) {
+    const configValueSource = getConfigValueSource(configValueSources, configName);
+    // Enable users to suppress global config values by overriding the config's value to null
+    if (configValueSource?.value === null)
+        return false;
+    return !!configValueSource;
+}
+function getConfigValueSource(configValueSources, configName) {
+    const sources = configValueSources[configName];
+    if (!sources)
+        return null;
+    const configValueSource = sources[0];
+    (0, utils_js_1.assert)(configValueSource);
+    return configValueSource;
+}

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

@@ -18,8 +18,8 @@ const removeSuperfluousViteLog_js_1 = require("../../../shared/loggerVite/remove
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
 const assertExports_js_1 = require("../../../../../shared/page-configs/assertExports.js");
-const getVirtualFilePageConfigs_js_1 = require("./getVirtualFilePageConfigs.js");
 const getConfigVike_js_1 = require("../../../../shared/getConfigVike.js");
+const getConfigValuesSerialized_js_1 = require("./getConfigValuesSerialized.js");
 (0, utils_js_1.assertIsNotProductionRuntime)();
 let devServerIsCorrupt = false;
 let wasConfigInvalid = null;
@@ -156,12 +156,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)
+        (0, utils_js_1.assertUsage)(configEnv.config, `Config ${picocolors_1.default.cyan(configName)} needs its ${picocolors_1.default.cyan('env')} to have ${picocolors_1.default.cyan('{ config: true }')} (because ${picocolors_1.default.cyan(configName)} is a ${picocolors_1.default.cyan('cumulative')} config)`);
+    }
+    return !!configEnv.config;
 }
 function getInterfaceFileFromConfigFile(configFile, isConfigExtend) {
     const { fileExports, filePath, extendsFilePaths } = configFile;
@@ -514,6 +514,7 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
     }
     else if (interfaceFile.isValueFile) {
         const valueAlreadyLoaded = 'configValue' in conf;
+        (0, utils_js_1.assert)(valueAlreadyLoaded === !!configEnv.config);
         const configValueSource = {
             configEnv,
             valueIsImportedAtRuntime: !valueAlreadyLoaded,
@@ -528,9 +529,6 @@ async function getConfigValueSource(configName, interfaceFile, configDef, userRo
         if (valueAlreadyLoaded) {
             configValueSource.value = conf.configValue;
         }
-        else {
-            (0, utils_js_1.assert)(configEnv !== 'config-only');
-        }
         return configValueSource;
     }
     (0, utils_js_1.assert)(false);
@@ -542,12 +540,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) => !(0, utils_js_1.deepEqual)(c.configEnv, configEnv))[0];
     if (configDifferentEnv) {
         (0, utils_js_1.assertUsage)(false, [
             `${filePathForEnvCheck} defines the value of configs living in different environments:`,
-            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.cyan(c.configName)} which value lives in environment ${picocolors_1.default.cyan(c.configEnv)}`),
-            'Defining config values in the same file is allowed only if they live in the same environment, see https://vike.dev/header-file/import-from-same-file'
+            ...[configDifferentEnv, { configName, configEnv }].map((c) => `  - config ${picocolors_1.default.cyan(c.configName)} which value lives in environment ${picocolors_1.default.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'));
     }
 }
@@ -683,30 +681,17 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
             (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}`)} to a value with an invalid type ${picocolors_1.default.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 ${picocolors_1.default.cyan(`meta.${configName}.env`)} to `,
-                (0, utils_js_1.joinEnglish)(envValues.map((s) => picocolors_1.default.cyan(`'${s}'`)), 'or'),
-                '.'
-            ].join('');
+            (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
             if (!('env' in def)) {
-                (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} doesn't set ${picocolors_1.default.cyan(`meta.${configName}.env`)} but it's required. ${fix}`);
-            }
-            if (!(0, utils_js_1.hasProp)(def, 'env', 'string')) {
-                (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.env`)} to an invalid type ${picocolors_1.default.cyan(typeof def.env)}. ${fix}`);
-            }
-            if (!envValues.includes(def.env)) {
-                (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.env`)} to an unknown value ${picocolors_1.default.cyan(`'${def.env}'`)}. ${fix}`);
+                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} doesn't set ${picocolors_1.default.cyan(`meta.${configName}.env`)} but it's required.`);
             }
+            configEnv = getConfigEnvValue(def.env, `${configMetaDefinedAt} sets ${picocolors_1.default.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) {
@@ -714,9 +699,9 @@ function assertMetaValue(metaVal, configMetaDefinedAt) {
                 (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
                 (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.effect`)} to an invalid type ${picocolors_1.default.cyan(typeof def.effect)}: it should be a function instead`);
             }
-            if (def.env !== 'config-only') {
+            if (!configEnv.config) {
                 (0, utils_js_1.assert)(configMetaDefinedAt); // We expect internal effects to return a valid meta value
-                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.effect`)} but it's only supported if meta.${configName}.env is ${picocolors_1.default.cyan('config-only')} (but it's ${picocolors_1.default.cyan(def.env)} instead)`);
+                (0, utils_js_1.assertUsage)(false, `${configMetaDefinedAt} sets ${picocolors_1.default.cyan(`meta.${configName}.effect`)} but it's only supported if meta.${configName}.env has ${picocolors_1.default.cyan('{ config: true }')} (but it's ${picocolors_1.default.cyan(JSON.stringify(configEnv))} instead)`);
             }
         }
     });
@@ -727,8 +712,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.)
-        (0, utils_js_1.assertUsage)(configDef.env === 'config-only', [
-            `Cannot add effect to ${picocolors_1.default.cyan(configName)} because its ${picocolors_1.default.cyan('env')} is ${picocolors_1.default.cyan(configDef.env)}: effects can only be added to configs with an ${picocolors_1.default.cyan('env')} value of ${picocolors_1.default.cyan('config-only')}.`
+        (0, utils_js_1.assertUsage)(configDef.env.config, [
+            `Cannot add effect to ${picocolors_1.default.cyan(configName)} because its ${picocolors_1.default.cyan('env')} is ${picocolors_1.default.cyan(JSON.stringify(configDef.env))}: effects can only be added to configs with an ${picocolors_1.default.cyan('env')} with ${picocolors_1.default.cyan('{ config: true }')}.`
         ].join(' '));
         const source = configValueSources[configName]?.[0];
         if (!source)
@@ -1046,7 +1031,7 @@ function determineRouteFilesystem(locationId, configValueSources) {
     return { routeFilesystem, isErrorPage: undefined };
 }
 function getFilesystemRoutingRootEffect(configFilesystemRoutingRoot, configName) {
-    (0, utils_js_1.assert)(configFilesystemRoutingRoot.configEnv === 'config-only');
+    (0, utils_js_1.assert)(configFilesystemRoutingRoot.configEnv.config);
     // Eagerly loaded since it's config-only
     (0, utils_js_1.assert)('value' in configFilesystemRoutingRoot);
     const { value } = configFilesystemRoutingRoot;
@@ -1143,7 +1128,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.
         (0, utils_js_1.assert)('value' in configValueSource);
         // Make sure configValueSource.value is serializable
-        (0, getVirtualFilePageConfigs_js_1.getConfigValueSerialized)(configValueSource.value, configName, getDefinedAt(configValueSource));
+        (0, getConfigValuesSerialized_js_1.assertConfigValueIsSerializable)(configValueSource.value, configName, getDefinedAt(configValueSource));
         const assertNoMixing = (isSet) => {
             const vals1 = isSet ? valuesSet : valuesArr;
             const t1 = isSet ? 'a Set' : 'an array';
@@ -1184,3 +1169,35 @@ function mergeCumulative(configName, configValueSources) {
     }
     (0, utils_js_1.assert)(false);
 }
+function getConfigEnvValue(val, errMsgIntro) {
+    const errInvalidValue = `${errMsgIntro} an invalid value ${picocolors_1.default.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 };
+            (0, utils_js_1.assertUsage)(false, errInvalidValue);
+        })();
+        (0, utils_js_1.assertWarning)(false, `${errMsgIntro} ${picocolors_1.default.cyan(val)} which is deprecated and will be removed in the next major release`, { onlyOnce: true });
+        return valConverted;
+    }
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(val), `${errMsgIntro} an invalid type ${picocolors_1.default.cyan(typeof val)}`);
+    (0, utils_js_1.assertKeys)(val, ['config', 'server', 'client'], `${errInvalidValue}:`);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(val, 'config', 'undefined') || (0, utils_js_1.hasProp)(val, 'config', 'boolean'), errInvalidValue);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(val, 'server', 'undefined') || (0, utils_js_1.hasProp)(val, 'server', 'boolean'), errInvalidValue);
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(val, 'client', 'undefined') || (0, utils_js_1.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/cjs/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigValuesAll.js

@@ -7,10 +7,11 @@ const getVikeConfig_js_1 = require("./getVikeConfig.js");
 const extractAssetsQuery_js_1 = require("../../../../shared/extractAssetsQuery.js");
 const debug_js_1 = require("./debug.js");
 const helpers_js_1 = require("../../../../../shared/page-configs/helpers.js");
-const getConfigValueSourcesRelevant_js_1 = require("../../../shared/getConfigValueSourcesRelevant.js");
+const getConfigValueSourcesNotOverriden_js_1 = require("../../../shared/getConfigValueSourcesNotOverriden.js");
 const isRuntimeEnvMatch_js_1 = require("./isRuntimeEnvMatch.js");
 const serializeConfigValue_js_1 = require("../../../../../shared/page-configs/serialize/serializeConfigValue.js");
 const getConfigVike_js_1 = require("../../../../shared/getConfigVike.js");
+const getConfigValuesSerialized_js_1 = require("./getConfigValuesSerialized.js");
 async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     const result = (0, virtualFilePageConfigValuesAll_js_1.isVirtualFileIdPageConfigValuesAll)(id);
     (0, utils_js_1.assert)(result);
@@ -31,27 +32,52 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
 }
 exports.getVirtualFilePageConfigValuesAll = getVirtualFilePageConfigValuesAll;
 function getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
-    const configValue = (0, helpers_js_1.getConfigValue)(pageConfig, 'clientRouting', 'boolean');
-    const isClientRouting = configValue?.value ?? false;
     const lines = [];
     const importStatements = [];
-    lines.push('export default [');
-    const varCounterContainer = { varCounter: 0 };
-    (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(pageConfig).forEach((configValueSource) => {
-        const { valueIsImportedAtRuntime, configEnv, configName } = configValueSource;
-        if (!valueIsImportedAtRuntime)
-            return;
-        if (configValueSource.valueIsFilePath)
-            return;
-        if (!(0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: false }))
-            return;
-        const whitespace = '  ';
-        lines.push(...(0, serializeConfigValue_js_1.serializeConfigValueImported)(configValueSource, configName, whitespace, varCounterContainer, importStatements));
-    });
+    const isClientRouting = (0, helpers_js_1.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((0, getConfigValuesSerialized_js_1.getConfigValuesSerialized)(pageConfig, (configEnv, configValueSource) => isEnvMatch(configEnv, !configValueSource ? false : checkWhetherIsImport(configValueSource), {
+        isImport: false,
+        isForClientSide,
+        isClientRouting
+    })));
+    lines.push('};');
     if (includeAssetsImportedByServer && isForClientSide && !isDev) {
-        lines.push(`import '${(0, extractAssetsQuery_js_1.extractAssetsAddQuery)((0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, false))}'`);
+        importStatements.push(`import '${(0, extractAssetsQuery_js_1.extractAssetsAddQuery)((0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageId, false))}'`);
     }
     const code = [...importStatements, ...lines].join('\n');
     return code;
 }
+function getConfigValuesImported(pageConfig, isForClientSide, isClientRouting, importStatements) {
+    const lines = [];
+    const varCounterContainer = { varCounter: 0 };
+    (0, getConfigValueSourcesNotOverriden_js_1.getConfigValueSourcesNotOverriden)(pageConfig).forEach((configValueSource) => {
+        if (!isEnvMatch(configValueSource.configEnv, checkWhetherIsImport(configValueSource), {
+            isImport: true,
+            isForClientSide,
+            isClientRouting
+        }))
+            return;
+        const whitespace = '  ';
+        lines.push(...(0, serializeConfigValue_js_1.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 (!(0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isEager: false }))
+        return false;
+    return true;
+}