vike 0.4.146-commit-701e2e5 → 0.4.147-commit-2fa53b2

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

@@ -1,98 +1,119 @@
 export { configDefinitionsBuiltIn };
 export { configDefinitionsBuiltInGlobal };
-import { getConfigEnv, isConfigSet } from '../helpers.js';
+import { assert } from '../../../../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',
+        env: { server: true, client: true, eager: true },
         _computed: (configValueSources) => isConfigSet(configValueSources, 'onRenderClient') &&
             isConfigSet(configValueSources, 'Page') &&
-            getConfigEnv(configValueSources, 'Page') !== 'server-only'
+            !!getConfigEnv(configValueSources, 'Page')?.client
     },
     onBeforeRenderEnv: {
-        env: 'client-only',
+        env: { client: true },
         _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
     }
 };
 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 } }
 };
+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];
+    assert(configValueSource);
+    return configValueSource;
+}

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

@@ -0,0 +1,5 @@
+export { crawlPlusFiles };
+declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: string, isDev: boolean): Promise<{
+    filePathRelativeToUserRootDir: string;
+    filePathAbsoluteFilesystem: string;
+}[]>;

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

@@ -0,0 +1,98 @@
+export { crawlPlusFiles };
+import { assertPosixPath, assert, toPosixPath, assertWarning, scriptFileExtensionList, scriptFileExtensions } from '../../../../utils.js';
+import path from 'path';
+import glob from 'fast-glob';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execA = promisify(exec);
+async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
+    assertPosixPath(userRootDir);
+    assertPosixPath(outDirAbsoluteFilesystem);
+    assert(outDirAbsoluteFilesystem.startsWith(userRootDir));
+    const outDir = path.posix.relative(userRootDir, outDirAbsoluteFilesystem);
+    assert(!outDir.startsWith('.'));
+    const timeBase = new Date().getTime();
+    let files = [];
+    const res = await gitLsFiles(userRootDir, outDir);
+    if (res &&
+        // Fallback to fast-glob for users that dynamically generate plus files (we assume generetad plus files to be skipped because they are usually included in .gitignore)
+        res.length > 0) {
+        files = res;
+    }
+    else {
+        files = await fastGlob(userRootDir, outDir);
+    }
+    {
+        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 = files.map((p) => {
+        p = toPosixPath(p);
+        assert(!p.startsWith(userRootDir));
+        const filePathRelativeToUserRootDir = path.posix.join('/', p);
+        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, p);
+        return {
+            filePathRelativeToUserRootDir,
+            filePathAbsoluteFilesystem
+        };
+    });
+    return plusFiles;
+}
+// Same as fastGlob() but using `$ git ls-files`
+async function gitLsFiles(userRootDir, outDir) {
+    const cmd = [
+        'git ls-files',
+        ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
+        ...getIgnorePatterns(outDir).map((pattern) => `--exclude="${pattern}"`),
+        // --others lists untracked files only (but using .gitignore because --exclude-standard)
+        // --cached adds the tracked files to the output
+        '--others --cached --exclude-standard'
+    ].join(' ');
+    let stdout;
+    try {
+        const res = await execA(cmd, { cwd: userRootDir });
+        stdout = res.stdout;
+    }
+    catch (err) {
+        if (err.message.includes('not a git repository'))
+            return null;
+        throw err;
+    }
+    let files = stdout.split('\n').filter(Boolean);
+    assert(!outDir.startsWith('/'));
+    files = files.filter(
+    // We have to repeat the same exclusion logic here because the `git ls-files` option --exclude only applies to untracked files. (We use --exclude only to speed up the command.)
+    (file) => getIgnoreFilter(file, outDir));
+    return files;
+}
+// Same as gitLsFiles() but using fast-glob
+async function fastGlob(userRootDir, outDir) {
+    const files = await glob(`**/+*.${scriptFileExtensions}`, {
+        ignore: getIgnorePatterns(outDir),
+        cwd: userRootDir,
+        dot: false
+    });
+    return files;
+}
+// Same as getIgnoreFilter() but as glob pattern
+function getIgnorePatterns(outDir) {
+    return [
+        '**/node_modules/**',
+        `${outDir}/**`,
+        // Allow:
+        // ```
+        // +Page.js
+        // +Page.telefunc.js
+        // ```
+        '**/*.telefunc.*'
+    ];
+}
+// Same as getIgnorePatterns() but for Array.filter()
+function getIgnoreFilter(file, outDir) {
+    return !file.includes('node_modules/') && !file.includes('.telefunc.') && !file.startsWith(`${outDir}/`);
+}

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;