vike 0.4.225-commit-37a36a5 → 0.4.225-commit-2b7971f

package/dist/esm/client/server-routing-runtime/getPageContext.d.ts

@@ -1,12 +1,15 @@
 export { getPageContext };
 declare function getPageContext(): Promise<{
-    pageId: string;
-    routeParams: Record<string, string>;
-} & {
+    _isPageContextObject: boolean;
+    isPrerendering: boolean;
+    isClientSide: boolean;
     isHydration: true;
     isBackwardNavigation: null;
     _hasPageContextFromServer: true;
     _hasPageContextFromClient: false;
+} & {
+    pageId: string;
+    routeParams: Record<string, string>;
 } & {
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../__internal/index.js").PageConfig[];

package/dist/esm/client/server-routing-runtime/getPageContext.js

@@ -9,13 +9,16 @@ import * as virtualFileExports from 'virtual:vike:importUserCode:client:server-r
 const { pageFilesAll, pageConfigs, pageConfigGlobal } = getPageConfigsRuntime(virtualFileExports);
 const urlFirst = getCurrentUrl({ withoutHash: true });
 async function getPageContext() {
-    const pageContext = getPageContextSerializedInHtml();
-    objectAssign(pageContext, {
+    const pageContext = {
+        _isPageContextObject: true,
+        isPrerendering: false,
+        isClientSide: true,
         isHydration: true,
         isBackwardNavigation: null,
         _hasPageContextFromServer: true,
         _hasPageContextFromClient: false
-    });
+    };
+    objectAssign(pageContext, getPageContextSerializedInHtml());
     objectAssign(pageContext, await loadPageUserFiles(pageContext.pageId));
     assertPristineUrl();
     return pageContext;

package/dist/esm/client/shared/getPageContextProxyForUser.d.ts

@@ -1,12 +1,2 @@
 export { getPageContextProxyForUser };
-export { PageContextForPassToClientWarning };
-type PageContextForPassToClientWarning = {
-    _hasPageContextFromServer: boolean;
-    _hasPageContextFromClient: boolean;
-};
-/**
- * Throw error when pageContext value isn't:
- * - serializable, or
- * - defined.
- */
-declare function getPageContextProxyForUser<PageContext extends Record<string, unknown> & PageContextForPassToClientWarning>(pageContext: PageContext): PageContext;
+declare function getPageContextProxyForUser<PageContext extends Record<string, unknown>>(pageContext: PageContext): PageContext;

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

@@ -1,77 +1,14 @@
 export { getPageContextProxyForUser };
-import { assert, assertUsage, assertWarning, getGlobalObject, getPropAccessNotation } from '../server-routing-runtime/utils.js';
-import { notSerializable } from '../../shared/notSerializable.js';
-const globalObject = getGlobalObject('shared/getPageContextProxyForUser.ts', {});
-/**
- * Throw error when pageContext value isn't:
- * - serializable, or
- * - defined.
- */
+import { assertUsage, getPropAccessNotation } from '../server-routing-runtime/utils.js';
+import { NOT_SERIALIZABLE } from '../../shared/NOT_SERIALIZABLE.js';
+// Throw error when pageContext value isn't serializable
 function getPageContextProxyForUser(pageContext) {
-    assert([true, false].includes(pageContext._hasPageContextFromServer));
-    assert([true, false].includes(pageContext._hasPageContextFromClient));
     return new Proxy(pageContext, {
         get(_, prop) {
             const val = pageContext[prop];
             const propName = getPropAccessNotation(prop);
-            assertUsage(val !== notSerializable, `Can't access pageContext${propName} on the client side. Because it can't be serialized, see server logs.`);
-            passToClientHint(pageContext, prop, propName);
+            assertUsage(val !== NOT_SERIALIZABLE, `Can't access pageContext${propName} on the client side. Because it can't be serialized, see server logs.`);
             return val;
         }
     });
 }
-function passToClientHint(pageContext, prop, propName) {
-    if (handleVueReactivity(prop))
-        return;
-    // `prop in pageContext` is the trick we use to know the passToClient value on the client-side, as we set a value to all passToClient props, even `undefined` ones:
-    // ```html
-    // <script id="vike_pageContext" type="application/json">{"pageProps":"!undefined"}</script>
-    // ```
-    if (prop in pageContext)
-        return;
-    if (isWhitelisted(prop))
-        return;
-    // The trick described above (`prop in pageContext`) doesn't work if Vike doesn't fetch any pageContext from the server.
-    // - There would still be some value to show a warning, but it isn't worth it because of the confusion that the first recommendation (adding `prop` to `passToClient`) wouldn't actually remove the warning, and only the second recommendation (using `prop in pageContext` instead of `pageContext[prop]`) would work.
-    if (!pageContext._hasPageContextFromServer)
-        return;
-    const errMsg = `pageContext${propName} isn't defined on the client-side, see https://vike.dev/passToClient#error`;
-    if (
-    // TODO/next-major-release always make it an error.
-    // - Remove pageContext._hasPageContextFromClient logic (IIRC this is its only use case).
-    pageContext._hasPageContextFromClient) {
-        assertWarning(false, errMsg, { onlyOnce: false, showStackTrace: true });
-    }
-    else {
-        assertUsage(false, errMsg);
-    }
-}
-const WHITELIST = [
-    'then',
-    // Vue calls toJSON()
-    'toJSON'
-];
-function isWhitelisted(prop) {
-    if (WHITELIST.includes(prop))
-        return true;
-    if (typeof prop === 'symbol')
-        return true; // Vue tries to access some symbols
-    if (typeof prop !== 'string')
-        return true;
-    if (prop.startsWith('__v_'))
-        return true; // Vue internals upon `reactive(pageContext)`
-    return false;
-}
-// Handle Vue's reactivity.
-// When changing a reactive object:
-// - Vue tries to read its old value first. This triggers a `assertIsDefined()` failure if e.g. `pageContextReactive.routeParams = pageContextNew.routeParams` and `pageContextReactive` has no `routeParams`.
-// - Vue seems to read __v_raw before reading the property.
-function handleVueReactivity(prop) {
-    if (globalObject.prev === prop || globalObject.prev === '__v_raw')
-        return true;
-    globalObject.prev = prop;
-    window.setTimeout(() => {
-        globalObject.prev = undefined;
-    }, 0);
-    return false;
-}

package/dist/esm/client/shared/preparePageContextForUserConsumptionClientSide.d.ts

@@ -2,9 +2,9 @@ export { preparePageContextForUserConsumptionClientSide };
 export type { PageContextForUserConsumptionClientSide };
 import type { PageConfigUserFriendlyOld } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-import { PageContextForPassToClientWarning } from './getPageContextProxyForUser.js';
-type PageContextForUserConsumptionClientSide = PageConfigUserFriendlyOld & PageContextForPassToClientWarning & {
+type PageContextForUserConsumptionClientSide = PageConfigUserFriendlyOld & {
     pageId: string;
+    _hasPageContextFromServer: boolean;
     _pageConfigs: PageConfigRuntime[];
 };
 declare function preparePageContextForUserConsumptionClientSide<T extends PageContextForUserConsumptionClientSide>(pageContext: T, isClientRouting: boolean): T & {

package/dist/esm/node/api/prepareViteApiCall.js

@@ -9,6 +9,7 @@ import path from 'path';
 import { assert, assertUsage, getGlobalObject, isObject, toPosixPath } from './utils.js';
 import pc from '@brillout/picocolors';
 import { clearGlobalContext } from '../runtime/globalContext.js';
+import { getEnvVarObject } from '../plugin/shared/getEnvVarObject.js';
 const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
 async function prepareViteApiCall(options, operation) {
     clear();
@@ -22,7 +23,7 @@ function clear() {
     clearGlobalContext();
 }
 async function enhanceViteConfig(viteConfigFromOptions, operation) {
-    const viteInfo = await getInfoFromVite(viteConfigFromOptions, operation);
+    const viteInfo = await getViteInfo(viteConfigFromOptions, operation);
     await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
     const vikeConfig = await getVikeConfig2(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
     const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
@@ -44,21 +45,30 @@ function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
 }
 async function getViteRoot(operation) {
     if (!globalObject.root)
-        await getInfoFromVite(undefined, operation);
+        await getViteInfo(undefined, operation);
     assert(globalObject.root);
     return globalObject.root;
 }
-async function getInfoFromVite(viteConfigFromOptions, operation) {
-    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromOptions, operation);
-    const root = normalizeViteRoot(
-    // `viteConfigFromOptions.root` before `viteConfigFromUserViteFile.root` replicates Vite's precedence:
+async function getViteInfo(viteConfigFromOptions, operation) {
+    let viteConfigEnhanced = viteConfigFromOptions;
+    // Precedence:
+    //  - viteConfigFromUserEnvVar (highest precendence)
+    //  - viteConfigFromOptions
+    //  - viteConfigFromUserViteFile (lowest precendence)
+    const viteConfigFromUserEnvVar = getEnvVarObject('VITE_CONFIG');
+    if (viteConfigFromUserEnvVar)
+        viteConfigEnhanced = mergeConfig(viteConfigEnhanced ?? {}, viteConfigFromUserEnvVar);
+    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigEnhanced, operation);
+    // Correct precedence, replicates Vite:
     // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
-    viteConfigFromOptions?.root ?? viteConfigFromUserViteFile?.root ?? process.cwd());
+    const viteConfigResolved = mergeConfig(viteConfigFromUserViteFile ?? {}, viteConfigEnhanced ?? {});
+    const root = normalizeViteRoot(viteConfigResolved.root ?? process.cwd());
     globalObject.root = root;
+    // - Find options `vike(options)` set in vite.config.js
+    //   - TODO/next-major: remove
+    // - Add Vike's Vite plugin if missing
     let vikeVitePluginOptions;
-    let viteConfigEnhanced = viteConfigFromOptions;
-    // If Vike's Vite plugin is found in both viteConfigFromOptions and viteConfigFromUserViteFile then Vike will later throw an error
-    const found = findVikeVitePlugin(viteConfigFromOptions) || findVikeVitePlugin(viteConfigFromUserViteFile);
+    const found = findVikeVitePlugin(viteConfigResolved);
     if (found) {
         vikeVitePluginOptions = found.vikeVitePluginOptions;
     }
@@ -67,8 +77,8 @@ async function getInfoFromVite(viteConfigFromOptions, operation) {
         // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
         const { plugin: vikePlugin } = await import('../plugin/index.js');
         viteConfigEnhanced = {
-            ...viteConfigFromOptions,
-            plugins: [...(viteConfigFromOptions?.plugins ?? []), vikePlugin()]
+            ...viteConfigEnhanced,
+            plugins: [...(viteConfigEnhanced?.plugins ?? []), vikePlugin()]
         };
         const res = findVikeVitePlugin(viteConfigEnhanced);
         assert(res);

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -1,13 +1,11 @@
 export { commonConfig };
 export { getVikeConfigPublic };
-import { mergeConfig } from 'vite';
 import { assert, assertUsage, assertWarning, findPackageJson, hasProp, isDevCheck, isDocker, isObject } from '../utils.js';
 import { assertRollupInput } from './build/pluginBuildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
 import path from 'path';
 import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
-import { getEnvVarObject } from '../shared/getEnvVarObject.js';
 import { isViteCliCall } from '../shared/isViteCliCall.js';
 import { isVikeCliOrApi } from '../../api/context.js';
 import { getVikeConfig2 } from './importUserCode/v1-design/getVikeConfig.js';
@@ -91,10 +89,6 @@ function commonConfig(vikeVitePluginOptions) {
                         // Set `--host` for Docker/Podman
                         setDefault('host', true, configFromUser, configFromVike);
                     }
-                    // VITE_CONFIG
-                    const configFromEnvVar = getEnvVarObject('VITE_CONFIG');
-                    if (configFromEnvVar)
-                        configFromVike = mergeConfig(configFromVike, configFromEnvVar);
                     return configFromVike;
                 }
             }

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

@@ -305,7 +305,7 @@ function assertGlobalConfigLocation(configName, sources, plusFilesAll, configDef
                 : 'to a value that is global';
             const what = isConditionallyGlobal ? 'global values' : pc.cyan(configName);
             const errEnd = configFilePathsGlobal.length > 0
-                ? `define ${what} at a global config file such as ${joinEnglish(configFilePathsGlobal, 'or')} instead`
+                ? `define ${what} at a global config file such as ${joinEnglish(configFilePathsGlobal.map(pc.bold), 'or')} instead`
                 : `create a global config file (e.g. /pages/+config.js) and define ${what} there instead`;
             // When updating this error message => also update error message at https://vike.dev/warning/global-config
             const errMsg = `${errBeg} ${errMid}: ${errEnd} (https://vike.dev/warning/global-config).`;

package/dist/esm/node/prerender/resolvePrerenderConfig.js

@@ -15,8 +15,8 @@ function resolvePrerenderConfigGlobal(vikeConfig) {
     };
     let defaultLocalValue = false;
     {
-        const valueFirst = prerenderConfigs.filter((p) => !isObject(p) || p.value !== null)[0];
-        if (valueFirst === true || (isObject(valueFirst) && (valueFirst.value ?? defaultValueForObject))) {
+        const valueFirst = prerenderConfigs.filter((p) => !isObject(p) || p.enable !== null)[0];
+        if (valueFirst === true || (isObject(valueFirst) && (valueFirst.enable ?? defaultValueForObject))) {
             defaultLocalValue = true;
         }
     }
@@ -47,7 +47,7 @@ function resolvePrerenderConfigLocal(pageConfig) {
     const values = configValue.value;
     assert(isArray(values));
     const value = values[0];
-    // TODO/now I believe this assert() can fail
+    // If it's set to an object in a local config then Vike considers it a global config and it's skipped from local inheritance, thus we can assume the value to be a boolean.
     assert(typeof value === 'boolean');
     assert(isArray(configValue.definedAtData));
     const prerenderConfigLocal = { value };

package/dist/esm/node/prerender/runPrerender.js

@@ -304,20 +304,16 @@ async function handlePagesWithStaticRoutes(prerenderContext, globalContext, doNo
     })));
 }
 async function createPageContext(urlOriginal, prerenderContext, globalContext) {
-    const pageContext = {
+    const pageContextInit = { urlOriginal };
+    objectAssign(pageContextInit, prerenderContext.pageContextInit);
+    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true, {});
+    assert(pageContext.isPrerendering === true);
+    objectAssign(pageContext, {
         _urlHandler: null,
         _urlRewrite: null,
         _noExtraDir: prerenderContext.noExtraDir,
         _prerenderContext: prerenderContext
-    };
-    const pageContextInit = {
-        urlOriginal
-    };
-    objectAssign(pageContextInit, prerenderContext.pageContextInit);
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext);
-        objectAssign(pageContext, pageContextInitEnhanced);
-    }
+    });
     return pageContext;
 }
 async function callOnPrerenderStartHook(prerenderContext, globalContext) {

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

@@ -1,6 +1,7 @@
 export { serializePageContextClientSide };
 export { serializePageContextAbort };
 export type { PageContextSerialization };
+export { getPropKeys };
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { UrlRedirect } from '../../../shared/route/abort.js';
 type PageContextSerialization = {
@@ -20,3 +21,4 @@ declare function serializePageContextAbort(pageContext: Record<string, unknown>
 } | {
     abortStatusCode: number;
 })): string;
+declare function getPropKeys(prop: string): string[];

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

@@ -1,11 +1,13 @@
 export { serializePageContextClientSide };
 export { serializePageContextAbort };
+// For ./serializePageContextClientSide.spec.ts
+export { getPropKeys };
 import { stringify, isJsonSerializerError } from '@brillout/json-serializer/stringify';
-import { assert, assertUsage, assertWarning, getPropAccessNotation, hasProp, unique } from '../utils.js';
+import { assert, assertUsage, assertWarning, getPropAccessNotation, hasProp, isObject, unique } from '../utils.js';
 import { isErrorPage } from '../../../shared/error-page.js';
 import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
 import pc from '@brillout/picocolors';
-import { notSerializable } from '../../../shared/notSerializable.js';
+import { NOT_SERIALIZABLE } from '../../../shared/NOT_SERIALIZABLE.js';
 import { pageContextInitIsPassedToClient } from '../../../shared/misc/pageContextInitIsPassedToClient.js';
 import { isServerSideError } from '../../../shared/misc/isServerSideError.js';
 const PASS_TO_CLIENT = [
@@ -25,12 +27,8 @@ const PASS_TO_CLIENT = [
 const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isServerSideError];
 function serializePageContextClientSide(pageContext) {
     const passToClient = getPassToClient(pageContext);
-    const pageContextClient = {};
-    passToClient.forEach((prop) => {
-        // We set non-existing props to `undefined`, in order to pass the list of passToClient values to the client-side
-        pageContextClient[prop] = pageContext[prop];
-    });
-    if (Object.keys(pageContext._pageContextInit).some((p) => passToClient.includes(p))) {
+    const pageContextClient = applyPassToClient(passToClient, pageContext);
+    if (passToClient.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient] = true;
     }
     let pageContextSerialized;
@@ -42,14 +40,15 @@ function serializePageContextClientSide(pageContext) {
         let hasWarned = false;
         const propsNonSerializable = [];
         passToClient.forEach((prop) => {
-            const propName1 = getPropAccessNotation(prop);
-            const propName2 = JSON.stringify(prop);
-            const varName = `pageContext${propName1}`;
+            const res = getPropVal(pageContext, prop);
+            if (!res)
+                return;
+            const { value } = res;
+            const varName = `pageContext${getPropKeys(prop).map(getPropAccessNotation).join('')}`;
             try {
-                serialize(pageContext[prop], varName);
+                serialize(value, varName);
             }
             catch (err) {
-                hasWarned = true;
                 propsNonSerializable.push(prop);
                 // useConfig() wrong usage
                 if (prop === '_configFromHook') {
@@ -62,7 +61,7 @@ function serializePageContextClientSide(pageContext) {
                 // Non-serializable pageContext set by the user
                 let msg = [
                     `${h(varName)} can't be serialized and, therefore, can't be passed to the client side.`,
-                    `Make sure ${h(varName)} is serializable, or remove ${h(propName2)} from ${h('passToClient')}.`
+                    `Make sure ${h(varName)} is serializable, or remove ${h(JSON.stringify(prop))} from ${h('passToClient')}.`
                 ].join(' ');
                 if (isJsonSerializerError(err)) {
                     msg = `${msg} Serialization error: ${err.messageCore}.`;
@@ -75,11 +74,12 @@ function serializePageContextClientSide(pageContext) {
                 }
                 // We warn (instead of throwing an error) since Vike's client runtime throws an error (with `assertUsage()`) if the user's client code tries to access the property that cannot be serialized
                 assertWarning(false, msg, { onlyOnce: false });
+                hasWarned = true;
             }
         });
         assert(hasWarned);
         propsNonSerializable.forEach((prop) => {
-            pageContextClient[prop] = notSerializable;
+            pageContextClient[getPropKeys(prop)[0]] = NOT_SERIALIZABLE;
         });
         try {
             pageContextSerialized = serialize(pageContextClient);
@@ -138,3 +138,57 @@ function serializePageContextAbort(pageContext) {
     }
     return serialize(pageContext);
 }
+function applyPassToClient(passToClient, pageContext) {
+    const pageContextClient = {};
+    passToClient.forEach((prop) => {
+        // Get value from pageContext
+        const res = getPropVal(pageContext, prop);
+        if (!res)
+            return;
+        const { value } = res;
+        // Set value to pageContextClient
+        setPropVal(pageContextClient, prop, value);
+    });
+    return pageContextClient;
+}
+// Get a nested property from an object using a dot-separated path such as 'user.id'
+function getPropVal(obj, prop) {
+    const keys = getPropKeys(prop);
+    let value = obj;
+    for (const key of keys) {
+        if (isObject(value) && key in value) {
+            value = value[key];
+        }
+        else {
+            return null; // Property or intermediate property doesn't exist
+        }
+    }
+    return { value };
+}
+// Set a nested property in an object using a dot-separated path such as 'user.id'
+function setPropVal(obj, prop, val) {
+    const keys = getPropKeys(prop);
+    let currentObj = obj;
+    // Creating intermediate objects if necessary
+    for (let i = 0; i <= keys.length - 2; i++) {
+        const key = keys[i];
+        if (!(key in currentObj)) {
+            // Create intermediate object
+            currentObj[key] = {};
+        }
+        if (!isObject(currentObj[key])) {
+            // Skip value upon data structure conflict
+            return;
+        }
+        currentObj = currentObj[key];
+    }
+    // Set the final key to the value
+    const finalKey = keys[keys.length - 1];
+    currentObj[finalKey] = val;
+}
+function getPropKeys(prop) {
+    // Like `prop.split('.')` but with added support for `\` escaping, see serializePageContextClientSide.spec.ts
+    return prop
+        .split(/(?<!\\)\./) // Split on unescaped dots
+        .map((key) => key.replace(/\\\./g, '.')); // Replace escaped dots with literal dots
+}

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

@@ -7,5 +7,8 @@ function preparePageContextForUserConsumptionServerSide(pageContext) {
     assert(isPlainObject(pageContext.routeParams));
     assert('Page' in pageContext);
     assert(typeof pageContext.isClientSideNavigation === 'boolean');
+    assert(pageContext._isPageContextObject);
+    assert(pageContext.isClientSide === false);
+    assert(typeof pageContext.isPrerendering === 'boolean');
     preparePageContextForUserConsumption(pageContext);
 }

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

@@ -2,6 +2,7 @@ export { renderPageAlreadyRouted };
 export { prerenderPage };
 export { prerender404Page };
 export { getPageContextInitEnhanced };
+export { createPageContext };
 export type { PageContextAfterRender };
 export type { PageContextInitEnhanced };
 import { type PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
@@ -32,6 +33,10 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
     documentHtml: string;
     pageContextSerialized: null;
     pageContext: {
+        _isPageContextObject: boolean;
+        isClientSide: boolean;
+        isPrerendering: boolean;
+    } & Record<string, unknown> & {
         urlOriginal: string;
         headersOriginal?: unknown;
         headers?: unknown;
@@ -118,6 +123,10 @@ declare function prerenderPage(pageContext: PageContextInitEnhanced & PageFiles
     documentHtml: string;
     pageContextSerialized: string;
     pageContext: {
+        _isPageContextObject: boolean;
+        isClientSide: boolean;
+        isPrerendering: boolean;
+    } & Record<string, unknown> & {
         urlOriginal: string;
         headersOriginal?: unknown;
         headers?: unknown;
@@ -205,6 +214,10 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
     documentHtml: string;
     pageContextSerialized: null;
     pageContext: {
+        _isPageContextObject: boolean;
+        isClientSide: boolean;
+        isPrerendering: boolean;
+    } & Record<string, unknown> & {
         urlOriginal: string;
         headersOriginal?: unknown;
         headers?: unknown;
@@ -291,6 +304,10 @@ declare function prerender404Page(pageContextInit_: Record<string, unknown> | nu
     documentHtml: string;
     pageContextSerialized: string;
     pageContext: {
+        _isPageContextObject: boolean;
+        isClientSide: boolean;
+        isPrerendering: boolean;
+    } & Record<string, unknown> & {
         urlOriginal: string;
         headersOriginal?: unknown;
         headers?: unknown;
@@ -379,13 +396,17 @@ declare function getPageContextInitEnhanced(pageContextInit: {
     urlOriginal: string;
     headersOriginal?: unknown;
     headers?: unknown;
-}, globalContext: GlobalContextInternal, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } }?: {
+}, globalContext: GlobalContextInternal, isPrerendering: boolean, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } }?: {
     ssr?: {
         urlRewrite: null | string;
         urlHandler: null | ((url: string) => string);
         isClientSideNavigation: boolean;
     };
 }): Promise<{
+    _isPageContextObject: boolean;
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Record<string, unknown> & {
     urlOriginal: string;
     headersOriginal?: unknown;
     headers?: unknown;
@@ -450,3 +471,8 @@ declare function getPageContextInitEnhanced(pageContextInit: {
 } & {
     headers: Record<string, string> | null;
 }>;
+declare function createPageContext(pageContextInit: Record<string, unknown>, isPrerendering: boolean): {
+    _isPageContextObject: boolean;
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Record<string, unknown>;

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

@@ -2,6 +2,7 @@ export { renderPageAlreadyRouted };
 export { prerenderPage };
 export { prerender404Page };
 export { getPageContextInitEnhanced };
+export { createPageContext };
 import { getErrorPageId } from '../../../shared/error-page.js';
 import { getHtmlString } from '../html/renderHtml.js';
 import { assert, assertUsage, assertWarning, hasProp, normalizeHeaders, objectAssign } from '../utils.js';
@@ -84,7 +85,11 @@ async function prerender404Page(pageContextInit_, globalContext) {
     if (!errorPageId) {
         return null;
     }
-    const pageContext = {
+    // A URL is required for `viteDevServer.transformIndexHtml(url,html)`
+    const pageContextInit = { urlOriginal: '/fake-404-url' };
+    objectAssign(pageContextInit, pageContextInit_);
+    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true);
+    objectAssign(pageContext, {
         pageId: errorPageId,
         _httpRequestId: null,
         _urlRewrite: null,
@@ -93,25 +98,17 @@ async function prerender404Page(pageContextInit_, globalContext) {
         // `prerender404Page()` is about generating `dist/client/404.html` for static hosts; there is no Client Routing.
         _usesClientRouter: false,
         _debugRouteMatches: []
-    };
-    const pageContextInit = {
-        urlOriginal: '/fake-404-url' // A URL is needed for `applyViteHtmlTransform`
-    };
-    objectAssign(pageContextInit, pageContextInit_);
-    {
-        const pageContextInitEnhanced = await getPageContextInitEnhanced(pageContextInit, globalContext);
-        objectAssign(pageContext, pageContextInitEnhanced);
-    }
+    });
     objectAssign(pageContext, await loadUserFilesServerSide(pageContext));
     return prerenderPage(pageContext);
 }
-async function getPageContextInitEnhanced(pageContextInit, globalContext, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
+async function getPageContextInitEnhanced(pageContextInit, globalContext, isPrerendering, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
     urlRewrite: null,
     urlHandler: null,
     isClientSideNavigation: false
 } } = {}) {
     assert(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = {};
+    const pageContextInitEnhanced = createPageContext(pageContextInit, isPrerendering);
     objectAssign(pageContextInitEnhanced, pageContextInit);
     objectAssign(pageContextInitEnhanced, {
         _objectCreatedByVike: true,
@@ -158,3 +155,12 @@ async function getPageContextInitEnhanced(pageContextInit, globalContext, { ssr:
     }
     return pageContextInitEnhanced;
 }
+function createPageContext(pageContextInit, isPrerendering) {
+    const pageContext = {
+        _isPageContextObject: true,
+        isClientSide: false,
+        isPrerendering
+    };
+    objectAssign(pageContext, pageContextInit);
+    return pageContext;
+}