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

package/dist/cjs/node/runtime/renderPage/getHttpResponseBody.js

@@ -11,7 +11,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const streamDocs = 'See https://vike.dev/stream for more information.';
 function getHttpResponseBody(htmlRender, renderHook) {
     if (typeof htmlRender !== 'string') {
-        (0, utils_js_1.assertUsage)(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${picocolors_1.default.cyan('pageContext.httpResponse.pipe()')} or ${picocolors_1.default.cyan('pageContext.httpResponse.getBody()')} instead`));
+        (0, utils_js_1.assertUsage)(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${picocolors_1.default.cyan('pageContext.httpResponse.pipe()')} instead`));
     }
     const body = htmlRender;
     return body;

package/dist/cjs/node/runtime/renderPage.js

@@ -333,10 +333,8 @@ function normalizeUrl(pageContextInit, httpRequestId) {
 function getPermanentRedirect(pageContextInit, httpRequestId) {
     const { redirects, baseServer } = (0, globalContext_js_1.getGlobalContext)();
     const urlWithoutBase = (0, utils_js_1.removeBaseServer)(pageContextInit.urlOriginal, baseServer);
-    let urlOriginalPathnameWithouBase;
     let origin = null;
     let urlTarget = (0, utils_js_1.modifyUrlPathname)(urlWithoutBase, (urlPathname) => {
-        urlOriginalPathnameWithouBase = urlPathname;
         const urlTargetWithOrigin = (0, resolveRedirects_js_1.resolveRedirects)(redirects, urlPathname);
         if (urlTargetWithOrigin === null)
             return null;
@@ -346,13 +344,12 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
     });
     if (origin)
         urlTarget = (0, utils_js_1.addUrlOrigin)(urlTarget, origin);
-    (0, utils_js_1.assert)(urlOriginalPathnameWithouBase);
     if (urlTarget === urlWithoutBase)
         return null;
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
     urlTarget = (0, utils_js_1.prependBase)(urlTarget, baseServer);
     (0, utils_js_1.assert)(urlTarget !== pageContextInit.urlOriginal);
-    const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)({ url: urlTarget, statusCode: 301 }, urlOriginalPathnameWithouBase);
+    const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)({ url: urlTarget, statusCode: 301 }, urlWithoutBase);
     const pageContextHttpResponse = { ...pageContextInit, httpResponse };
     return pageContextHttpResponse;
 }
@@ -396,7 +393,13 @@ async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextIn
             ...pageContextInit,
             ...pageContextAbort
         };
-        const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)(pageContextAbort._urlRedirect, pageContextNominalPageInit.urlPathname);
+        const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)(pageContextAbort._urlRedirect, (() => {
+            const { pathname, searchOriginal } = pageContextNominalPageInit.urlParsed;
+            const urlLogical = (0, utils_js_1.createUrlFromComponents)(null, pathname, searchOriginal, 
+            // The server-side doesn't have access to the hash
+            null);
+            return urlLogical;
+        })());
         (0, utils_js_1.objectAssign)(pageContextReturn, { httpResponse });
         return { pageContextReturn };
     }

package/dist/cjs/shared/getPageFiles/analyzePageClientSide/determineClientEntry.js

@@ -1,4 +1,5 @@
 "use strict";
+// TODO/v1-release: remove
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVikeClientEntry = exports.determineClientEntry = void 0;
 function determineClientEntry({ pageFilesClientSide, pageFilesServerSide, isHtmlOnly, isClientRouting }) {

package/dist/cjs/shared/page-configs/loadConfigValues.js

@@ -3,15 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadConfigValues = void 0;
 const utils_js_1 = require("../utils.js");
 const parseConfigValuesImported_js_1 = require("./serialize/parseConfigValuesImported.js");
+const parseConfigValuesSerialized_js_1 = require("./serialize/parseConfigValuesSerialized.js");
 async function loadConfigValues(pageConfig, isDev) {
     if ('isAllLoaded' in pageConfig &&
         // We don't need to cache in dev, since Vite already caches the virtual module
         !isDev) {
         return pageConfig;
     }
-    const configValuesImported = await pageConfig.loadConfigValuesAll();
-    const configValuesAddendum = (0, parseConfigValuesImported_js_1.parseConfigValuesImported)(configValuesImported);
-    Object.assign(pageConfig.configValues, configValuesAddendum);
+    const configValuesLoaded = await pageConfig.loadConfigValuesAll();
+    {
+        const { configValuesImported } = configValuesLoaded;
+        const configValuesAddendum = (0, parseConfigValuesImported_js_1.parseConfigValuesImported)(configValuesImported);
+        Object.assign(pageConfig.configValues, configValuesAddendum);
+    }
+    {
+        const { configValuesSerialized } = configValuesLoaded;
+        const configValuesAddendum = (0, parseConfigValuesSerialized_js_1.parseConfigValuesSerialized)(configValuesSerialized);
+        Object.assign(pageConfig.configValues, configValuesAddendum);
+    }
     (0, utils_js_1.objectAssign)(pageConfig, { isAllLoaded: true });
     return pageConfig;
 }

package/dist/cjs/shared/page-configs/serialize/parseConfigValuesSerialized.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConfigValuesSerialized = void 0;
+const utils_js_1 = require("../../utils.js");
+const parse_1 = require("@brillout/json-serializer/parse");
+function parseConfigValuesSerialized(configValuesSerialized) {
+    const configValues = {};
+    Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
+        const { valueSerialized, definedAt } = configValueSeriliazed;
+        (0, utils_js_1.assert)(valueSerialized);
+        (0, utils_js_1.assert)(!configValues[configName]);
+        configValues[configName] = {
+            value: (0, parse_1.parse)(valueSerialized),
+            definedAt
+        };
+    });
+    return configValues;
+}
+exports.parseConfigValuesSerialized = parseConfigValuesSerialized;

package/dist/cjs/shared/page-configs/serialize/parsePageConfigs.js

@@ -1,26 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePageConfigs = void 0;
-const parse_1 = require("@brillout/json-serializer/parse");
 const parseConfigValuesImported_js_1 = require("./parseConfigValuesImported.js");
 const utils_js_1 = require("../../utils.js");
 const helpers_js_1 = require("../helpers.js");
+const parseConfigValuesSerialized_js_1 = require("./parseConfigValuesSerialized.js");
 function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = {};
         {
             const { configValuesSerialized } = pageConfigSerialized;
-            Object.entries(configValuesSerialized).forEach(([configName, configValueSeriliazed]) => {
-                {
-                    const { valueSerialized, definedAt } = configValueSeriliazed;
-                    (0, utils_js_1.assert)(valueSerialized);
-                    (0, utils_js_1.assert)(!configValues[configName]);
-                    configValues[configName] = {
-                        value: (0, parse_1.parse)(valueSerialized),
-                        definedAt
-                    };
-                }
-            });
+            const configValuesAddendum = (0, parseConfigValuesSerialized_js_1.parseConfigValuesSerialized)(configValuesSerialized);
+            Object.assign(configValues, configValuesAddendum);
         }
         {
             const { configValuesImported } = pageConfigSerialized;

package/dist/cjs/utils/assertKeys.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertKeys = void 0;
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const assert_js_1 = require("./assert.js");
+const joinEnglish_js_1 = require("./joinEnglish.js");
+function assertKeys(obj, keysExpected, errPrefix) {
+    const keysUnknown = [];
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+        if (!keysExpected.includes(key)) {
+            keysUnknown.push(key);
+        }
+    }
+    if (keysUnknown.length !== 0) {
+        (0, assert_js_1.assertUsage)(false, [
+            errPrefix,
+            `unknown key${keysUnknown.length === 1 ? '' : 's'}`,
+            (0, joinEnglish_js_1.joinEnglish)(keysUnknown, 'and', picocolors_1.default.cyan) + '.',
+            'Only following keys are allowed:',
+            (0, joinEnglish_js_1.joinEnglish)(keysExpected, 'and', picocolors_1.default.cyan) + '.'
+        ].join(' '));
+    }
+}
+exports.assertKeys = assertKeys;

package/dist/cjs/utils/joinEnglish.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.joinEnglish = void 0;
 const assert_js_1 = require("./assert.js");
 // https://stackoverflow.com/questions/53879088/join-an-array-by-commas-and-and/53879103#53879103
-function joinEnglish(arr, conjunction) {
+function joinEnglish(arr, conjunction, colorizer = (s) => s) {
     (0, assert_js_1.assert)(arr.length > 0);
     if (arr.length === 1)
-        return arr[0];
+        return colorizer(arr[0]);
     const firsts = arr.slice(0, arr.length - 1);
     const last = arr[arr.length - 1];
-    return firsts.join(', ') + ` ${conjunction} ` + last;
+    return firsts.map(colorizer).join(', ') + ` ${conjunction} ` + colorizer(last);
 }
 exports.joinEnglish = joinEnglish;

package/dist/cjs/utils/parseUrl.js

@@ -55,7 +55,7 @@ function parseUrl(url, baseServer) {
         searchAll[key] = [...(searchAll.hasOwnProperty(key) ? searchAll[key] : []), val];
     });
     // Origin + pathname
-    const { origin, pathname: pathnameResolved } = parsePathname(urlWithoutHashNorSearch, baseServer);
+    const { origin, pathname: pathnameResolved } = getPathname(urlWithoutHashNorSearch, baseServer);
     (0, assert_js_1.assert)(origin === null || origin === decodeSafe(origin)); // AFAICT decoding the origin is useless
     (0, assert_js_1.assert)(pathnameResolved.startsWith('/'));
     (0, assert_js_1.assert)(origin === null || url.startsWith(origin));
@@ -91,35 +91,43 @@ function decodeSafe(urlComponent) {
     return urlComponent;
 }
 function decodePathname(urlPathname) {
+    urlPathname = urlPathname.replace(/\s+$/, '');
     urlPathname = urlPathname
         .split('/')
         .map((dir) => decodeSafe(dir).split('/').join('%2F'))
         .join('/');
-    urlPathname = urlPathname.replace(/\s/g, '');
     return urlPathname;
 }
-function parsePathname(urlWithoutHashNorSearch, baseServer) {
+function getPathname(url, baseServer) {
+    // Search and hash already extracted
+    (0, assert_js_1.assert)(!url.includes('?') && !url.includes('#'));
+    // url has origin
     {
-        const { origin, pathname } = parseOrigin(urlWithoutHashNorSearch);
+        const { origin, pathname } = parseOrigin(url);
         if (origin) {
             return { origin, pathname };
         }
-        (0, assert_js_1.assert)(pathname === urlWithoutHashNorSearch);
+        (0, assert_js_1.assert)(pathname === url);
     }
-    if (urlWithoutHashNorSearch.startsWith('/')) {
-        return { origin: null, pathname: urlWithoutHashNorSearch };
+    // url doesn't have origin
+    if (url.startsWith('/')) {
+        return { origin: null, pathname: url };
     }
     else {
-        // In the browser, this is the Base URL of the current URL
+        // url is a relative path
+        // In the browser, this is the Base URL of the current URL.
         // Safe access `window?.document?.baseURI` for users who shim `window` in Node.js
-        let baseURI = typeof window !== 'undefined' && window?.document?.baseURI;
-        if (baseURI)
-            baseURI = parseOrigin(baseURI).pathname;
-        const base = baseURI || baseServer;
-        const pathname = resolveUrlPathnameRelative(urlWithoutHashNorSearch, base);
-        // We need to parse the origin in case `base === window.document.baseURI`
-        const parsed = parseOrigin(pathname);
-        return parsed;
+        const baseURI = typeof window !== 'undefined' ? window?.document?.baseURI : undefined;
+        let base;
+        if (baseURI) {
+            const baseURIPathaname = parseOrigin(baseURI.split('?')[0]).pathname;
+            base = baseURIPathaname;
+        }
+        else {
+            base = baseServer;
+        }
+        const pathname = resolveUrlPathnameRelative(url, base);
+        return { origin: null, pathname };
     }
 }
 function parseOrigin(url) {

package/dist/cjs/utils/projectInfo.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectInfo = void 0;
+exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.146-commit-701e2e5';
+const PROJECT_VERSION = '0.4.147-commit-2fa53b2';
+exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION,

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.js

@@ -27,7 +27,7 @@ async function getPageContextFromHooks_firstRender(pageContext) {
     objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContextFromHooks._pageId, pageContext));
     {
         const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
-        if (await onBeforeRenderClientOnlyExists(pageContextForHook)) {
+        if (onBeforeRenderClientOnlyExists(pageContextForHook)) {
             const pageContextFromHook = await executeOnBeforeRenderHookClientSide(pageContextForHook);
             objectAssign(pageContextFromHooks, pageContextFromHook);
         }
@@ -57,13 +57,17 @@ async function getPageContextFromHooks_uponNavigation(pageContext) {
 }
 async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
     let pageContextFromHooks = {};
+    objectAssign(pageContextFromHooks, { _hasPageContextFromClient: false });
     objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContext._pageId, pageContext));
+    let pageContextFetchedFromServer = false;
     // Needs to be called before any client-side hook, because it may contain pageContextInit.user which is needed for guard() and onBeforeRender()
     if (
     // For the error page, we cannot fetch pageContext from the server because the pageContext JSON request is based on the URL
     !isErrorPage &&
+        // true if pageContextInit has some client data or the onBeforeRender hook is server-side only:
         (await hasPageContextServer({ ...pageContext, ...pageContextFromHooks }))) {
         const pageContextFromServer = await fetchPageContextFromServer(pageContext);
+        pageContextFetchedFromServer = true;
         if (!pageContextFromServer['_isError']) {
             objectAssign(pageContextFromHooks, pageContextFromServer);
         }
@@ -72,6 +76,7 @@ async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
             assert(errorPageId);
             pageContextFromHooks = {};
             objectAssign(pageContextFromHooks, {
+                _hasPageContextFromClient: false,
                 isHydration: false,
                 _pageId: errorPageId
             });
@@ -91,25 +96,29 @@ async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
         if (!isErrorPage) {
             // Should we really call the guard() hook on the client-side? Shouldn't we make the guard() hook a server-side only hook? Or maybe make its env configurable like onBeforeRender()?
             await executeGuardHook({
-                _hasPageContextFromClient: false,
                 ...pageContext,
                 ...pageContextFromHooks
             }, (pageContext) => preparePageContextForUserConsumptionClientSide(pageContext, true));
         }
     }
+    // For the error page, we also execute the client-side onBeforeRender() hook, but maybe we shouldn't? The server-side does it as well (but maybe it shouldn't).
     {
-        // For the error page, we also execute the client-side onBeforeRender() hook, but maybe we shouldn't? The server-side does it as well (but maybe it shouldn't).
-        const pageContextFromOnBeforeRender = await executeOnBeforeRenderHookClientSide({
-            ...pageContext,
-            ...pageContextFromHooks
-        });
-        objectAssign(pageContextFromHooks, pageContextFromOnBeforeRender);
+        const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
+        if (onBeforeRenderClientOnlyExists(pageContextForHook) || !pageContextFetchedFromServer) {
+            // This won't do anything if no hook has been defined or if the hook's env.client is false.
+            const pageContextFromHook = await executeOnBeforeRenderHookClientSide(pageContextForHook);
+            objectAssign(pageContextFromHooks, pageContextFromHook);
+        }
+        else {
+            assert(pageContextFetchedFromServer);
+        }
     }
     return pageContextFromHooks;
 }
 async function executeOnBeforeRenderHookClientSide(pageContext) {
     const hook = getHook(pageContext, 'onBeforeRender');
     if (!hook) {
+        // No hook defined or hook's env.client is false
         const pageContextFromOnBeforeRender = {
             _hasPageContextFromClient: false
         };
@@ -153,7 +162,9 @@ async function onBeforeRenderServerOnlyExists(pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
         const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
-        return getConfigValue(pageConfig, 'onBeforeRenderEnv')?.value === 'server-only';
+        const onBeforeRenderEnv = getConfigValue(pageConfig, 'onBeforeRenderEnv')?.value ?? {};
+        assert(isObject(onBeforeRenderEnv));
+        return !!onBeforeRenderEnv.server && !onBeforeRenderEnv.client;
     }
     else {
         // TODO/v1-release: remove
@@ -162,14 +173,17 @@ async function onBeforeRenderServerOnlyExists(pageContext) {
         return hasOnBeforeRenderServerSideOnlyHook;
     }
 }
-async function onBeforeRenderClientOnlyExists(pageContext) {
+function onBeforeRenderClientOnlyExists(pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
         const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
-        return getConfigValue(pageConfig, 'onBeforeRenderEnv')?.value === 'client-only';
+        const onBeforeRenderEnv = getConfigValue(pageConfig, 'onBeforeRenderEnv')?.value ?? {};
+        assert(isObject(onBeforeRenderEnv));
+        return !!onBeforeRenderEnv.client && !onBeforeRenderEnv.server;
     }
     else {
         // TODO/v1-release: remove
+        // Client-only onBeforeRender() hooks were never supported for the V0.4 design
         return false;
     }
 }

package/dist/esm/client/client-routing-runtime/index.d.ts

@@ -1,5 +1,6 @@
 export { navigate, reload } from './navigate.js';
 export { prefetch } from './prefetch.js';
+export { PROJECT_VERSION } from './utils.js';
 import type { PageContextBuiltInClientWithClientRouting } from '../../shared/types.js';
 /** @deprecated
  * Replace:

package/dist/esm/client/client-routing-runtime/index.js

@@ -5,3 +5,4 @@
 // Use package.json#exports to make the imports isomorphic.
 export { navigate, reload } from './navigate.js';
 export { prefetch } from './prefetch.js';
+export { PROJECT_VERSION } from './utils.js';

package/dist/esm/client/client-routing-runtime/onBrowserHistoryNavigation.js

@@ -14,8 +14,8 @@ function onBrowserHistoryNavigation() {
     //     - By user clicking on a hash link `<a href="#some-hash" />`
     //       - The popstate event is *only* triggered if `href` starts with '#' (even if `href` is '/#some-hash' while the current URL's pathname is '/' then the popstate still isn't triggered)
     //     - By JavaScript: `location.hash = 'some-hash'`
-    // - The `event` of `window.addEventListener('popstate', (event) => /*...*/)` is useless: the History API doesn't provide the previous state (the popped state), see https://stackoverflow.com/questions/48055323/is-history-state-always-the-same-as-popstate-event-state
-    window.addEventListener('popstate', () => {
+    // - The `event` argument of `window.addEventListener('popstate', (event) => /*...*/)` is useless: the History API doesn't provide the previous state (the popped state), see https://stackoverflow.com/questions/48055323/is-history-state-always-the-same-as-popstate-event-state
+    window.addEventListener('popstate', (ev) => {
         const currentState = getState();
         const scrollTarget = currentState.historyState.scrollPosition || 'scroll-to-top-or-hash';
         const isUserLandPushStateNavigation = currentState.historyState.triggedBy === 'user';

package/dist/esm/client/shared/getPageContextSerializedInHtml.js

@@ -4,7 +4,7 @@ export { getPageContextSerializedInHtml };
 function getPageContextSerializedInHtml() {
     const id = 'vike_pageContext';
     const elem = document.getElementById(id);
-    assertUsage(elem, `The element #${id} (which vike automatically injects into the HTML) is missing from the DOM. This may happen if your HTML is malformed. Make sure your HTML isn't malformed, and make sure you don't remove #${id} from the HTML nor from the DOM.`);
+    assertUsage(elem, `The element #${id} (which Vike automatically injects into the HTML) is missing from the DOM. This may happen if your HTML is malformed. Make sure your HTML isn't malformed, and make sure you don't remove #${id} from the HTML nor from the DOM.`);
     const pageContextJson = elem.textContent;
     assert(pageContextJson);
     const pageContextSerializedInHtml = parse(pageContextJson);

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

@@ -2,5 +2,6 @@ export default plugin;
 export { plugin };
 export { plugin as ssr };
 export type { ConfigVikeUserProvided as UserConfig };
+export { PROJECT_VERSION as version } from './utils.js';
 import type { ConfigVikeUserProvided } from '../../shared/ConfigVike.js';
 declare function plugin(vikeConfig?: ConfigVikeUserProvided): any;

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

@@ -2,6 +2,7 @@ export default plugin;
 export { plugin };
 // TODO/v1-release: remove
 export { plugin as ssr };
+export { PROJECT_VERSION as version } from './utils.js';
 import { assertUsage, markEnvAsVite } from './utils.js';
 import { buildConfig } from './plugins/buildConfig.js';
 import { previewConfig } from './plugins/previewConfig.js';

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

@@ -2,7 +2,7 @@ export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { assert, getFilePathAbsolute, isNotNullish, isNpmPackageImport, unique } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
-import { getConfigValueSourcesRelevant } from '../../shared/getConfigValueSourcesRelevant.js';
+import { getConfigValueSourcesNotOverriden } from '../../shared/getConfigValueSourcesNotOverriden.js';
 import { analyzeClientEntries } from '../buildConfig.js';
 import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 async function determineOptimizeDeps(config, configVike, isDev) {
@@ -30,12 +30,11 @@ async function getPageDeps(config, pageConfigs, isDev) {
     // V1 design
     {
         pageConfigs.forEach((pageConfig) => {
-            const configValueSourcesRelevant = getConfigValueSourcesRelevant(pageConfig);
-            configValueSourcesRelevant.forEach((configValueSource) => {
+            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/esm/node/plugin/plugins/importUserCode/v1-design/getConfigValuesSerialized.d.ts

@@ -0,0 +1,5 @@
+export { getConfigValuesSerialized };
+export { assertConfigValueIsSerializable };
+import type { ConfigEnvInternal, ConfigValueSource, DefinedAt, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
+declare function getConfigValuesSerialized(pageConfig: PageConfigBuildTime, isEnvMatch: (configEnv: ConfigEnvInternal, configValueSource?: ConfigValueSource) => boolean): string;
+declare function assertConfigValueIsSerializable(value: unknown, configName: string, definedAt: DefinedAt): void;

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

@@ -0,0 +1,70 @@
+export { getConfigValuesSerialized };
+export { assertConfigValueIsSerializable };
+import { assert, assertUsage, getPropAccessNotation } from '../../../utils.js';
+import { isJsonSerializerError, stringify } from '@brillout/json-serializer/stringify';
+import pc from '@brillout/picocolors';
+import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/helpers.js';
+import { serializeConfigValue } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
+import { getConfigValueSourcesNotOverriden } from '../../../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];
+        assert(configValue);
+        const { definedAt } = configValue;
+        const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+        serializeConfigValue(lines, configName, { definedAt, valueSerialized });
+    });
+    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);
+        serializeConfigValue(lines, configName, { definedAt, valueSerialized });
+    });
+    const code = lines.join('\n');
+    return code;
+}
+function assertConfigValueIsSerializable(value, configName, definedAt) {
+    // Contains asserts
+    getConfigValueSerialized(value, configName, definedAt);
+}
+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;
+}