vike 0.4.228 → 0.4.229-commit-a19745d

package/dist/esm/node/runtime/html/{serializePageContextClientSide.js → serializeContext.js}

@@ -1,16 +1,16 @@
-export { serializePageContextClientSide };
-export { serializePageContextAbort };
-// For ./serializePageContextClientSide.spec.ts
-export { getPropKeys };
+export { getPageContextClientSerialized };
+export { getPageContextClientSerializedAbort };
+export { getGlobalContextClientSerialized };
 import { stringify, isJsonSerializerError } from '@brillout/json-serializer/stringify';
-import { assert, assertUsage, assertWarning, getPropAccessNotation, hasProp, isObject, unique } from '../utils.js';
+import { assert, assertUsage, assertWarning, getPropAccessNotation, hasProp, unique } from '../utils.js';
 import { isErrorPage } from '../../../shared/error-page.js';
 import { addIs404ToPageProps } from '../../../shared/addIs404ToPageProps.js';
 import pc from '@brillout/picocolors';
 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 = [
+import { getPropKeys, getPropVal, setPropVal } from './propKeys.js';
+const passToClientBuiltInPageContext = [
     'abortReason',
     '_urlRewrite',
     '_urlRedirect',
@@ -24,29 +24,39 @@ const PASS_TO_CLIENT = [
     'routeParams',
     'data' // for data() hook
 ];
-const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', isServerSideError];
-function serializePageContextClientSide(pageContext) {
-    const passToClient = getPassToClient(pageContext);
-    const pageContextClient = applyPassToClient(passToClient, pageContext);
-    if (passToClient.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
+const pageToClientBuiltInPageContextError = ['pageProps', 'is404', isServerSideError];
+function getPageContextClientSerialized(pageContext) {
+    const passToClientPageContext = getPassToClientPageContext(pageContext);
+    const pageContextClient = applyPassToClient(passToClientPageContext, pageContext);
+    if (passToClientPageContext.some((prop) => getPropVal(pageContext._pageContextInit, prop))) {
         pageContextClient[pageContextInitIsPassedToClient] = true;
     }
-    let pageContextSerialized;
+    const pageContextClientSerialized = serializeObject(pageContextClient, 'pageContext', passToClientPageContext);
+    return pageContextClientSerialized;
+}
+function getGlobalContextClientSerialized(pageContext) {
+    const passToClient = pageContext._passToClient;
+    const globalContextClient = applyPassToClient(passToClient, pageContext.globalContext);
+    const globalContextClientSerialized = serializeObject(globalContextClient, 'globalContext', passToClient);
+    return globalContextClientSerialized;
+}
+function serializeObject(obj, objName, passToClient) {
+    let serialized;
     try {
-        pageContextSerialized = serialize(pageContextClient);
+        serialized = serializeValue(obj);
     }
     catch (err) {
         const h = (s) => pc.cyan(s);
         let hasWarned = false;
         const propsNonSerializable = [];
         passToClient.forEach((prop) => {
-            const res = getPropVal(pageContext, prop);
+            const res = getPropVal(obj, prop);
             if (!res)
                 return;
             const { value } = res;
-            const varName = `pageContext${getPropKeys(prop).map(getPropAccessNotation).join('')}`;
+            const varName = `${objName}${getPropKeys(prop).map(getPropAccessNotation).join('')}`;
             try {
-                serialize(value, varName);
+                serializeValue(value, varName);
             }
             catch (err) {
                 propsNonSerializable.push(prop);
@@ -58,7 +68,7 @@ function serializePageContextClientSide(pageContext) {
                     }
                     assertUsage(false, `Cannot serialize config ${h(pathString)} set by useConfig(), see https://vike.dev/useConfig#serialization-error`);
                 }
-                // Non-serializable pageContext set by the user
+                // Non-serializable property 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(JSON.stringify(prop))} from ${h('passToClient')}.`
@@ -79,31 +89,31 @@ function serializePageContextClientSide(pageContext) {
         });
         assert(hasWarned);
         propsNonSerializable.forEach((prop) => {
-            pageContextClient[getPropKeys(prop)[0]] = NOT_SERIALIZABLE;
+            obj[getPropKeys(prop)[0]] = NOT_SERIALIZABLE;
         });
         try {
-            pageContextSerialized = serialize(pageContextClient);
+            serialized = serializeValue(obj);
         }
         catch (err) {
             assert(false);
         }
     }
-    return pageContextSerialized;
+    return serialized;
 }
-function serialize(value, varName) {
+function serializeValue(value, varName) {
     return stringify(value, { forbidReactElements: true, valueName: varName });
 }
-function getPassToClient(pageContext) {
-    let passToClient = [...pageContext._passToClient, ...PASS_TO_CLIENT];
+function getPassToClientPageContext(pageContext) {
+    let passToClient = [...pageContext._passToClient, ...passToClientBuiltInPageContext];
     if (isErrorPage(pageContext.pageId, pageContext._pageConfigs)) {
         assert(hasProp(pageContext, 'is404', 'boolean'));
         addIs404ToPageProps(pageContext);
-        passToClient.push(...PASS_TO_CLIENT_ERROR_PAGE);
+        passToClient.push(...pageToClientBuiltInPageContextError);
     }
     passToClient = unique(passToClient);
     return passToClient;
 }
-function serializePageContextAbort(pageContext) {
+function getPageContextClientSerializedAbort(pageContext) {
     assert(pageContext._urlRedirect || pageContext._urlRewrite || pageContext.abortStatusCode);
     assert(pageContext._abortCall);
     assert(pageContext._abortCaller);
@@ -136,7 +146,7 @@ function serializePageContextAbort(pageContext) {
             onlyOnce: false
         });
     }
-    return serialize(pageContext);
+    return serializeValue(pageContext);
 }
 function applyPassToClient(passToClient, pageContext) {
     const pageContextClient = {};
@@ -151,44 +161,3 @@ function applyPassToClient(passToClient, pageContext) {
     });
     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/index-deprecated.d.ts

@@ -1,16 +1 @@
-export * from './index-common.js';
-export * from '../../types/index-dreprecated.js';
-import { RenderErrorPage as RenderErrorPage_ } from '../../shared/route/abort.js';
-/** @deprecated
- * Replace:
- *   ```
- *   import { RenderErrorPage } from 'vike'
- *   ```
- * With:
- *   ```
- *   import { render } from 'vike/abort'
- *   ```
- *
- * See https://vike.dev/render
- */
-export declare const RenderErrorPage: (...args: Parameters<typeof RenderErrorPage_>) => Error;
+export * from './index.js';

package/dist/esm/node/runtime/index-deprecated.js

@@ -1,41 +1,14 @@
-// TODO/v1-release: replace this with:
-// assertUsage(false, "`import { something } from 'vike'` doesn't exist: instead import from 'vike/server', 'vike/client', 'vike/plugin', ...")
-import { isBrowser } from '../../utils/isBrowser.js';
-import { assertUsage } from '../../utils/assert.js';
-assertUsage(!isBrowser(), "It's forbidden to `import { something } from 'vike'` on the client-side: the module 'vike' is a server-only module.", { showStackTrace: true });
-export * from './index-common.js';
-export * from '../../types/index-dreprecated.js';
+// TODO/soon: point package.json#exports['./server'] to this file.
+// - Write migration guide, see comment below.
+export * from './index.js';
 import { assertWarning } from './utils.js';
 import pc from '@brillout/picocolors';
-import { RenderErrorPage as RenderErrorPage_ } from '../../shared/route/abort.js';
-/** @deprecated
- * Replace:
- *   ```
- *   import { RenderErrorPage } from 'vike'
- *   ```
- * With:
- *   ```
- *   import { render } from 'vike/abort'
- *   ```
- *
- * See https://vike.dev/render
- */
-export const RenderErrorPage = (...args) => {
-    assertWarning(false, [
-        'Replace:',
-        pc.red("  import { RenderErrorPage } from 'vike'"),
-        'With:',
-        pc.green("  import { render } from 'vike/abort'"),
-        'See https://vike.dev/render'
-    ].join('\n'), { onlyOnce: true, showStackTrace: true });
-    return RenderErrorPage_(...args);
-};
 assertWarning(false, [
-    'You have following imports which are outdated:',
-    pc.red("  import { something } from 'vike'"),
+    'You have outdated imports:',
+    pc.bold(pc.red("  import { something } from 'vike/server'")),
     'Replace them with:',
-    pc.green("  import { something } from 'vike/server'"),
-    `Or if ${pc.cyan('something')} is a type:`,
-    pc.green("  import type { something } from 'vike/types'"),
-    "Make sure to import renderPage(), escapeInject, html, dangerouslySkipEscape(), pipeWebStream(), pipeNodeStream(), pipeStream(), stampPipe() from 'vike/server'. (Or inspect the error stack below to find the import causing this warning.)"
+    pc.bold(pc.green("  import { something } from 'vike'"))
+    /* Add migration guide, with migration scritps such as `$ rename vike/server vike`
+    `See ${pc.underline('https://vike.dev/migration/0.4.xxx')}`
+    */
 ].join('\n'), { showStackTrace: true, onlyOnce: true });

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

@@ -1 +1,23 @@
-export * from './index-common.js';
+export { renderPage } from './renderPage.js';
+export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
+export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
+export { PROJECT_VERSION as version } from './utils.js';
+export { getGlobalContext, getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
+export { createDevMiddleware } from '../runtime-dev/index.js';
+export * from '../../types/index-dreprecated.js';
+export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
+export { createPageRenderer } from '../createPageRenderer.js';
+import { RenderErrorPage as RenderErrorPage_ } from '../../shared/route/abort.js';
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import { RenderErrorPage } from 'vike'
+ *   ```
+ * With:
+ *   ```
+ *   import { render } from 'vike/abort'
+ *   ```
+ *
+ * See https://vike.dev/render
+ */
+export declare const RenderErrorPage: (...args: Parameters<typeof RenderErrorPage_>) => Error;

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

@@ -1,4 +1,39 @@
 import { isBrowser } from '../../utils/isBrowser.js';
-import { assertUsage } from '../../utils/assert.js';
-assertUsage(!isBrowser(), "It's forbidden to `import { something } from 'vike/server'` on the client-side: the module 'vike/server' is a server-only module.", { showStackTrace: true });
-export * from './index-common.js';
+import { assert } from '../../utils/assert.js';
+assert(!isBrowser());
+export { renderPage } from './renderPage.js';
+export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
+export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
+export { PROJECT_VERSION as version } from './utils.js';
+export { getGlobalContext, getGlobalContextSync, getGlobalContextAsync } from './globalContext.js';
+export { createDevMiddleware } from '../runtime-dev/index.js';
+// TODO/v1-release: remove
+// Deprecated exports
+export * from '../../types/index-dreprecated.js';
+export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
+export { createPageRenderer } from '../createPageRenderer.js';
+import { assertWarning } from './utils.js';
+import pc from '@brillout/picocolors';
+import { RenderErrorPage as RenderErrorPage_ } from '../../shared/route/abort.js';
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import { RenderErrorPage } from 'vike'
+ *   ```
+ * With:
+ *   ```
+ *   import { render } from 'vike/abort'
+ *   ```
+ *
+ * See https://vike.dev/render
+ */
+export const RenderErrorPage = (...args) => {
+    assertWarning(false, [
+        'Replace:',
+        pc.red("  import { RenderErrorPage } from 'vike'"),
+        'With:',
+        pc.green("  import { render } from 'vike/abort'"),
+        'See https://vike.dev/render'
+    ].join('\n'), { onlyOnce: true, showStackTrace: true });
+    return RenderErrorPage_(...args);
+};

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

@@ -2,5 +2,5 @@ export { analyzePage };
 import type { PageFile } from '../../../shared/getPageFiles/getPageFileObject.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import { type AnalysisResult } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-import type { GlobalContextInternal } from '../globalContext.js';
-declare function analyzePage(pageFilesAll: PageFile[], pageConfig: null | PageConfigRuntime, pageId: string, globalContext: GlobalContextInternal): Promise<AnalysisResult>;
+import type { GlobalContextServerInternal } from '../globalContext.js';
+declare function analyzePage(pageFilesAll: PageFile[], pageConfig: null | PageConfigRuntime, pageId: string, globalContext: GlobalContextServerInternal): Promise<AnalysisResult>;

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

@@ -20,7 +20,7 @@ async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
             eagerlyImported: false
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
-        if (!globalContext.isProduction) {
+        if (!globalContext._isProduction) {
             clientDependencies.push({
                 id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, false),
                 onlyAssets: true,

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

@@ -1,6 +1,7 @@
 export { createHttpResponsePage };
 export { createHttpResponsePageContextJson };
 export { createHttpResponseError };
+export { createHttpResponseErrorWithoutGlobalContext };
 export { createHttpResponseRedirect };
 export { createHttpResponseFavicon404 };
 export { createHttpResponseBaseIsMissing };
@@ -13,6 +14,7 @@ import type { RedirectStatusCode, AbortStatusCode, UrlRedirect } from '../../../
 import { HttpResponseBody } from './getHttpResponseBody.js';
 import { type EarlyHint } from './getEarlyHints.js';
 import type { PageFile } from '../../../shared/getPageFiles.js';
+import type { PageContextBegin } from '../renderPage.js';
 type HttpResponse = {
     statusCode: 200 | 404 | 500 | RedirectStatusCode | AbortStatusCode;
     headers: [string, string][];
@@ -30,11 +32,10 @@ declare function createHttpResponsePage(htmlRender: HtmlRender, renderHook: null
 }): Promise<HttpResponse>;
 declare function createHttpResponseFavicon404(): HttpResponse;
 declare function createHttpResponseBaseIsMissing(urlOriginal: string, baseServer: string): HttpResponse;
-declare function createHttpResponseError(pageContext: null | {
+declare function createHttpResponseError(pageContext: {
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
 }): HttpResponse;
+declare function createHttpResponseErrorWithoutGlobalContext(): HttpResponse;
 declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
-declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, pageContextInit: {
-    urlOriginal: string;
-}): HttpResponse;
+declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, pageContextInit: PageContextBegin): HttpResponse;

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

@@ -1,6 +1,7 @@
 export { createHttpResponsePage };
 export { createHttpResponsePageContextJson };
 export { createHttpResponseError };
+export { createHttpResponseErrorWithoutGlobalContext };
 export { createHttpResponseRedirect };
 export { createHttpResponseFavicon404 };
 export { createHttpResponseBaseIsMissing };
@@ -64,9 +65,6 @@ function createHttpResponseBaseIsMissing(urlOriginal, baseServer) {
 }
 function createHttpResponseError(pageContext) {
     const reason = (() => {
-        if (!pageContext) {
-            return 'no error page (https://vike.dev/error-page) could be rendered';
-        }
         const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
         if (errorPageId) {
             return "the error page (https://vike.dev/error-page) couldn't be rendered (for example if an error occurred while rendering the error page)";
@@ -75,6 +73,13 @@ function createHttpResponseError(pageContext) {
             return 'no error page (https://vike.dev/error-page) is defined, make sure to create one';
         }
     })();
+    return createHttpResponseError_(reason);
+}
+function createHttpResponseErrorWithoutGlobalContext() {
+    const reason = 'no error page (https://vike.dev/error-page) could be rendered';
+    return createHttpResponseError_(reason);
+}
+function createHttpResponseError_(reason) {
     const httpResponse = createHttpResponse(500, 'text/html;charset=utf-8', [], `<p>An error occurred.</p><script>console.log(${JSON.stringify(`This HTTP response was generated by Vike. Vike returned this response because ${reason}.`)})</script>`);
     return httpResponse;
 }

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

@@ -0,0 +1,155 @@
+export { createPageContextServerSide };
+export { createPageContextServerSideWithoutGlobalContext };
+export type { PageContextCreatedServerSide };
+import type { GlobalContextServerInternal, GlobalContextServer } from '../globalContext.js';
+import type { PageContextInit } from '../renderPage.js';
+type PageContextCreatedServerSide = Awaited<ReturnType<typeof createPageContextServerSide>>;
+declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, globalObject_public: GlobalContextServer, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } }: {
+    isPrerendering: false;
+    ssr: {
+        urlHandler: null | ((url: string) => string);
+        isClientSideNavigation: boolean;
+    };
+} | {
+    isPrerendering: true;
+    ssr?: undefined;
+}): Promise<{
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Pick<import("../../../shared/types.js").PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+} & {
+    globalContext: GlobalContextServer;
+    _globalContext: {
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../../types/index.js").ConfigResolved;
+        pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & ({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer;
+        viteConfig: import("vite").ResolvedConfig;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../../types/index.js").ConfigResolved;
+        pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: true;
+        viteConfig: import("vite").ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../../types/index.js").ConfigResolved;
+        pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../../shared/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+        _usesClientRouter: boolean;
+        baseServer: string;
+        baseAssets: string;
+        isClientSide: false;
+        _pageRoutes: import("../../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+        isGlobalContext: true;
+        _virtualFileExports: unknown;
+        _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+        _pageConfigs: import("../../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+        config: import("../../../types/index.js").ConfigResolved;
+        pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    });
+    _baseServer: string;
+    _baseAssets: string;
+    _includeAssetsImportedByServer: boolean;
+    _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
+    _pageConfigs: import("../../../__internal/index.js").PageConfig[];
+    _pageConfigGlobal: import("../../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _allPageIds: string[];
+    _pageRoutes: import("../../../__internal/index.js").PageRoutes;
+    _onBeforeRouteHook: import("../../../shared/hooks/getHook.js").Hook | null;
+    _pageContextInit: PageContextInit;
+    _urlRewrite: null;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    urlParsed: import("../utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+} & {
+    config: import("../../../types/index.js").ConfigResolved;
+    _source: import("../../../shared/page-configs/getPageConfigUserFriendly.js").Source;
+    _sources: import("../../../shared/page-configs/getPageConfigUserFriendly.js").Sources;
+    _from: import("../../../shared/page-configs/getPageConfigUserFriendly.js").From;
+    isPageContext: true;
+}>;
+declare function createPageContextServerSideWithoutGlobalContext(pageContextInit: PageContextInit): {
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Pick<import("../../../shared/types.js").PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+};

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

@@ -0,0 +1,71 @@
+export { createPageContextServerSide };
+export { createPageContextServerSideWithoutGlobalContext };
+import { assert, assertUsage, assertWarning, augmentType, normalizeHeaders, objectAssign } from '../utils.js';
+import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComputed.js';
+import { createPageContextShared } from '../../../shared/createPageContextShared.js';
+async function createPageContextServerSide(pageContextInit, globalContext, globalObject_public, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
+    urlHandler: null,
+    isClientSideNavigation: false
+} }) {
+    assert(pageContextInit.urlOriginal);
+    const pageContextCreated = createPageContext(pageContextInit, isPrerendering);
+    objectAssign(pageContextCreated, {
+        /* Don't spread globalContext for now? Or never spread it as it leads to confusion? The convenience isn't worth the added confusion?
+        // We must use Flatten<T> otherwise TypeScript complains upon assigning types
+        ...(globalContext as Flatten<typeof globalContext>), // least precedence
+        */
+        globalContext: globalObject_public,
+        _globalContext: globalContext,
+        // The following is defined on `pageContext` because we can eventually make these non-global
+        _baseServer: globalContext.baseServer,
+        _baseAssets: globalContext.baseAssets,
+        // TODO/now: add meta.default
+        _includeAssetsImportedByServer: globalContext.config.includeAssetsImportedByServer ?? true,
+        // TODO/soon: use GloablContext instead
+        _pageFilesAll: globalContext._pageFilesAll,
+        _pageConfigs: globalContext._pageConfigs,
+        _pageConfigGlobal: globalContext._pageConfigGlobal,
+        _allPageIds: globalContext._allPageIds,
+        _pageRoutes: globalContext._pageRoutes,
+        _onBeforeRouteHook: globalContext._onBeforeRouteHook,
+        _pageContextInit: pageContextInit,
+        _urlRewrite: null,
+        _urlHandler: urlHandler,
+        isClientSideNavigation
+    });
+    // pageContext.urlParsed
+    const pageContextUrlComputed = getPageContextUrlComputed(pageContextCreated);
+    objectAssign(pageContextCreated, pageContextUrlComputed);
+    // pageContext.headers
+    {
+        let headers;
+        if (pageContextInit.headersOriginal) {
+            headers = normalizeHeaders(pageContextInit.headersOriginal);
+            assertUsage(!('headers' in pageContextInit), "You're defining pageContextInit.headersOriginal as well as pageContextInit.headers but you should only define pageContextInit.headersOriginal instead, see https://vike.dev/headers");
+        }
+        else if (pageContextInit.headers) {
+            headers = pageContextInit.headers;
+            // TODO/next-major-release: remove
+            assertWarning(false, 'Setting pageContextInit.headers is deprecated: set pageContextInit.headersOriginal instead, see https://vike.dev/headers', { onlyOnce: true });
+        }
+        else {
+            headers = null;
+        }
+        objectAssign(pageContextCreated, { headers });
+    }
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal);
+    augmentType(pageContextCreated, pageContextAugmented);
+    return pageContextCreated;
+}
+function createPageContextServerSideWithoutGlobalContext(pageContextInit) {
+    const pageContext = createPageContext(pageContextInit, false);
+    return pageContext;
+}
+function createPageContext(pageContextInit, isPrerendering) {
+    const pageContext = {
+        isClientSide: false,
+        isPrerendering
+    };
+    objectAssign(pageContext, pageContextInit);
+    return pageContext;
+}

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

@@ -1,5 +1,5 @@
 export { executeOnBeforeRenderAndDataHooks };
-import { getHook } from '../../../shared/hooks/getHook.js';
+import { getHookFromPageContext } from '../../../shared/hooks/getHook.js';
 import { preparePageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
 import { assertOnBeforeRenderHookReturn } from '../../../shared/assertOnBeforeRenderHookReturn.js';
 import { executeHook } from '../../../shared/hooks/executeHook.js';
@@ -7,8 +7,8 @@ async function executeOnBeforeRenderAndDataHooks(pageContext) {
     if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
         return;
     }
-    const dataHook = getHook(pageContext, 'data');
-    const onBeforeRenderHook = getHook(pageContext, 'onBeforeRender');
+    const dataHook = getHookFromPageContext(pageContext, 'data');
+    const onBeforeRenderHook = getHookFromPageContext(pageContext, 'onBeforeRender');
     if (!dataHook && !onBeforeRenderHook) {
         return;
     }

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

@@ -5,7 +5,7 @@ import { type Hook } from '../../../shared/hooks/getHook.js';
 import type { PageAsset } from './getPageAssets.js';
 import { type PageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
-import type { PageContextSerialization } from '../html/serializePageContextClientSide.js';
+import type { PageContextSerialization } from '../html/serializeContext.js';
 type GetPageAssets = () => Promise<PageAsset[]>;
 type RenderHook = Hook & {
     hookName: HookName;