vike 0.4.236 → 0.4.237-commit-85e89b1

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

@@ -30,63 +30,42 @@ const passToClientBuiltInPageContext = [
     'data', // for data() hook
 ];
 const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError_js_1.isServerSideError];
-function getPageContextClientSerialized(pageContext) {
+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);
+    const pageContextClientSerialized = serializeObject(pageContextClient, passToClientPageContext, 'pageContext', isHtmlJsonScript);
     return pageContextClientSerialized;
 }
-function getGlobalContextClientSerialized(pageContext) {
+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);
+    const globalContextClientSerialized = serializeObject(globalContextClient, passToClient, 'globalContext', isHtmlJsonScript);
     return globalContextClientSerialized;
 }
-function serializeObject(obj, passToClient, getObj) {
+function serializeObject(obj, passToClient, objName, isHtmlJsonScript) {
     let serialized;
     try {
-        serialized = serializeValue(obj);
+        serialized = serializeValue(obj, isHtmlJsonScript);
     }
     catch (err) {
         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, varName);
+                serializeValue(value, isHtmlJsonScript, varName);
             }
             catch (err) {
                 propsNonSerializable.push(prop);
@@ -124,7 +103,7 @@ function serializeObject(obj, passToClient, getObj) {
             obj[(0, propKeys_js_1.getPropKeys)(prop)[0]] = NOT_SERIALIZABLE_js_1.NOT_SERIALIZABLE;
         });
         try {
-            serialized = serializeValue(obj);
+            serialized = serializeValue(obj, isHtmlJsonScript);
         }
         catch (err) {
             (0, utils_js_1.assert)(false);
@@ -132,20 +111,20 @@ function serializeObject(obj, passToClient, getObj) {
     }
     return serialized;
 }
-function serializeValue(value, varName) {
+function serializeValue(value, isHtmlJsonScript, varName) {
     return (0, stringify_1.stringify)(value, {
         forbidReactElements: true,
         valueName: varName,
         // Prevent Google from crawling URLs in JSON:
-        //  - https://github.com/vikejs/vike/discussions/2541#discussioncomment-13660198
-        //  - https://github.com/vikejs/vike/discussions/2277
-        //  - https://github.com/vikejs/vike/pull/2542
-        replacer(_key, value) {
-            if (typeof value === 'string' && value.startsWith('/')) {
-                // No need to use a reviver: https://github.com/brillout/json-serializer/blob/70fc8ed3741306391b51655b05df24e6963d1fdb/test/main.spec.ts#L74-L80
-                return { replacement: (value = '!' + value) };
-            }
-        },
+        // - https://github.com/vikejs/vike/pull/2603
+        // - https://github.com/brillout/json-serializer/blob/38edbb9945de4938da1e65d6285ce1dd123a45ef/test/main.spec.ts#L44-L95
+        replacer: !isHtmlJsonScript
+            ? undefined
+            : (_key, value) => {
+                if (typeof value === 'string') {
+                    return { replacement: value.replaceAll('/', '\\/'), resolved: false };
+                }
+            },
     });
 }
 function getPassToClientPageContext(pageContext) {
@@ -158,7 +137,7 @@ function getPassToClientPageContext(pageContext) {
     passToClient = (0, utils_js_1.unique)(passToClient);
     return passToClient;
 }
-function getPageContextClientSerializedAbort(pageContext) {
+function getPageContextClientSerializedAbort(pageContext, isHtmlJsonScript) {
     (0, utils_js_1.assert)(pageContext._urlRedirect || pageContext._urlRewrite || pageContext.abortStatusCode);
     (0, utils_js_1.assert)(pageContext._abortCall);
     (0, utils_js_1.assert)(pageContext._abortCaller);
@@ -191,17 +170,12 @@ function getPageContextClientSerializedAbort(pageContext) {
             onlyOnce: false,
         });
     }
-    return serializeValue(pageContext);
+    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/analyzePage.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzePage = analyzePage;
 const determineClientEntry_js_1 = require("../../../shared/getPageFiles/analyzePageClientSide/determineClientEntry.js");
 const analyzePageClientSide_js_1 = require("../../../shared/getPageFiles/analyzePageClientSide.js");
-const virtualFilePageConfigLazy_js_1 = require("../../shared/virtualFiles/virtualFilePageConfigLazy.js");
+const virtualFileId_js_1 = require("../../shared/virtualFileId.js");
 const analyzeClientSide_js_1 = require("../../../shared/getPageFiles/analyzeClientSide.js");
 const getConfigValueRuntime_js_1 = require("../../../shared/page-configs/getConfigValueRuntime.js");
 async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
@@ -17,14 +17,14 @@ async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
             clientEntries.push((0, determineClientEntry_js_1.getVikeClientEntry)(isClientRouting));
         const clientDependencies = [];
         clientDependencies.push({
-            id: (0, virtualFilePageConfigLazy_js_1.getVirtualFileIdPageConfigLazy)(pageConfig.pageId, true),
+            id: (0, virtualFileId_js_1.generateVirtualFileId)({ type: 'page-entry', pageId: pageConfig.pageId, isForClientSide: true }),
             onlyAssets: isClientRuntimeLoaded ? false : true,
             eagerlyImported: false,
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
         if (!globalContext._isProduction) {
             clientDependencies.push({
-                id: (0, virtualFilePageConfigLazy_js_1.getVirtualFileIdPageConfigLazy)(pageConfig.pageId, false),
+                id: (0, virtualFileId_js_1.generateVirtualFileId)({ type: 'page-entry', pageId: pageConfig.pageId, isForClientSide: false }),
                 onlyAssets: true,
                 eagerlyImported: false,
             });

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/getPageAssets/getManifestEntry.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getManifestEntry = getManifestEntry;
 const utils_js_1 = require("../../utils.js");
-const virtualFilePageConfigLazy_js_1 = require("../../../shared/virtualFiles/virtualFilePageConfigLazy.js");
+const virtualFileId_js_1 = require("../../../shared/virtualFileId.js");
 const prependEntriesDir_js_1 = require("../../../shared/prependEntriesDir.js");
 function getManifestEntry(id, assetsManifest) {
     const debugInfo = getDebugInfo(id, assetsManifest);
@@ -14,7 +14,8 @@ function getManifestEntry(id, assetsManifest) {
         return { manifestEntry, manifestKey };
     }
     // Page code importer
-    if ((0, virtualFilePageConfigLazy_js_1.isVirtualFileIdPageConfigLazy)(id)) {
+    const virtualFile = (0, virtualFileId_js_1.parseVirtualFileId)(id);
+    if (virtualFile && virtualFile.type === 'page-entry') {
         {
             const manifestKey = id;
             const manifestEntry = assetsManifest[manifestKey];
@@ -24,9 +25,9 @@ function getManifestEntry(id, assetsManifest) {
         }
         // Workaround for what seems to be a Vite bug when process.cwd() !== config.root
         //  - Manifest key is:
-        //       ../../virtual:vike:pageConfigLazy:client:/pages/index
+        //       ../../virtual:vike:page-entry:client:/pages/index
         //    But it should be this instead:
-        //      virtual:vike:pageConfigLazy:client:/pages/index
+        //      virtual:vike:page-entry:client:/pages/index
         //  - This workaround was implemented to support Vitest running /tests/*
         //    - I don't know whether end users actually need this workaround? (I'm not sure what the bug actually is.)
         const manifestKeyEnd = id;

package/dist/cjs/node/runtime/renderPage/getPageAssets/{retrieveAssetsDev.js → retrievePageAssetsDev.js}

@@ -1,13 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retrieveAssetsDev = retrieveAssetsDev;
+exports.retrievePageAssetsDev = retrievePageAssetsDev;
+exports.setGetClientEntrySrcDev = setGetClientEntrySrcDev;
 const utils_js_1 = require("../../utils.js");
-async function retrieveAssetsDev(clientDependencies, viteDevServer) {
+const virtualFileId_js_1 = require("../../../shared/virtualFileId.js");
+const globalObject = (0, utils_js_1.getGlobalObject)('getPageAssets/retrievePageAssetsDev.ts', {
+    // We cannot define getClientEntrySrcDev() in this file because it depends on utils/requireResolve.ts which isn't available in production
+    getClientEntrySrcDev: null,
+});
+async function retrievePageAssetsDev(viteDevServer, clientDependencies, clientEntries) {
+    const clientEntriesSrc = clientEntries.map((clientEntry) => globalObject.getClientEntrySrcDev(clientEntry, viteDevServer));
+    const assetUrls = await getAssetUrls(clientDependencies, viteDevServer);
+    return { clientEntriesSrc, assetUrls };
+}
+function setGetClientEntrySrcDev(getClientEntrySrcDev) {
+    globalObject.getClientEntrySrcDev = getClientEntrySrcDev;
+}
+async function getAssetUrls(clientDependencies, viteDevServer) {
     const assetUrls = new Set();
     await Promise.all(clientDependencies.map(async ({ id }) => {
         if (id.startsWith('@@vike'))
             return; // vike doesn't have any CSS
         (0, utils_js_1.assert)(id);
+        const virtualFile = (0, virtualFileId_js_1.parseVirtualFileId)(id);
+        (0, utils_js_1.assert)(!virtualFile || virtualFile.type !== 'global-entry');
         const { moduleGraph } = viteDevServer;
         const [_, graphId] = await moduleGraph.resolveUrl(id);
         (0, utils_js_1.assert)(graphId, { id });
@@ -34,6 +50,9 @@ function collectCss(mod, styleUrls, visitedModules, importer) {
     if (visitedModules.has(mod.url))
         return;
     visitedModules.add(mod.url);
+    const virtualFile = (0, virtualFileId_js_1.parseVirtualFileId)(mod.id || mod.url);
+    if (virtualFile && virtualFile.type === 'global-entry')
+        return; // virtual:vike:global-entry:server dependency list includes all pages
     if (isStyle(mod) && (!importer || !isStyle(importer))) {
         if (mod.url.startsWith('/')) {
             styleUrls.add(mod.url);

package/dist/cjs/node/runtime/renderPage/getPageAssets/{retrieveAssetsProd.js → retrievePageAssetsProd.js}

@@ -1,10 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retrieveAssetsProd = retrieveAssetsProd;
+exports.retrievePageAssetsProd = retrievePageAssetsProd;
+exports.resolveIncludeAssetsImportedByServer = resolveIncludeAssetsImportedByServer;
 const utils_js_1 = require("../../utils.js");
 const getManifestEntry_js_1 = require("./getManifestEntry.js");
 const extractAssetsQuery_js_1 = require("../../../shared/extractAssetsQuery.js");
-function retrieveAssetsProd(clientDependencies, assetsManifest, includeAssetsImportedByServer) {
+function retrievePageAssetsProd(assetsManifest, clientDependencies, clientEntries, config) {
+    const clientEntriesSrc = clientEntries.map((clientEntry) => getClientEntrySrcProd(clientEntry, assetsManifest));
+    const assetUrls = getAssetsUrl(clientDependencies, assetsManifest, config);
+    return { clientEntriesSrc, assetUrls };
+}
+function getClientEntrySrcProd(clientEntry, assetsManifest) {
+    const { manifestEntry } = (0, getManifestEntry_js_1.getManifestEntry)(clientEntry, assetsManifest);
+    (0, utils_js_1.assert)(manifestEntry.isEntry || manifestEntry.isDynamicEntry || clientEntry.endsWith('.css'), { clientEntry });
+    let { file } = manifestEntry;
+    (0, utils_js_1.assert)(!file.startsWith('/'));
+    return '/' + file;
+}
+function getAssetsUrl(clientDependencies, assetsManifest, config) {
+    const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(config);
     let assetUrls = new Set();
     (0, utils_js_1.assert)(assetsManifest);
     const visistedAssets = new Set();
@@ -58,3 +72,6 @@ function collectSingleStyle(assetUrls, assetsManifest) {
         assetUrls.add(`/${style.file}`);
     }
 }
+function resolveIncludeAssetsImportedByServer(config) {
+    return config.includeAssetsImportedByServer ?? true;
+}

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

@@ -1,33 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPageAssets = getPageAssets;
-exports.setResolveClientEntriesDev = setResolveClientEntriesDev;
-exports.resolveIncludeAssetsImportedByServer = resolveIncludeAssetsImportedByServer;
-const utils_js_1 = require("../utils.js");
-const retrieveAssetsDev_js_1 = require("./getPageAssets/retrieveAssetsDev.js");
-const retrieveAssetsProd_js_1 = require("./getPageAssets/retrieveAssetsProd.js");
+const retrievePageAssetsProd_js_1 = require("./getPageAssets/retrievePageAssetsProd.js");
+const retrievePageAssetsDev_js_1 = require("./getPageAssets/retrievePageAssetsDev.js");
 const inferMediaType_js_1 = require("./inferMediaType.js");
-const getManifestEntry_js_1 = require("./getPageAssets/getManifestEntry.js");
 const sortPageAssetsForEarlyHintsHeader_js_1 = require("./getPageAssets/sortPageAssetsForEarlyHintsHeader.js");
-const globalObject = (0, utils_js_1.getGlobalObject)('renderPage/getPageAssets.ts', {
-    resolveClientEntriesDev: null,
-});
+const utils_js_1 = require("../utils.js");
 async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     const globalContext = pageContext._globalContext;
     const { _isProduction: isProduction } = globalContext;
     const isDev = !isProduction;
-    let assetUrls;
-    let clientEntriesSrc;
-    if (isDev) {
-        const { _viteDevServer: viteDevServer } = globalContext;
-        clientEntriesSrc = clientEntries.map((clientEntry) => globalObject.resolveClientEntriesDev(clientEntry, viteDevServer));
-        assetUrls = await (0, retrieveAssetsDev_js_1.retrieveAssetsDev)(clientDependencies, viteDevServer);
-    }
-    else {
-        const { assetsManifest } = globalContext;
-        clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, assetsManifest));
-        assetUrls = (0, retrieveAssetsProd_js_1.retrieveAssetsProd)(clientDependencies, assetsManifest, resolveIncludeAssetsImportedByServer(pageContext._globalContext.config));
-    }
+    const { assetUrls, clientEntriesSrc } = isDev
+        ? !globalContext._viteDevServer
+            ? await (0, utils_js_1.getViteRPC)().retrievePageAssetsDevRPC(clientDependencies, clientEntries)
+            : await (0, retrievePageAssetsDev_js_1.retrievePageAssetsDev)(globalContext._viteDevServer, clientDependencies, clientEntries)
+        : (0, retrievePageAssetsProd_js_1.retrievePageAssetsProd)(globalContext.assetsManifest, clientDependencies, clientEntries, globalContext.config);
     let pageAssets = [];
     (0, utils_js_1.unique)([...clientEntriesSrc, ...assetUrls]).forEach((src) => {
         const { mediaType = null, assetType = null } = (0, inferMediaType_js_1.inferMediaType)(src) || {};
@@ -61,16 +48,3 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
     await (0, sortPageAssetsForEarlyHintsHeader_js_1.sortPageAssetsForEarlyHintsHeader)(pageAssets, isProduction);
     return pageAssets;
 }
-function resolveClientEntriesProd(clientEntry, assetsManifest) {
-    const { manifestEntry } = (0, getManifestEntry_js_1.getManifestEntry)(clientEntry, assetsManifest);
-    (0, utils_js_1.assert)(manifestEntry.isEntry || manifestEntry.isDynamicEntry || clientEntry.endsWith('.css'), { clientEntry });
-    let { file } = manifestEntry;
-    (0, utils_js_1.assert)(!file.startsWith('/'));
-    return '/' + file;
-}
-function setResolveClientEntriesDev(resolveClientEntriesDev) {
-    globalObject.resolveClientEntriesDev = resolveClientEntriesDev;
-}
-function resolveIncludeAssetsImportedByServer(config) {
-    return config.includeAssetsImportedByServer ?? true;
-}

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

@@ -9,7 +9,7 @@ const getPageAssets_js_1 = require("./getPageAssets.js");
 const debugPageFiles_js_1 = require("./debugPageFiles.js");
 const findPageConfig_js_1 = require("../../../shared/page-configs/findPageConfig.js");
 const analyzePage_js_1 = require("./analyzePage.js");
-const loadConfigValues_js_1 = require("../../../shared/page-configs/loadConfigValues.js");
+const loadPageEntry_js_1 = require("../../../shared/page-configs/loadPageEntry.js");
 const execHookServer_js_1 = require("./execHookServer.js");
 const getCacheControl_js_1 = require("./getCacheControl.js");
 async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
@@ -18,6 +18,7 @@ async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
     await (0, execHookServer_js_1.execHookServer)('onCreatePageContext', pageContext);
     return pageContext;
 }
+// TODO/now: define new function resolveAfterLoad() ?
 async function loadPageConfigsLazyServerSide(pageContext) {
     const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
     const globalContext = pageContext._globalContext;
@@ -30,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 = {};
@@ -107,9 +121,9 @@ async function loadPageConfigsLazyServerSide(pageContext) {
 }
 async function loadPageConfigFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {
     const pageFilesServerSide = (0, getPageFiles_js_1.getPageFilesServerSide)(pageFilesAll, pageId);
-    const pageConfigLoaded = !pageConfig ? null : await (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, isDev);
+    const pageConfigLoaded = !pageConfig ? null : await (0, loadPageEntry_js_1.loadPageEntry)(pageConfig, isDev);
     await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
-    const configPublicPageLazy = (0, resolveVikeConfigPublic_js_1.resolveVikeConfigPublicPageLazy)(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
+    const configPublicPageLazy = (0, resolveVikeConfigPublic_js_1.resolveVikeConfigPublicPageLazyLoaded)(pageFilesServerSide, pageConfigLoaded, pageConfigGlobal);
     return {
         configPublicPageLazy,
         pageFilesLoaded: pageFilesServerSide,

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

@@ -50,7 +50,7 @@ async function renderPageAlreadyRouted(pageContext) {
         if (isError) {
             (0, utils_js_1.objectAssign)(pageContext, { [isServerSideError_js_1.isServerSideError]: true });
         }
-        const pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
+        const pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext, false);
         const httpResponse = await (0, createHttpResponse_js_1.createHttpResponsePageContextJson)(pageContextSerialized);
         (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
         return pageContext;
@@ -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,14 +72,13 @@ 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) {
         return { documentHtml, pageContextSerialized: null, pageContext };
     }
     else {
-        const pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
+        const pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext, false);
         return { documentHtml, pageContextSerialized, pageContext };
     }
 }

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)
@@ -424,10 +425,10 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit, true);
             (0, utils_js_1.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSideAndExecHook)(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
-            pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
+            pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext, false);
         }
         else {
-            pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerializedAbort)(pageContextAbort);
+            pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerializedAbort)(pageContextAbort, false);
         }
         const httpResponse = await (0, createHttpResponse_js_1.createHttpResponsePageContextJson)(pageContextSerialized);
         const pageContextReturn = { httpResponse };