vike 0.4.236-commit-eab75f6 → 0.4.237

package/dist/cjs/client/shared/createGetGlobalContextClient.js

@@ -20,10 +20,8 @@ function createGetGlobalContextClient(virtualFileExports, isClientRouting, addGl
     getGlobalContext();
     return getGlobalContext;
     async function getGlobalContext() {
-        // Cache
-        if (globalObject.virtualFileExports &&
-            // Don't break HMR
-            globalObject.virtualFileExports === virtualFileExports) {
+        // HMR => virtualFileExports differ
+        if (globalObject.virtualFileExports === virtualFileExports) {
             const globalContext = await globalObject.globalContextPromise;
             return globalContext;
         }

package/dist/cjs/node/runtime/html/serializeContext.js

@@ -32,41 +32,24 @@ const passToClientBuiltInPageContext = [
 const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError_js_1.isServerSideError];
 function getPageContextClientSerialized(pageContext, isHtmlJsonScript) {
     const passToClientPageContext = getPassToClientPageContext(pageContext);
-    const getObj = (passToClientEntry) => {
-        if (passToClientEntry.once)
-            return undefined; // pass it to client-side globalContext
-        return { obj: pageContext, objName: 'pageContext' };
-    };
-    const res = applyPassToClient(passToClientPageContext, getObj);
+    const res = applyPassToClient(passToClientPageContext, pageContext);
     const pageContextClient = res.objClient;
     const pageContextClientProps = res.objClientProps;
     if (pageContextClientProps.some((prop) => (0, propKeys_js_1.getPropVal)(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient_js_1.pageContextInitIsPassedToClient] = true;
     }
-    const pageContextClientSerialized = serializeObject(pageContextClient, passToClientPageContext, getObj, isHtmlJsonScript);
+    const pageContextClientSerialized = serializeObject(pageContextClient, passToClientPageContext, 'pageContext', isHtmlJsonScript);
     return pageContextClientSerialized;
 }
 function getGlobalContextClientSerialized(pageContext, isHtmlJsonScript) {
     const passToClient = pageContext._passToClient;
     const globalContext = pageContext._globalContext;
-    const getObj = ({ prop, once }) => {
-        if (once && (0, propKeys_js_1.getPropVal)(pageContext, prop)) {
-            (0, utils_js_1.assert)(typeof pageContext.isClientSideNavigation === 'boolean');
-            if (!pageContext.isClientSideNavigation) {
-                return { obj: pageContext, objName: 'pageContext' }; // pass it to client-side globalContext
-            }
-            else {
-                return undefined; // already passed to client-side
-            }
-        }
-        return { obj: globalContext, objName: 'globalContext' };
-    };
-    const res = applyPassToClient(passToClient, getObj);
+    const res = applyPassToClient(passToClient, globalContext);
     const globalContextClient = res.objClient;
-    const globalContextClientSerialized = serializeObject(globalContextClient, passToClient, getObj, isHtmlJsonScript);
+    const globalContextClientSerialized = serializeObject(globalContextClient, passToClient, 'globalContext', isHtmlJsonScript);
     return globalContextClientSerialized;
 }
-function serializeObject(obj, passToClient, getObj, isHtmlJsonScript) {
+function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
     let serialized;
     try {
         serialized = serializeValue(obj, isHtmlJsonScript);
@@ -75,15 +58,11 @@ function serializeObject(obj, passToClient, getObj, isHtmlJsonScript) {
         const h = (s) => picocolors_1.default.cyan(s);
         let hasWarned = false;
         const propsNonSerializable = [];
-        passToClient.forEach((entry) => {
-            const entryNormalized = normalizePassToClientEntry(entry);
-            const { prop } = entryNormalized;
+        passToClient.forEach((prop) => {
             const res = (0, propKeys_js_1.getPropVal)(obj, prop);
             if (!res)
                 return;
             const { value } = res;
-            const { objName } = getObj(entryNormalized) ?? {};
-            (0, utils_js_1.assert)(objName);
             const varName = `${objName}${(0, propKeys_js_1.getPropKeys)(prop).map(utils_js_1.getPropAccessNotation).join('')}`;
             try {
                 serializeValue(value, isHtmlJsonScript, varName);
@@ -193,15 +172,10 @@ function getPageContextClientSerializedAbort(pageContext, isHtmlJsonScript) {
     }
     return serializeValue(pageContext, isHtmlJsonScript);
 }
-function applyPassToClient(passToClient, getObj) {
+function applyPassToClient(passToClient, obj) {
     const objClient = {};
     const objClientProps = [];
-    passToClient.forEach((entry) => {
-        const entryNormalized = normalizePassToClientEntry(entry);
-        const { prop } = entryNormalized;
-        const { obj } = getObj(entryNormalized) ?? {};
-        if (!obj)
-            return;
+    passToClient.forEach((prop) => {
         // Get value from pageContext
         const res = (0, propKeys_js_1.getPropVal)(obj, prop);
         if (!res)
@@ -213,16 +187,3 @@ function applyPassToClient(passToClient, getObj) {
     });
     return { objClient, objClientProps };
 }
-function normalizePassToClientEntry(entry) {
-    let once;
-    let prop;
-    if (typeof entry === 'string') {
-        prop = entry;
-        once = false;
-    }
-    else {
-        prop = entry.prop;
-        once = entry.once ?? false;
-    }
-    return { prop, once };
-}

package/dist/cjs/node/runtime/html/stream.js

@@ -527,8 +527,8 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         const closeStream = async () => {
             if (isClosed)
                 return;
-            isClosed = true;
             await onEnd(isCancel);
+            isClosed = true;
             controllerProxy.close();
         };
         let controllerProxy;

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

@@ -5,12 +5,9 @@ exports.createPageContextServerSideWithoutGlobalContext = createPageContextServe
 const utils_js_1 = require("../utils.js");
 const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
 const createPageContextShared_js_1 = require("../../../shared/createPageContextShared.js");
-function createPageContextServerSide(pageContextInit, globalContext, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
-    urlHandler: null,
-    isClientSideNavigation: false,
-}, }) {
+function createPageContextServerSide(pageContextInit, globalContext, args) {
     (0, utils_js_1.assert)(pageContextInit.urlOriginal);
-    const pageContextCreated = createPageContext(pageContextInit, isPrerendering);
+    const pageContextCreated = createPageContext(pageContextInit, args.isPrerendering);
     (0, utils_js_1.objectAssign)(pageContextCreated, {
         _globalContext: globalContext,
         _pageFilesAll: globalContext._pageFilesAll, // TO-DO/next-major-release: remove
@@ -19,8 +16,8 @@ function createPageContextServerSide(pageContextInit, globalContext, { isPrerend
         _baseAssets: globalContext.baseAssets,
         _pageContextInit: pageContextInit,
         _urlRewrite: null,
-        _urlHandler: urlHandler,
-        isClientSideNavigation,
+        _urlHandler: args.ssr?.urlHandler ?? null,
+        isClientSideNavigation: args.ssr?.isClientSideNavigation ?? false,
     });
     (0, utils_js_1.objectAssign)(pageContextCreated, globalContext._vikeConfigPublicGlobal);
     // pageContext.urlParsed

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

@@ -2,31 +2,67 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handlePageContextRequestUrl = handlePageContextRequestUrl;
 const getPageContextRequestUrl_js_1 = require("../../../shared/getPageContextRequestUrl.js");
+const modifyUrl_js_1 = require("../../../shared/modifyUrl.js");
 const utils_js_1 = require("../utils.js");
 // See also shared/getPageContextRequestUrl.ts
 function handlePageContextRequestUrl(url) {
-    if (!hasSuffix(url)) {
-        return { urlWithoutPageContextRequestSuffix: url, isPageContextRequest: false };
+    const urlParsed = (0, utils_js_1.parseUrl)(url, utils_js_1.baseServer);
+    if (!isMatch(urlParsed)) {
+        return {
+            isPageContextJsonRequest: false,
+            urlWithoutPageContextRequestSuffix: url,
+        };
+    }
+    else {
+        const { urlWithoutPageContextRequestSuffix, searchVikeArgs } = processUrl(urlParsed, url);
+        const previousUrl = parseSearchVikeArgs(searchVikeArgs);
+        return {
+            /* TO-DO/soon/once: pass & use previousUrl
+            isPageContextJsonRequest: { previousUrl },
+            /*/
+            isPageContextJsonRequest: true,
+            //*/
+            urlWithoutPageContextRequestSuffix,
+        };
     }
-    return { urlWithoutPageContextRequestSuffix: removePageContextUrlSuffix(url), isPageContextRequest: true };
 }
-function hasSuffix(url) {
-    const { pathnameOriginal, pathname } = (0, utils_js_1.parseUrl)(url, utils_js_1.baseServer);
-    (0, utils_js_1.assert)(pathnameOriginal.endsWith(getPageContextRequestUrl_js_1.pageContextJsonFileExtension) === pathname.endsWith(getPageContextRequestUrl_js_1.pageContextJsonFileExtension), {
-        url,
-    });
-    return pathnameOriginal.endsWith(getPageContextRequestUrl_js_1.pageContextJsonFileExtension);
+function isMatch(urlParsed) {
+    const { pathnameOriginal, pathname } = urlParsed;
+    (0, utils_js_1.assert)(pathname.endsWith(getPageContextRequestUrl_js_1.pageContextJsonFileExtension) === pathnameOriginal.endsWith(getPageContextRequestUrl_js_1.pageContextJsonFileExtension));
+    return pathname.endsWith(getPageContextRequestUrl_js_1.pageContextJsonFileExtension);
 }
-function removePageContextUrlSuffix(url) {
-    const urlParsed = (0, utils_js_1.parseUrl)(url, utils_js_1.baseServer);
+function processUrl(urlParsed, url) {
     // We cannot use `urlParsed.pathname` because it would break the `urlParsed.pathnameOriginal` value of subsequent `parseUrl()` calls.
-    const { origin, pathnameOriginal, searchOriginal, hashOriginal } = urlParsed;
+    const { pathnameOriginal, search } = urlParsed;
     (0, utils_js_1.assert)(getPageContextRequestUrl_js_1.doNotCreateExtraDirectory === false);
     const urlSuffix = `/index${getPageContextRequestUrl_js_1.pageContextJsonFileExtension}`;
     (0, utils_js_1.assert)(pathnameOriginal.endsWith(urlSuffix), { url });
     let pathnameModified = (0, utils_js_1.slice)(pathnameOriginal, 0, -1 * urlSuffix.length);
     if (pathnameModified === '')
         pathnameModified = '/';
-    (0, utils_js_1.assert)(url === `${origin || ''}${pathnameOriginal}${searchOriginal || ''}${hashOriginal || ''}`, { url });
-    return `${origin || ''}${pathnameModified}${searchOriginal || ''}${hashOriginal || ''}`;
+    const searchVikeArgs = search?._vike;
+    const urlWithoutPageContextRequestSuffix = (0, modifyUrl_js_1.modifyUrl)(url, {
+        pathname: pathnameModified,
+        search: {
+            _vike: searchVikeArgs ? null : undefined,
+        },
+    });
+    return {
+        searchVikeArgs,
+        urlWithoutPageContextRequestSuffix,
+    };
+}
+function parseSearchVikeArgs(searchVikeArgs) {
+    const args = {
+        previousUrl: null,
+    };
+    if (searchVikeArgs) {
+        const parsed = JSON.parse(searchVikeArgs);
+        (0, utils_js_1.assert)((0, utils_js_1.isObject)(parsed));
+        if ('previousUrl' in parsed) {
+            (0, utils_js_1.assert)((0, utils_js_1.hasProp)(parsed, 'previousUrl', 'string'));
+            args.previousUrl = parsed.previousUrl;
+        }
+    }
+    return args;
 }

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

@@ -31,19 +31,32 @@ async function loadPageConfigsLazyServerSide(pageContext) {
     const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = await (0, analyzePage_js_1.analyzePage)(pageContext._globalContext._pageFilesAll, pageConfig, pageContext.pageId, globalContext);
     const isV1Design = !!pageConfig;
     const passToClient = [];
-    const errMsg = ' should be an array of strings.';
+    const errMsgSuffix = ' should be an array of strings.';
     if (!isV1Design) {
         configPublicPageLazy.exportsAll.passToClient?.forEach((e) => {
-            (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(e, 'exportValue', 'string[]'), `${e.exportSource}${errMsg}`);
+            (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(e, 'exportValue', 'string[]'), `${e.exportSource}${errMsgSuffix}`);
             passToClient.push(...e.exportValue);
         });
     }
     else {
         configPublicPageLazy.from.configsCumulative.passToClient?.values.forEach((v) => {
-            const { value } = v;
-            // const { definedAt } = v
-            // assertUsage(isArrayOfStrings(value), `+passToClient value defined at ${definedAt}${errMsg}`)
-            passToClient.push(...value);
+            const { value, definedAt } = v;
+            const errMsg = `+passToClient value defined at ${definedAt}${errMsgSuffix}`;
+            //*/ TO-DO/next-major-release: remove the passToClient once setting from the public API
+            (0, utils_js_1.assertUsage)((0, utils_js_1.isArray)(value), `+passToClient value defined at ${definedAt} should be an array`);
+            const valS = value.map((el) => {
+                if ((0, utils_js_1.isObject)(el)) {
+                    (0, utils_js_1.assertWarning)(!('once' in el), 'The passToClient once setting is deprecated and no longer has any effect. Instead, see the upcoming .once.js suffix (see https://github.com/vikejs/vike/issues/2566 for more information).', { onlyOnce: true });
+                    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(el, 'prop', 'string'), errMsg);
+                    return el.prop;
+                }
+                (0, utils_js_1.assertUsage)(typeof el === 'string', errMsg);
+                return el;
+            });
+            /*/
+            assertUsage(isArrayOfStrings(value), errMsg)
+            //*/
+            passToClient.push(...valS);
         });
     }
     const pageContextAddendum = {};

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

@@ -63,8 +63,7 @@ async function renderPageAlreadyRouted(pageContext) {
 }
 async function prerenderPage(pageContext) {
     (0, utils_js_1.objectAssign)(pageContext, {
-        isClientSideNavigation: false,
-        _urlHandler: null,
+        _isPageContextJsonRequest: null,
     });
     /* Should we execute the guard() hook upon pre-rendering? Is there a use case for this?
      *  - It isn't trivial to implement, as it requires to duplicate / factor out the isAbortError() handling
@@ -73,7 +72,6 @@ async function prerenderPage(pageContext) {
     await (0, execHookDataAndOnBeforeRender_js_1.execHookDataAndOnBeforeRender)(pageContext);
     const { htmlRender, renderHook } = await (0, execHookOnRenderHtml_js_1.execHookOnRenderHtml)(pageContext);
     (0, utils_js_1.assertUsage)(htmlRender !== null, `Cannot pre-render ${picocolors_1.default.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
-    (0, utils_js_1.assert)(pageContext.isClientSideNavigation === false);
     const documentHtml = await (0, renderHtml_js_1.getHtmlString)(htmlRender);
     (0, utils_js_1.assert)(typeof documentHtml === 'string');
     if (!pageContext._usesClientRouter) {

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

@@ -312,7 +312,7 @@ async function getPageContextErrorPageInit(pageContextBegin, errNominalPage, pag
     return pageContext;
 }
 function getPageContextBegin(pageContextInit, globalContext, httpRequestId) {
-    const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
+    const { isClientSideNavigation, _urlHandler, _isPageContextJsonRequest } = handlePageContextUrl(pageContextInit.urlOriginal);
     const pageContextBegin = (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, {
         isPrerendering: false,
         ssr: {
@@ -320,13 +320,14 @@ function getPageContextBegin(pageContextInit, globalContext, httpRequestId) {
             isClientSideNavigation,
         },
     });
-    (0, utils_js_1.objectAssign)(pageContextBegin, { _httpRequestId: httpRequestId });
+    (0, utils_js_1.objectAssign)(pageContextBegin, { _httpRequestId: httpRequestId, _isPageContextJsonRequest });
     return pageContextBegin;
 }
 function handlePageContextUrl(urlOriginal) {
-    const { isPageContextRequest } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
+    const { isPageContextJsonRequest } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
     return {
-        isClientSideNavigation: isPageContextRequest,
+        isClientSideNavigation: !!isPageContextJsonRequest,
+        _isPageContextJsonRequest: isPageContextJsonRequest,
         _urlHandler: (url) => (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(url).urlWithoutPageContextRequestSuffix,
     };
 }
@@ -350,8 +351,8 @@ async function normalizeUrl(pageContextBegin, globalContext, httpRequestId) {
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContext;
-    const { isPageContextRequest } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
-    if (isPageContextRequest)
+    const { isPageContextJsonRequest } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
+    if (isPageContextJsonRequest)
         return null;
     const urlNormalized = (0, utils_js_1.normalizeUrlPathname)(urlOriginal, trailingSlash ?? false, globalContext.baseServer);
     if (!urlNormalized)

package/dist/cjs/node/vite/plugins/pluginDev/determineOptimizeDeps.js

@@ -7,6 +7,7 @@ const resolveVikeConfigInternal_js_1 = require("../../shared/resolveVikeConfigIn
 const pluginBuildConfig_js_1 = require("../pluginBuild/pluginBuildConfig.js");
 const virtualFileEntry_js_1 = require("../../../shared/virtualFiles/virtualFileEntry.js");
 const getFilePath_js_1 = require("../../shared/getFilePath.js");
+const getConfigValueSourcesRelevant_js_1 = require("../pluginVirtualFiles/getConfigValueSourcesRelevant.js");
 const debug = (0, utils_js_1.createDebugger)('vike:optimizeDeps');
 async function determineOptimizeDeps(config) {
     const vikeConfig = await (0, resolveVikeConfigInternal_js_1.getVikeConfigInternal)();
@@ -40,43 +41,36 @@ async function getPageDeps(config, pageConfigs) {
     let entriesServer = [];
     let includeClient = [];
     let includeServer = [];
-    const addEntry = (e, configEnv, definedAt) => {
+    const addEntry = (e, isForClientSide, definedAt) => {
         (0, utils_js_1.assert)(e);
         // optimizeDeps.entries expects filesystem absolute paths
         (0, utils_js_1.assert)((0, utils_js_1.isVirtualFileId)(e) || (0, utils_js_1.isFilePathAbsoluteFilesystem)(e));
-        if (isRelevant(e, false, configEnv, definedAt)) {
+        if (isExcluded(e, isForClientSide, definedAt))
+            return;
+        if (isForClientSide) {
             entriesClient.push(e);
         }
-        if (isRelevant(e, true, configEnv, definedAt)) {
+        else {
             entriesServer.push(e);
         }
     };
-    const addInclude = (e, configEnv, definedAt) => {
+    const addInclude = (e, isForClientSide, definedAt) => {
         (0, utils_js_1.assert)(e);
         // optimizeDeps.include expects npm packages
         (0, utils_js_1.assert)(!e.startsWith('/'));
         // Shouldn't be a path alias, as path aliases would need to be added to optimizeDeps.entries instead of optimizeDeps.include
         (0, utils_js_1.assertIsImportPathNpmPackage)(e);
-        if (isRelevant(e, false, configEnv, definedAt)) {
+        if (isExcluded(e, isForClientSide, definedAt))
+            return;
+        if (isForClientSide) {
             includeClient.push(e);
         }
-        if (isRelevant(e, true, configEnv, definedAt)) {
-            includeServer.push(e);
-        }
-    };
-    const isRelevant = (e, server, configEnv, definedAt) => {
-        if (server) {
-            if (!configEnv || !configEnv.server)
-                return false;
-        }
         else {
-            if (configEnv && !configEnv.client)
-                return false;
+            includeServer.push(e);
         }
-        return !isExcluded(e, server, definedAt);
     };
-    const isExcluded = (e, server, definedAt) => {
-        const exclude = server ? config.ssr.optimizeDeps.exclude : config.optimizeDeps.exclude;
+    const isExcluded = (e, isForClientSide, definedAt) => {
+        const exclude = isForClientSide ? config.optimizeDeps.exclude : config.ssr.optimizeDeps.exclude;
         if (!exclude)
             return false;
         if (definedAt?.importPathAbsolute) {
@@ -88,26 +82,34 @@ async function getPageDeps(config, pageConfigs) {
     };
     // V1 design
     {
-        pageConfigs.forEach((pageConfig) => {
-            Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
-                sources
-                    .filter((source) => !(0, resolveVikeConfigInternal_js_1.isOverridden)(source, configName, pageConfig))
-                    .forEach((configValueSource) => {
-                    if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
-                        return;
-                    const { definedAt, configEnv } = configValueSource;
-                    if (definedAt.definedBy)
-                        return;
-                    if (definedAt.filePathAbsoluteUserRootDir !== null) {
-                        addEntry(
-                        // optimizeDeps.entries expects filesystem absolute paths
-                        definedAt.filePathAbsoluteFilesystem, configEnv, definedAt);
-                    }
-                    else {
-                        addInclude(
-                        // optimizeDeps.include expects npm packages
-                        definedAt.importPathAbsolute, configEnv, definedAt);
-                    }
+        ;
+        [true, false].forEach((isForClientSide) => {
+            pageConfigs.forEach((pageConfig) => {
+                Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
+                    const runtimeEnv = {
+                        isForClientSide,
+                        isDev: true,
+                        // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
+                        isClientRouting: true,
+                    };
+                    const sourcesRelevant = (0, getConfigValueSourcesRelevant_js_1.getConfigValueSourcesRelevant)(configName, runtimeEnv, pageConfig);
+                    sourcesRelevant.forEach((configValueSource) => {
+                        if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
+                            return;
+                        const { definedAt } = configValueSource;
+                        if (definedAt.definedBy)
+                            return;
+                        if (definedAt.filePathAbsoluteUserRootDir !== null) {
+                            addEntry(
+                            // optimizeDeps.entries expects filesystem absolute paths
+                            definedAt.filePathAbsoluteFilesystem, isForClientSide, definedAt);
+                        }
+                        else {
+                            addInclude(
+                            // optimizeDeps.include expects npm packages
+                            definedAt.importPathAbsolute, isForClientSide, definedAt);
+                        }
+                    });
                 });
             });
         });
@@ -119,7 +121,7 @@ async function getPageDeps(config, pageConfigs) {
         pageFiles.forEach((filePathAbsoluteUserRootDir) => {
             const entry = (0, getFilePath_js_1.getFilePathResolved)({ filePathAbsoluteUserRootDir, userRootDir });
             const { filePathAbsoluteFilesystem } = entry;
-            addEntry(filePathAbsoluteFilesystem);
+            addEntry(filePathAbsoluteFilesystem, true);
         });
     }
     // Add virtual files.
@@ -129,11 +131,11 @@ async function getPageDeps(config, pageConfigs) {
     //     - If we do, then we need to adjust include/entries (maybe by making include === entries -> will Vite complain?)
     {
         const { hasClientRouting, hasServerRouting, clientEntries } = (0, pluginBuildConfig_js_1.analyzeClientEntries)(pageConfigs, config);
-        Object.values(clientEntries).forEach((e) => addEntry(e));
+        Object.values(clientEntries).forEach((e) => addEntry(e, true));
         if (hasClientRouting)
-            addEntry(virtualFileEntry_js_1.virtualFileIdEntryClientCR);
+            addEntry(virtualFileEntry_js_1.virtualFileIdEntryClientCR, true);
         if (hasServerRouting)
-            addEntry(virtualFileEntry_js_1.virtualFileIdEntryClientSR);
+            addEntry(virtualFileEntry_js_1.virtualFileIdEntryClientSR, true);
     }
     entriesClient = entriesClient;
     entriesServer = entriesServer;

package/dist/cjs/node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigValueSourcesRelevant = getConfigValueSourcesRelevant;
+exports.isRuntimeEnvMatch = isRuntimeEnvMatch;
+const utils_js_1 = require("../../utils.js");
+function getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig) {
+    const configDef = pageConfig.configDefinitions[configName];
+    (0, utils_js_1.assert)(configDef);
+    let sourcesRelevant = pageConfig.configValueSources[configName];
+    if (!sourcesRelevant)
+        return [];
+    if (!configDef.cumulative) {
+        const source = sourcesRelevant[0];
+        if (source) {
+            sourcesRelevant = [source];
+        }
+        else {
+            (0, utils_js_1.assert)(sourcesRelevant.length === 0);
+        }
+    }
+    else {
+        // isOverridden() must be called before isRuntimeEnvMatch() is called (otherwise isOverridden() will return a wrong value)
+        sourcesRelevant = sourcesRelevant.filter((source) => !isOverridden(source, configName, pageConfig));
+    }
+    sourcesRelevant = sourcesRelevant.filter((source) => isRuntimeEnvMatch(source.configEnv, runtimeEnv));
+    return sourcesRelevant;
+}
+function isRuntimeEnvMatch(configEnv, runtimeEnv) {
+    if ('isForConfig' in runtimeEnv)
+        return !!configEnv.config;
+    // Runtime
+    if (!runtimeEnv.isForClientSide) {
+        if (!configEnv.server)
+            return false;
+    }
+    else {
+        if (!configEnv.client)
+            return false;
+        if (configEnv.client === 'if-client-routing' && !runtimeEnv.isClientRouting)
+            return false;
+    }
+    // Production/development
+    if (configEnv.production !== undefined) {
+        (0, utils_js_1.assert)(typeof configEnv.production === 'boolean');
+        (0, utils_js_1.assert)(typeof runtimeEnv.isDev === 'boolean');
+        if (configEnv.production) {
+            if (runtimeEnv.isDev)
+                return false;
+        }
+        else {
+            if (!runtimeEnv.isDev)
+                return false;
+        }
+    }
+    return true;
+}
+function isOverridden(source, configName, pageConfig) {
+    const configDef = pageConfig.configDefinitions[configName];
+    (0, utils_js_1.assert)(configDef);
+    if (configDef.cumulative)
+        return false;
+    const sources = pageConfig.configValueSources[configName];
+    (0, utils_js_1.assert)(sources);
+    const idx = sources.indexOf(source);
+    (0, utils_js_1.assert)(idx >= 0);
+    return idx > 0;
+}

package/dist/cjs/node/vite/plugins/pluginVirtualFiles/getVirtualFilePageConfigLazy.js

@@ -7,7 +7,6 @@ const virtualFilePageConfigLazy_js_1 = require("../../../shared/virtualFiles/vir
 const resolveVikeConfigInternal_js_1 = require("../../shared/resolveVikeConfigInternal.js");
 const extractAssetsQuery_js_1 = require("../../../shared/extractAssetsQuery.js");
 const debug_js_1 = require("./debug.js");
-const isRuntimeEnvMatch_js_1 = require("./isRuntimeEnvMatch.js");
 const serializeConfigValues_js_1 = require("../../../../shared/page-configs/serialize/serializeConfigValues.js");
 const handleAssetsManifest_js_1 = require("../pluginBuild/handleAssetsManifest.js");
 const getConfigValueBuildTime_js_1 = require("../../../../shared/page-configs/getConfigValueBuildTime.js");
@@ -46,7 +45,7 @@ function getLoadConfigLazy(pageConfig, isForClientSide, pageId, includeAssetsImp
     const filesEnv = new Map();
     const isClientRouting = (0, getConfigValueBuildTime_js_1.getConfigValueBuildTime)(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
     lines.push('export const configValuesSerialized = {');
-    lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfig, importStatements, filesEnv, (configEnv) => (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isDev }), '', false));
+    lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '', false));
     lines.push('};');
     if (!(0, handleAssetsManifest_js_1.handleAssetsManifest_isFixEnabled)(config) && includeAssetsImportedByServer && isForClientSide && !isDev) {
         importStatements.push(`import '${(0, extractAssetsQuery_js_1.extractAssetsAddQuery)((0, virtualFilePageConfigLazy_js_1.getVirtualFileIdPageConfigLazy)(pageId, false))}'`);

package/dist/cjs/node/vite/plugins/pluginVirtualFiles/getVirtualFilePageConfigsEager.js

@@ -4,7 +4,6 @@ exports.getVirtualFilePageConfigsEager = getVirtualFilePageConfigsEager;
 const virtualFilePageConfigLazy_js_1 = require("../../../shared/virtualFiles/virtualFilePageConfigLazy.js");
 const debug_js_1 = require("./debug.js");
 const resolveVikeConfigInternal_js_1 = require("../../shared/resolveVikeConfigInternal.js");
-const isRuntimeEnvMatch_js_1 = require("./isRuntimeEnvMatch.js");
 const serializeConfigValues_js_1 = require("../../../../shared/page-configs/serialize/serializeConfigValues.js");
 async function getVirtualFilePageConfigsEager(isForClientSide, isDev, id, isClientRouting) {
     const vikeConfig = await (0, resolveVikeConfigInternal_js_1.getVikeConfigInternal)(true);
@@ -41,7 +40,7 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
         const load = `() => ({ moduleId: ${virtualFileId}, moduleExports: import(${virtualFileId}) })`;
         lines.push(`    loadConfigLazy: ${load},`);
         lines.push(`    configValuesSerialized: {`);
-        lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfig, importStatements, filesEnv, (configEnv) => (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', true));
+        lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', true));
         lines.push(`    },`);
         lines.push(`  },`);
     });
@@ -51,7 +50,7 @@ function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRout
 function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
     const lines = [];
     lines.push(`  configValuesSerialized: {`);
-    lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfigGlobal, importStatements, filesEnv, (configEnv) => (0, isRuntimeEnvMatch_js_1.isRuntimeEnvMatch)(configEnv, { isForClientSide, isClientRouting, isDev }), '    ', null));
+    lines.push(...(0, serializeConfigValues_js_1.serializeConfigValues)(pageConfigGlobal, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', null));
     lines.push(`  },`);
     const code = lines.join('\n');
     return code;