vike 0.4.228-commit-d423e4f → 0.4.228-commit-ae4784f

package/dist/cjs/client/client-routing-runtime/globalContextClientSide.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalContext = getGlobalContext;
+const utils_js_1 = require("./utils.js");
+const globalObject = (0, utils_js_1.getGlobalObject)('client-routing-runtime/globalContextClientSide.ts', {});
+function getGlobalContext() {
+    if (!globalObject.globalContext)
+        globalObject.globalContext = {};
+    return globalObject.globalContext;
+}

package/dist/cjs/client/client-routing-runtime/onLoad.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onLoad = onLoad;
+const assertIsBrowser_js_1 = require("../../utils/assertIsBrowser.js");
+const assertRoutingType_js_1 = require("../../utils/assertRoutingType.js");
+function onLoad() {
+    (0, assertIsBrowser_js_1.assertIsBrowser)();
+    // Ensure we don't bloat the Server Routing runtime with Client Routing utils
+    (0, assertRoutingType_js_1.assertClientRouting)();
+}

package/dist/cjs/client/client-routing-runtime/utils.js

@@ -0,0 +1,43 @@
+"use strict";
+// Utils needed by Vike's client runtime (with Client Routing)
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// We call onLoad() here so that it's called even when only a subset of the runtime is loaded. (Making the assert() calls inside onLoad() a lot stronger.)
+const onLoad_js_1 = require("./onLoad.js");
+(0, onLoad_js_1.onLoad)();
+__exportStar(require("../../utils/assert.js"), exports);
+__exportStar(require("../../utils/assertSingleInstance.js"), exports);
+__exportStar(require("../../utils/getGlobalObject.js"), exports);
+__exportStar(require("../../utils/hasProp.js"), exports);
+__exportStar(require("../../utils/isBrowser.js"), exports);
+__exportStar(require("../../utils/isCallable.js"), exports);
+__exportStar(require("../../utils/isObject.js"), exports);
+__exportStar(require("../../utils/isPlainObject.js"), exports);
+__exportStar(require("../../utils/isReact.js"), exports);
+__exportStar(require("../../utils/isSameErrorMessage.js"), exports);
+__exportStar(require("../../utils/objectAssign.js"), exports);
+__exportStar(require("../../utils/parseUrl.js"), exports);
+__exportStar(require("../../utils/PromiseType.js"), exports);
+__exportStar(require("../../utils/redirectHard.js"), exports);
+__exportStar(require("../../utils/sleep.js"), exports);
+__exportStar(require("../../utils/slice.js"), exports);
+__exportStar(require("../../utils/throttle.js"), exports);
+__exportStar(require("../../utils/assertRoutingType.js"), exports);
+__exportStar(require("../../utils/onPageVisibilityChange.js"), exports);
+__exportStar(require("../../utils/augmentType.js"), exports);
+__exportStar(require("../../utils/PROJECT_VERSION.js"), exports);
+__exportStar(require("../../utils/genPromise.js"), exports);
+__exportStar(require("../../utils/catchInfiniteLoop.js"), exports);

package/dist/cjs/client/server-routing-runtime/utils.js

@@ -20,7 +20,6 @@ const onLoad_js_1 = require("./onLoad.js");
 (0, onLoad_js_1.onLoad)();
 __exportStar(require("../../utils/assert.js"), exports);
 __exportStar(require("../../utils/assertSingleInstance.js"), exports);
-__exportStar(require("../../shared/hooks/executeHook.js"), exports);
 __exportStar(require("../../utils/checkType.js"), exports); // Only used by Server Routing (not needed for Client Routing)
 __exportStar(require("../../utils/getGlobalObject.js"), exports);
 __exportStar(require("../../utils/hasProp.js"), exports);

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

@@ -19,6 +19,11 @@ const configDefinitionsBuiltIn = {
     onPageTransitionEnd: {
         env: { client: true }
     },
+    onCreatePageContext: {
+        env: { server: true },
+        global: true,
+        cumulative: true
+    },
     onBeforeRender: {
         env: { server: true }
     },

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles/ignorePatternsBuiltIn.js

@@ -11,6 +11,8 @@ exports.ignorePatternsBuiltIn = [
     // +Page.telefunc.js
     // ```
     '**/*.telefunc.*',
+    // https://github.com/vikejs/vike/issues/1589#issuecomment-2031925598
+    '**/.history/**',
     // https://github.com/vikejs/vike/discussions/2222
     '**/*.generated.*'
 ];

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

@@ -126,7 +126,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     // - Sitll required for esbuild@0.24.0 (November 2024).
                     // - Let's try to remove this workaround again later.
                     if (resolved.errors.length > 0) {
-                        const resolvedWithNode = (0, utils_js_1.requireResolveOptional)(path, args.resolveDir);
+                        const resolvedWithNode = (0, utils_js_1.requireResolveOptional)(path, (0, utils_js_1.toPosixPath)(args.resolveDir));
                         if (debugEsbuildResolve.isActivated)
                             debugEsbuildResolve('resolvedWithNode', resolvedWithNode);
                         if (resolvedWithNode)

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

@@ -44,6 +44,7 @@ const path_1 = __importDefault(require("path"));
 const index_js_1 = require("../../shared/route/index.js");
 const utils_js_1 = require("./utils.js");
 const renderPageAlreadyRouted_js_1 = require("../runtime/renderPage/renderPageAlreadyRouted.js");
+const createPageContextServerSide_js_1 = require("../runtime/renderPage/createPageContextServerSide.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const os_1 = require("os");
 const globalContext_js_1 = require("../runtime/globalContext.js");
@@ -147,10 +148,10 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await callOnBeforePrerenderStartHooks(prerenderContext, globalContext, concurrencyLimit, doNotPrerenderList);
     // Create `pageContext` for each page with a static route
     const urlList = getUrlListFromPagesWithStaticRoute(globalContext, doNotPrerenderList);
-    await createPageContextsForOnPrerenderStartHook(urlList, prerenderContext, globalContext, concurrencyLimit, false);
+    await createPageContexts(urlList, prerenderContext, globalContext, concurrencyLimit, false);
     // Create `pageContext` for 404 page
     const urlList404 = getUrlList404(globalContext);
-    await createPageContextsForOnPrerenderStartHook(urlList404, prerenderContext, globalContext, concurrencyLimit, true);
+    await createPageContexts(urlList404, prerenderContext, globalContext, concurrencyLimit, true);
     // Allow user to duplicate the list of `pageContext` for i18n
     // https://vike.dev/onPrerenderStart
     await callOnPrerenderStartHook(prerenderContext, globalContext, concurrencyLimit);
@@ -295,7 +296,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
             }
             // Add result
             const providedByHook = { hookFilePath, hookName };
-            const pageContextNew = await createPageContext(url, prerenderContext, globalContext, false, undefined, providedByHook);
+            const pageContextNew = await createPageContextPrerendering(url, prerenderContext, globalContext, false, undefined, providedByHook);
             prerenderContext.pageContexts.push(pageContextNew);
             if (pageContext) {
                 (0, utils_js_1.objectAssign)(pageContextNew, { _pageContextAlreadyProvidedByOnPrerenderHook: true });
@@ -341,22 +342,22 @@ function getUrlList404(globalContext) {
     }
     return urlList;
 }
-async function createPageContextsForOnPrerenderStartHook(urlList, prerenderContext, globalContext, concurrencyLimit, is404) {
+async function createPageContexts(urlList, prerenderContext, globalContext, concurrencyLimit, is404) {
     await Promise.all(urlList.map(({ urlOriginal, pageId }) => concurrencyLimit(async () => {
         // Already included in a onBeforePrerenderStart() hook
         if (prerenderContext.pageContexts.find((pageContext) => isSameUrl(pageContext.urlOriginal, urlOriginal))) {
             return;
         }
-        const pageContext = await createPageContext(urlOriginal, prerenderContext, globalContext, is404, pageId, null);
+        const pageContext = await createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, is404, pageId, null);
         prerenderContext.pageContexts.push(pageContext);
     })));
 }
-async function createPageContext(urlOriginal, prerenderContext, globalContext, is404, pageId, providedByHook) {
+async function createPageContextPrerendering(urlOriginal, prerenderContext, globalContext, is404, pageId, providedByHook) {
     const pageContextInit = {
         urlOriginal,
         ...prerenderContext.pageContextInit
     };
-    const pageContext = await (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, globalContext, true);
+    const pageContext = await (0, createPageContextServerSide_js_1.createPageContextServerSide)(pageContextInit, globalContext, { isPrerendering: true });
     (0, utils_js_1.assert)(pageContext.isPrerendering === true);
     (0, utils_js_1.objectAssign)(pageContext, {
         _urlHandler: null,

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHttpResponsePage = createHttpResponsePage;
 exports.createHttpResponsePageContextJson = createHttpResponsePageContextJson;
 exports.createHttpResponseError = createHttpResponseError;
+exports.createHttpResponseErrorWithoutGlobalContext = createHttpResponseErrorWithoutGlobalContext;
 exports.createHttpResponseRedirect = createHttpResponseRedirect;
 exports.createHttpResponseFavicon404 = createHttpResponseFavicon404;
 exports.createHttpResponseBaseIsMissing = createHttpResponseBaseIsMissing;
@@ -66,9 +67,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 = (0, error_page_js_1.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)";
@@ -77,6 +75,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/cjs/node/runtime/renderPage/createPageContextServerSide.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPageContextServerSide = createPageContextServerSide;
+exports.createPageContextServerSideWithoutGlobalContext = createPageContextServerSideWithoutGlobalContext;
+const utils_js_1 = require("../utils.js");
+const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
+const executeHookGeneric_js_1 = require("./executeHookGeneric.js");
+async function createPageContextServerSide(pageContextInit, globalContext, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
+    urlHandler: null,
+    isClientSideNavigation: false
+} }) {
+    (0, utils_js_1.assert)(pageContextInit.urlOriginal);
+    const pageContextCreated = createPageContext(pageContextInit, isPrerendering);
+    (0, utils_js_1.objectAssign)(pageContextCreated, pageContextInit);
+    (0, utils_js_1.objectAssign)(pageContextCreated, {
+        _objectCreatedByVike: true,
+        // 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,
+        _globalContext: globalContext,
+        // TODO/now: add PageContext['globalContext']
+        /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
+        globalContext: globalContext.globalContext_public,
+        _pageContextInit: pageContextInit,
+        _urlRewrite: null,
+        _urlHandler: urlHandler,
+        isClientSideNavigation
+    });
+    // pageContext.urlParsed
+    const pageContextUrlComputed = (0, getPageContextUrlComputed_js_1.getPageContextUrlComputed)(pageContextCreated);
+    (0, utils_js_1.objectAssign)(pageContextCreated, pageContextUrlComputed);
+    // pageContext.headers
+    {
+        let headers;
+        if (pageContextInit.headersOriginal) {
+            headers = (0, utils_js_1.normalizeHeaders)(pageContextInit.headersOriginal);
+            (0, utils_js_1.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
+            (0, utils_js_1.assertWarning)(false, 'Setting pageContextInit.headers is deprecated: set pageContextInit.headersOriginal instead, see https://vike.dev/headers', { onlyOnce: true });
+        }
+        else {
+            headers = null;
+        }
+        (0, utils_js_1.objectAssign)(pageContextCreated, { headers });
+    }
+    await (0, executeHookGeneric_js_1.executeHookGenericGlobalCumulative)('onCreatePageContext', globalContext, pageContextCreated);
+    return pageContextCreated;
+}
+function createPageContextServerSideWithoutGlobalContext(pageContextInit) {
+    const pageContext = createPageContext(pageContextInit, false);
+    return pageContext;
+}
+function createPageContext(pageContextInit, isPrerendering) {
+    const pageContext = {
+        _isPageContextObject: true,
+        isClientSide: false,
+        isPrerendering
+    };
+    (0, utils_js_1.objectAssign)(pageContext, pageContextInit);
+    return pageContext;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeHookGeneric = executeHookGeneric;
+exports.executeHookGenericGlobalCumulative = executeHookGenericGlobalCumulative;
+const executeHook_js_1 = require("../../../shared/hooks/executeHook.js");
+const getHook_js_1 = require("../../../shared/hooks/getHook.js");
+async function executeHookGeneric(hookName, pageContext) {
+    const hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, hookName);
+    if (!hook)
+        return;
+    await (0, executeHook_js_1.executeHook)(() => hook.hookFn(pageContext), hook, pageContext);
+}
+async function executeHookGenericGlobalCumulative(hookName, globalContext, pageContext) {
+    const hooks = (0, getHook_js_1.getHookFromPageConfigGlobalCumulative)(globalContext.pageConfigGlobal, hookName);
+    await Promise.all(hooks.map(async (hook) => {
+        await (0, executeHook_js_1.executeHook)(() => hook.hookFn(pageContext), hook, null);
+    }));
+}

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

@@ -9,8 +9,8 @@ async function executeOnBeforeRenderAndDataHooks(pageContext) {
     if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
         return;
     }
-    const dataHook = (0, getHook_js_1.getHook)(pageContext, 'data');
-    const onBeforeRenderHook = (0, getHook_js_1.getHook)(pageContext, 'onBeforeRender');
+    const dataHook = (0, getHook_js_1.getHookFromPageContext)(pageContext, 'data');
+    const onBeforeRenderHook = (0, getHook_js_1.getHookFromPageContext)(pageContext, 'onBeforeRender');
     if (!dataHook && !onBeforeRenderHook) {
         return;
     }

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

@@ -41,12 +41,12 @@ function getRenderHook(pageContext) {
     {
         let hook;
         let hookName = undefined;
-        hook = (0, getHook_js_1.getHook)(pageContext, 'onRenderHtml');
+        hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, 'onRenderHtml');
         if (hook) {
             hookName = 'onRenderHtml';
         }
         else {
-            hook = (0, getHook_js_1.getHook)(pageContext, 'render');
+            hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, 'render');
             if (hook) {
                 hookName = 'render';
             }

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.retrieveAssetsDev = retrieveAssetsDev;
 const utils_js_1 = require("../../utils.js");
 async function retrieveAssetsDev(clientDependencies, viteDevServer) {
-    const visitedModules = new Set();
     const assetUrls = new Set();
     await Promise.all(clientDependencies.map(async ({ id }) => {
         if (id.startsWith('@@vike'))
@@ -22,7 +21,7 @@ async function retrieveAssetsDev(clientDependencies, viteDevServer) {
             return;
         }
         (0, utils_js_1.assert)(mod, { id });
-        collectCss(mod, assetUrls, visitedModules);
+        collectCss(mod, assetUrls, new Set());
     }));
     return Array.from(assetUrls);
 }
@@ -52,9 +51,6 @@ function collectCss(mod, styleUrls, visitedModules, importer) {
             // Is this useful? Maybe for virtual modules that don't respect the \0 virtual module convention?
             styleUrls.add(`/@id/${mod.url}`);
         }
-        /* Debug:
-        logModule(mod)
-        //*/
     }
     mod.importedModules.forEach((dep) => {
         collectCss(dep, styleUrls, visitedModules, mod);
@@ -69,15 +65,3 @@ function isStyle(mod) {
         // CSS of .vue files
         (mod.id && /\?vue&type=style/.test(mod.id)));
 }
-/*
-function logModule(mod: ModuleNode) {
-  const redacted = 'redacted'
-  console.log({
-    ...mod,
-    ssrModule: redacted,
-    ssrTransformResult: redacted,
-    importedModules: redacted,
-    importers: redacted
-  })
-}
-//*/

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

@@ -5,13 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderPageAlreadyRouted = renderPageAlreadyRouted;
 exports.prerenderPage = prerenderPage;
-exports.getPageContextInitEnhanced = getPageContextInitEnhanced;
-exports.createPageContext = createPageContext;
 const error_page_js_1 = require("../../../shared/error-page.js");
 const renderHtml_js_1 = require("../html/renderHtml.js");
 const utils_js_1 = require("../utils.js");
 const serializePageContextClientSide_js_1 = require("../html/serializePageContextClientSide.js");
-const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
 const createHttpResponse_js_1 = require("./createHttpResponse.js");
 const loadUserFilesServerSide_js_1 = require("./loadUserFilesServerSide.js");
 const executeOnRenderHtmlHook_js_1 = require("./executeOnRenderHtmlHook.js");
@@ -84,65 +81,3 @@ async function prerenderPage(pageContext) {
         return { documentHtml, pageContextSerialized, pageContext };
     }
 }
-async function getPageContextInitEnhanced(pageContextInit, globalContext, isPrerendering, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
-    urlRewrite: null,
-    urlHandler: null,
-    isClientSideNavigation: false
-} } = {}) {
-    (0, utils_js_1.assert)(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = createPageContext(pageContextInit, isPrerendering);
-    (0, utils_js_1.objectAssign)(pageContextInitEnhanced, pageContextInit);
-    (0, utils_js_1.objectAssign)(pageContextInitEnhanced, {
-        _objectCreatedByVike: true,
-        // 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,
-        _globalContext: globalContext,
-        // TODO/now: add PageContext['globalContext']
-        /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
-        globalContext: globalContext.globalContext_public,
-        _pageContextInit: pageContextInit,
-        _urlRewrite: urlRewrite,
-        _urlHandler: urlHandler,
-        isClientSideNavigation
-    });
-    // pageContext.urlParsed
-    const pageContextUrlComputed = (0, getPageContextUrlComputed_js_1.getPageContextUrlComputed)(pageContextInitEnhanced);
-    (0, utils_js_1.objectAssign)(pageContextInitEnhanced, pageContextUrlComputed);
-    // pageContext.headers
-    {
-        let headers;
-        if (pageContextInit.headersOriginal) {
-            headers = (0, utils_js_1.normalizeHeaders)(pageContextInit.headersOriginal);
-            (0, utils_js_1.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: assertUsage() instead of assertWarning()
-            (0, utils_js_1.assertWarning)(false, 'Setting pageContextInit.headers is deprecated: set pageContextInit.headersOriginal instead, see https://vike.dev/headers', { onlyOnce: true });
-        }
-        else {
-            headers = null;
-        }
-        (0, utils_js_1.objectAssign)(pageContextInitEnhanced, { headers });
-    }
-    return pageContextInitEnhanced;
-}
-function createPageContext(pageContextInit, isPrerendering) {
-    const pageContext = {
-        _isPageContextObject: true,
-        isClientSide: false,
-        isPrerendering
-    };
-    (0, utils_js_1.objectAssign)(pageContext, pageContextInit);
-    return pageContext;
-}