vike 0.4.236-commit-eab75f6 → 0.4.237

package/dist/esm/node/runtime/html/serializeContext.d.ts

@@ -3,9 +3,12 @@ export { getPageContextClientSerializedAbort };
 export { getGlobalContextClientSerialized };
 export type { PageContextSerialization };
 export type { PassToClient };
+export type { PassToClientPublic };
 import type { UrlRedirect } from '../../../shared/route/abort.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
-type PageContextSerialization = {
+import type { PageContextCreated } from '../renderPage/createPageContextServerSide.js';
+import type { PageContextBegin } from '../renderPage.js';
+type PageContextSerialization = PageContextCreated & {
     pageId: string;
     routeParams: Record<string, string>;
     _passToClient: PassToClient;
@@ -13,12 +16,14 @@ type PageContextSerialization = {
     pageProps?: Record<string, unknown>;
     _pageContextInit: Record<string, unknown>;
     _globalContext: GlobalContextServerInternal;
-    isClientSideNavigation: boolean;
+    _isPageContextJsonRequest: null | PageContextBegin['_isPageContextJsonRequest'];
 };
 declare function getPageContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
 declare function getGlobalContextClientSerialized(pageContext: PageContextSerialization, isHtmlJsonScript: boolean): string;
-type PassToClient = (string | {
+type PassToClient = string[];
+type PassToClientPublic = (string | {
     prop: string;
+    /** @deprecated 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). */
     once?: boolean;
 })[];
 declare function getPageContextClientSerializedAbort(pageContext: Record<string, unknown> & ({

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

@@ -27,41 +27,24 @@ const passToClientBuiltInPageContext = [
 const pageToClientBuiltInPageContextError = ['pageProps', 'is404', 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) => getPropVal(pageContext._pageContextInit, prop))) {
         pageContextClient[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 && getPropVal(pageContext, prop)) {
-            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);
@@ -70,15 +53,11 @@ function serializeObject(obj, passToClient, getObj, isHtmlJsonScript) {
         const h = (s) => pc.cyan(s);
         let hasWarned = false;
         const propsNonSerializable = [];
-        passToClient.forEach((entry) => {
-            const entryNormalized = normalizePassToClientEntry(entry);
-            const { prop } = entryNormalized;
+        passToClient.forEach((prop) => {
             const res = getPropVal(obj, prop);
             if (!res)
                 return;
             const { value } = res;
-            const { objName } = getObj(entryNormalized) ?? {};
-            assert(objName);
             const varName = `${objName}${getPropKeys(prop).map(getPropAccessNotation).join('')}`;
             try {
                 serializeValue(value, isHtmlJsonScript, varName);
@@ -188,15 +167,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 = getPropVal(obj, prop);
         if (!res)
@@ -208,16 +182,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/esm/node/runtime/html/stream.js

@@ -522,8 +522,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/esm/node/runtime/renderPage/createPageContextServerSide.d.ts

@@ -4,7 +4,7 @@ export type { PageContextCreated };
 import type { GlobalContextServerInternal } from '../globalContext.js';
 import type { PageContextInit } from '../renderPage.js';
 type PageContextCreated = Awaited<ReturnType<typeof createPageContextServerSide>>;
-declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, { isPrerendering, ssr: { urlHandler, isClientSideNavigation }, }: {
+declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, args: {
     isPrerendering: false;
     ssr: {
         urlHandler: null | ((url: string) => string);

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

@@ -3,12 +3,9 @@ export { createPageContextServerSideWithoutGlobalContext };
 import { assert, assertUsage, assertWarning, augmentType, normalizeHeaders, objectAssign } from '../utils.js';
 import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComputed.js';
 import { createPageContextObject, createPageContextShared } from '../../../shared/createPageContextShared.js';
-function createPageContextServerSide(pageContextInit, globalContext, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
-    urlHandler: null,
-    isClientSideNavigation: false,
-}, }) {
+function createPageContextServerSide(pageContextInit, globalContext, args) {
     assert(pageContextInit.urlOriginal);
-    const pageContextCreated = createPageContext(pageContextInit, isPrerendering);
+    const pageContextCreated = createPageContext(pageContextInit, args.isPrerendering);
     objectAssign(pageContextCreated, {
         _globalContext: globalContext,
         _pageFilesAll: globalContext._pageFilesAll, // TO-DO/next-major-release: remove
@@ -17,8 +14,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,
     });
     objectAssign(pageContextCreated, globalContext._vikeConfigPublicGlobal);
     // pageContext.urlParsed

package/dist/esm/node/runtime/renderPage/handleErrorWithoutErrorPage.d.ts

@@ -1,8 +1,8 @@
 export { handleErrorWithoutErrorPage };
 import type { GlobalContextServerInternal } from '../globalContext.js';
 import type { PageContextAfterRender } from './renderPageAlreadyRouted.js';
-declare function handleErrorWithoutErrorPage<PageContext extends {
-    isClientSideNavigation: boolean;
+import type { PageContextCreated } from './createPageContextServerSide.js';
+declare function handleErrorWithoutErrorPage<PageContext extends PageContextCreated & {
     errorWhileRendering: null | Error;
     is404: null | boolean;
     pageId: null;

package/dist/esm/node/runtime/renderPage/handlePageContextRequestUrl.d.ts

@@ -1,5 +1,5 @@
 export { handlePageContextRequestUrl };
 declare function handlePageContextRequestUrl(url: string): {
+    isPageContextJsonRequest: boolean;
     urlWithoutPageContextRequestSuffix: string;
-    isPageContextRequest: boolean;
 };

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

@@ -1,30 +1,66 @@
 export { handlePageContextRequestUrl };
 import { pageContextJsonFileExtension, doNotCreateExtraDirectory } from '../../../shared/getPageContextRequestUrl.js';
-import { baseServer, parseUrl, assert, slice } from '../utils.js';
+import { modifyUrl } from '../../../shared/modifyUrl.js';
+import { baseServer, parseUrl, assert, slice, isObject, hasProp } from '../utils.js';
 // See also shared/getPageContextRequestUrl.ts
 function handlePageContextRequestUrl(url) {
-    if (!hasSuffix(url)) {
-        return { urlWithoutPageContextRequestSuffix: url, isPageContextRequest: false };
+    const urlParsed = parseUrl(url, 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 } = parseUrl(url, baseServer);
-    assert(pathnameOriginal.endsWith(pageContextJsonFileExtension) === pathname.endsWith(pageContextJsonFileExtension), {
-        url,
-    });
-    return pathnameOriginal.endsWith(pageContextJsonFileExtension);
+function isMatch(urlParsed) {
+    const { pathnameOriginal, pathname } = urlParsed;
+    assert(pathname.endsWith(pageContextJsonFileExtension) === pathnameOriginal.endsWith(pageContextJsonFileExtension));
+    return pathname.endsWith(pageContextJsonFileExtension);
 }
-function removePageContextUrlSuffix(url) {
-    const urlParsed = parseUrl(url, 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;
     assert(doNotCreateExtraDirectory === false);
     const urlSuffix = `/index${pageContextJsonFileExtension}`;
     assert(pathnameOriginal.endsWith(urlSuffix), { url });
     let pathnameModified = slice(pathnameOriginal, 0, -1 * urlSuffix.length);
     if (pathnameModified === '')
         pathnameModified = '/';
-    assert(url === `${origin || ''}${pathnameOriginal}${searchOriginal || ''}${hashOriginal || ''}`, { url });
-    return `${origin || ''}${pathnameModified}${searchOriginal || ''}${hashOriginal || ''}`;
+    const searchVikeArgs = search?._vike;
+    const urlWithoutPageContextRequestSuffix = 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);
+        assert(isObject(parsed));
+        if ('previousUrl' in parsed) {
+            assert(hasProp(parsed, 'previousUrl', 'string'));
+            args.previousUrl = parsed.previousUrl;
+        }
+    }
+    return args;
 }

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

@@ -2,7 +2,7 @@ export { loadPageConfigsLazyServerSideAndExecHook };
 import { getPageFilesServerSide } from '../../../shared/getPageFiles.js';
 import { resolveVikeConfigPublicPageLazy } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-import { assertUsage, assertWarning, hasProp, objectAssign } from '../utils.js';
+import { assertUsage, assertWarning, hasProp, isArray, isObject, objectAssign } from '../utils.js';
 import { getPageAssets } from './getPageAssets.js';
 import { debugPageFiles } from './debugPageFiles.js';
 import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
@@ -29,19 +29,32 @@ async function loadPageConfigsLazyServerSide(pageContext) {
     const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = await 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) => {
-            assertUsage(hasProp(e, 'exportValue', 'string[]'), `${e.exportSource}${errMsg}`);
+            assertUsage(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
+            assertUsage(isArray(value), `+passToClient value defined at ${definedAt} should be an array`);
+            const valS = value.map((el) => {
+                if (isObject(el)) {
+                    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 });
+                    assertUsage(hasProp(el, 'prop', 'string'), errMsg);
+                    return el.prop;
+                }
+                assertUsage(typeof el === 'string', errMsg);
+                return el;
+            });
+            /*/
+            assertUsage(isArrayOfStrings(value), errMsg)
+            //*/
+            passToClient.push(...valS);
         });
     }
     const pageContextAddendum = {};

package/dist/esm/node/runtime/renderPage/log404/index.d.ts

@@ -2,10 +2,10 @@ export { log404 };
 export { getRoutesInfo };
 import type { PageRoutes } from '../../../../shared/route/index.js';
 import type { GlobalContextServerInternal } from '../../globalContext.js';
-declare function log404(pageContext: {
+import type { PageContextCreated } from '../createPageContextServerSide.js';
+declare function log404(pageContext: PageContextCreated & {
     urlPathname: string;
     errorWhileRendering: null | Error;
-    isClientSideNavigation: boolean;
     _globalContext: GlobalContextServerInternal;
 }): Promise<void>;
 declare function getRoutesInfo(pageRoutes: PageRoutes): string | null;

package/dist/esm/node/runtime/renderPage/preparePageContextForPublicUsageServer.d.ts

@@ -14,7 +14,6 @@ type PageContextForPublicUsageServer = PageContextInternalServer & VikeConfigPub
     Page: unknown;
     pageId: string;
     is404: null | boolean;
-    isClientSideNavigation: boolean;
     _globalContext: GlobalContextServerInternal;
 };
 declare function preparePageContextForPublicUsageServer<PageContext extends PageContextForPublicUsageServer>(pageContext: PageContext): PageContext;

package/dist/esm/node/runtime/renderPage/renderPageAlreadyRouted.d.ts

@@ -5,6 +5,7 @@ import { type PageContextUrlInternal } from '../../../shared/getPageContextUrlCo
 import { HttpResponse } from './createHttpResponse.js';
 import { PageContext_loadPageConfigsLazyServerSide, type PageConfigsLazy } from './loadPageConfigsLazyServerSide.js';
 import type { PageContextCreated } from './createPageContextServerSide.js';
+import type { PageContextBegin } from '../renderPage.js';
 type PageContextAfterRender = {
     httpResponse: HttpResponse;
     errorWhileRendering: null | Error;
@@ -16,7 +17,7 @@ declare function renderPageAlreadyRouted<PageContext extends {
     routeParams: Record<string, string>;
     errorWhileRendering: null | Error;
     _httpRequestId: number;
-} & PageContextCreated & PageContextUrlInternal & PageContext_loadPageConfigsLazyServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
+} & PageContextCreated & PageContextBegin & PageContextUrlInternal & PageContext_loadPageConfigsLazyServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
 declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy & {
     routeParams: Record<string, string>;
     pageId: string;
@@ -134,8 +135,7 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         _pageContextAlreadyProvidedByOnPrerenderHook?: true;
         is404: boolean;
     } & {
-        isClientSideNavigation: boolean;
-        _urlHandler: null;
+        _isPageContextJsonRequest: null;
     };
 } | {
     documentHtml: string;
@@ -246,7 +246,6 @@ declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy
         _pageContextAlreadyProvidedByOnPrerenderHook?: true;
         is404: boolean;
     } & {
-        isClientSideNavigation: boolean;
-        _urlHandler: null;
+        _isPageContextJsonRequest: null;
     };
 }>;

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

@@ -58,8 +58,7 @@ async function renderPageAlreadyRouted(pageContext) {
 }
 async function prerenderPage(pageContext) {
     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
@@ -68,7 +67,6 @@ async function prerenderPage(pageContext) {
     await execHookDataAndOnBeforeRender(pageContext);
     const { htmlRender, renderHook } = await execHookOnRenderHtml(pageContext);
     assertUsage(htmlRender !== null, `Cannot pre-render ${pc.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
-    assert(pageContext.isClientSideNavigation === false);
     const documentHtml = await getHtmlString(htmlRender);
     assert(typeof documentHtml === 'string');
     if (!pageContext._usesClientRouter) {

package/dist/esm/node/runtime/renderPage.d.ts

@@ -109,4 +109,5 @@ declare function getPageContextBegin(pageContextInit: PageContextInit, globalCon
     headers: Record<string, string> | null;
 } & {
     _httpRequestId: number;
+    _isPageContextJsonRequest: boolean;
 };

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

@@ -307,7 +307,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 = createPageContextServerSide(pageContextInit, globalContext, {
         isPrerendering: false,
         ssr: {
@@ -315,13 +315,14 @@ function getPageContextBegin(pageContextInit, globalContext, httpRequestId) {
             isClientSideNavigation,
         },
     });
-    objectAssign(pageContextBegin, { _httpRequestId: httpRequestId });
+    objectAssign(pageContextBegin, { _httpRequestId: httpRequestId, _isPageContextJsonRequest });
     return pageContextBegin;
 }
 function handlePageContextUrl(urlOriginal) {
-    const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
+    const { isPageContextJsonRequest } = handlePageContextRequestUrl(urlOriginal);
     return {
-        isClientSideNavigation: isPageContextRequest,
+        isClientSideNavigation: !!isPageContextJsonRequest,
+        _isPageContextJsonRequest: isPageContextJsonRequest,
         _urlHandler: (url) => handlePageContextRequestUrl(url).urlWithoutPageContextRequestSuffix,
     };
 }
@@ -345,8 +346,8 @@ async function normalizeUrl(pageContextBegin, globalContext, httpRequestId) {
     if (disableUrlNormalization)
         return null;
     const { urlOriginal } = pageContext;
-    const { isPageContextRequest } = handlePageContextRequestUrl(urlOriginal);
-    if (isPageContextRequest)
+    const { isPageContextJsonRequest } = handlePageContextRequestUrl(urlOriginal);
+    if (isPageContextJsonRequest)
         return null;
     const urlNormalized = normalizeUrlPathname(urlOriginal, trailingSlash ?? false, globalContext.baseServer);
     if (!urlNormalized)

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

@@ -1,10 +1,11 @@
 export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { assert, assertIsImportPathNpmPackage, createDebugger, getNpmPackageName, isArray, isFilePathAbsoluteFilesystem, isVirtualFileId, } from '../../utils.js';
-import { getVikeConfigInternal, isOverridden } from '../../shared/resolveVikeConfigInternal.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
 import { analyzeClientEntries } from '../pluginBuild/pluginBuildConfig.js';
 import { virtualFileIdEntryClientCR, virtualFileIdEntryClientSR, } from '../../../shared/virtualFiles/virtualFileEntry.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
+import { getConfigValueSourcesRelevant } from '../pluginVirtualFiles/getConfigValueSourcesRelevant.js';
 const debug = createDebugger('vike:optimizeDeps');
 async function determineOptimizeDeps(config) {
     const vikeConfig = await getVikeConfigInternal();
@@ -38,43 +39,36 @@ async function getPageDeps(config, pageConfigs) {
     let entriesServer = [];
     let includeClient = [];
     let includeServer = [];
-    const addEntry = (e, configEnv, definedAt) => {
+    const addEntry = (e, isForClientSide, definedAt) => {
         assert(e);
         // optimizeDeps.entries expects filesystem absolute paths
         assert(isVirtualFileId(e) || 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) => {
         assert(e);
         // optimizeDeps.include expects npm packages
         assert(!e.startsWith('/'));
         // Shouldn't be a path alias, as path aliases would need to be added to optimizeDeps.entries instead of optimizeDeps.include
         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) {
@@ -86,26 +80,34 @@ async function getPageDeps(config, pageConfigs) {
     };
     // V1 design
     {
-        pageConfigs.forEach((pageConfig) => {
-            Object.entries(pageConfig.configValueSources).forEach(([configName, sources]) => {
-                sources
-                    .filter((source) => !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 = 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);
+                        }
+                    });
                 });
             });
         });
@@ -117,7 +119,7 @@ async function getPageDeps(config, pageConfigs) {
         pageFiles.forEach((filePathAbsoluteUserRootDir) => {
             const entry = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
             const { filePathAbsoluteFilesystem } = entry;
-            addEntry(filePathAbsoluteFilesystem);
+            addEntry(filePathAbsoluteFilesystem, true);
         });
     }
     // Add virtual files.
@@ -127,11 +129,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 } = analyzeClientEntries(pageConfigs, config);
-        Object.values(clientEntries).forEach((e) => addEntry(e));
+        Object.values(clientEntries).forEach((e) => addEntry(e, true));
         if (hasClientRouting)
-            addEntry(virtualFileIdEntryClientCR);
+            addEntry(virtualFileIdEntryClientCR, true);
         if (hasServerRouting)
-            addEntry(virtualFileIdEntryClientSR);
+            addEntry(virtualFileIdEntryClientSR, true);
     }
     entriesClient = entriesClient;
     entriesServer = entriesServer;

package/dist/esm/node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.d.ts

@@ -0,0 +1,14 @@
+export { getConfigValueSourcesRelevant };
+export { isRuntimeEnvMatch };
+export type { RuntimeEnv };
+import type { ConfigEnvInternal, ConfigValueSource, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../../types/PageConfig.js';
+type RuntimeEnv = {
+    isForClientSide: boolean;
+    isClientRouting: boolean;
+    isDev?: boolean;
+} | {
+    isForConfig: true;
+};
+declare function getConfigValueSourcesRelevant(configName: string, runtimeEnv: RuntimeEnv, pageConfig: PageConfigPartial): ConfigValueSource[];
+declare function isRuntimeEnvMatch(configEnv: ConfigEnvInternal, runtimeEnv: RuntimeEnv): boolean;
+type PageConfigPartial = Pick<PageConfigBuildTime | PageConfigGlobalBuildTime, 'configValueSources' | 'configDefinitions'>;