npm - vike - Versions diffs - 0.4.232-commit-ec54a7e → 0.4.232 - Mend

vike 0.4.232-commit-ec54a7e → 0.4.232

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

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

@@ -67,7 +67,6 @@ const getOutDirs_js_1 = require("../vite/shared/getOutDirs.js");
 const node_fs_1 = __importDefault(require("node:fs"));
 const getProxyForPublicUsage_js_1 = require("../../shared/getProxyForPublicUsage.js");
 const resolveRedirects_js_1 = require("../runtime/renderPage/resolveRedirects.js");
-const utils_js_2 = require("../runtime/utils.js");
 const docLink = 'https://vike.dev/i18n#pre-rendering';
 async function runPrerender(options = {}, trigger) {
     (0, context_js_1.setWasPrerenderRun)(trigger);
@@ -361,7 +360,7 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
             routeParams: {},
         });
     }
-    (0, utils_js_2.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+    (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
     let usesClientRouter;
     {
         const { pageId } = pageContext;
@@ -764,13 +763,9 @@ function getRedirectHtml(urlTarget) {
   <meta charset="UTF-8">
   <meta http-equiv="refresh" content="0;url=${urlTargetSafe}">
   <title>Redirect ${urlTargetSafe}</title>
-  <style>body{opacity:0}</style>
-  <noscript>
-  <style>body{opacity:1}</style>
-  </noscript>
 </head>
 <body style="min-height: 100vh; margin: 0; font-family: sans-serif; display: flex; justify-content: center; align-items: center; transition: opacity 0.3s;">
-  <script>setTimeout(()=>{document.body.style.opacity=1},2000)</script>
+  <script>document.body.style.opacity=0; setTimeout(()=>{document.body.style.opacity=1},1000);</script>
   <div>
     <h1>Redirect <a href="${urlTargetSafe}"><code style="background-color: #eaeaea; padding: 3px 5px; border-radius: 4px;">${urlTargetSafe}</code></a></h1>
     <p>If you aren't redirected, click the link above.</p>

package/dist/cjs/node/runtime/renderPage/execHookServer.js CHANGED Viewed

@@ -4,5 +4,8 @@ exports.execHookServer = execHookServer;
 const execHook_js_1 = require("../../../shared/hooks/execHook.js");
 const preparePageContextForPublicUsageServer_js_1 = require("./preparePageContextForPublicUsageServer.js");
 async function execHookServer(hookName, pageContext) {
-    return await (0, execHook_js_1.execHook)(hookName, pageContext, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer);
+    return await (0, execHook_js_1.execHook)(hookName, pageContext, (p) => {
+        (0, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer)(p);
+        return p;
+    });
 }

package/dist/cjs/node/runtime/renderPage/loadPageConfigsLazyServerSide.js CHANGED Viewed

@@ -10,14 +10,7 @@ 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 execHookServer_js_1 = require("./execHookServer.js");
 async function loadPageConfigsLazyServerSide(pageContext) {
-    const pageContextAddendum = await loadPageConfigsLazy(pageContext);
-    (0, utils_js_1.objectAssign)(pageContext, pageContextAddendum);
-    await (0, execHookServer_js_1.execHookServer)('onCreatePageContext', pageContext);
-    return pageContext;
-}
-async function loadPageConfigsLazy(pageContext) {
     const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
     const globalContext = pageContext._globalContext;
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
@@ -93,16 +86,18 @@ async function loadPageConfigsLazy(pageContext) {
             return pageAssetsOldFormat;
         },
     });
-    (0, debugPageFiles_js_1.debugPageFiles)({
-        pageContext,
-        isHtmlOnly,
-        isClientRouting,
-        pageFilesLoaded,
-        pageFilesClientSide,
-        pageFilesServerSide,
-        clientEntries,
-        clientDependencies,
-    });
+    {
+        (0, debugPageFiles_js_1.debugPageFiles)({
+            pageContext,
+            isHtmlOnly,
+            isClientRouting,
+            pageFilesLoaded,
+            pageFilesClientSide,
+            pageFilesServerSide,
+            clientEntries,
+            clientDependencies,
+        });
+    }
     return pageContextAddendum;
 }
 async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {

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

@@ -28,7 +28,7 @@ async function renderPageAlreadyRouted(pageContext) {
     (0, utils_js_1.assert)(isError ===
         (pageContext.pageId ===
             (0, error_page_js_1.getErrorPageId)(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs)));
-    (0, utils_js_1.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+    (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
     if (!isError) {
         await (0, executeGuardHook_js_1.executeGuardHook)(pageContext, (pageContext) => (0, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer)(pageContext));
     }

package/dist/cjs/node/runtime/renderPage.js CHANGED Viewed

@@ -143,66 +143,59 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
     else {
         (0, utils_js_1.assert)(errNominalPage);
         (0, utils_js_1.assert)(pageContextNominalPageSuccess === undefined);
-        return await renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite);
-    }
-}
-// When the normal page threw an error
-// - Can be a URL rewrite upon `throw render('/some-url')`
-// - Can be rendering the error page
-// - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
-async function renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite) {
-    (0, utils_js_1.assert)(pageContextNominalPageBegin);
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextNominalPageBegin, 'urlOriginal', 'string'));
-    const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
-    // Handle `throw redirect()` and `throw render()` while rendering nominal page
-    if ((0, abort_js_1.isAbortError)(errNominalPage)) {
-        const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-        if (handled.pageContextReturn) {
-            // - throw redirect()
-            // - throw render(url)
-            // - throw render(abortStatusCode) if .pageContext.json request
-            return handled.pageContextReturn;
-        }
-        else {
-            // - throw render(abortStatusCode) if not .pageContext.json request
+        (0, utils_js_1.assert)(pageContextNominalPageBegin);
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextNominalPageBegin, 'urlOriginal', 'string'));
+        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
+        // Handle `throw redirect()` and `throw render()` while rendering nominal page
+        if ((0, abort_js_1.isAbortError)(errNominalPage)) {
+            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+            if (handled.pageContextReturn) {
+                // - throw redirect()
+                // - throw render(url)
+                // - throw render(abortStatusCode) if .pageContext.json request
+                return handled.pageContextReturn;
+            }
+            else {
+                // - throw render(abortStatusCode) if not .pageContext.json request
+            }
+            Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
         }
-        Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
-    }
-    {
-        const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
-        if (!errorPageId) {
-            (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: null });
-            return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContextErrorPageInit);
+        {
+            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
+            if (!errorPageId) {
+                (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: null });
+                return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContextErrorPageInit);
+            }
+            else {
+                (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: errorPageId });
+            }
         }
-        else {
-            (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: errorPageId });
+        let pageContextErrorPage;
+        try {
+            pageContextErrorPage = await (0, renderPageAlreadyRouted_js_1.renderPageAlreadyRouted)(pageContextErrorPageInit);
         }
-    }
-    let pageContextErrorPage;
-    try {
-        pageContextErrorPage = await (0, renderPageAlreadyRouted_js_1.renderPageAlreadyRouted)(pageContextErrorPageInit);
-    }
-    catch (errErrorPage) {
-        // Handle `throw redirect()` and `throw render()` while rendering error page
-        if ((0, abort_js_1.isAbortError)(errErrorPage)) {
-            const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-            // throw render(abortStatusCode)
-            if (!handled.pageContextReturn) {
-                const pageContextAbort = errErrorPage._pageContextAbort;
-                (0, utils_js_1.assertWarning)(false, `Failed to render error page because ${picocolors_1.default.cyan(pageContextAbort._abortCall)} was called: make sure ${picocolors_1.default.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
-                const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-                return pageContextHttpWithError;
+        catch (errErrorPage) {
+            // Handle `throw redirect()` and `throw render()` while rendering error page
+            if ((0, abort_js_1.isAbortError)(errErrorPage)) {
+                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+                // throw render(abortStatusCode)
+                if (!handled.pageContextReturn) {
+                    const pageContextAbort = errErrorPage._pageContextAbort;
+                    (0, utils_js_1.assertWarning)(false, `Failed to render error page because ${picocolors_1.default.cyan(pageContextAbort._abortCall)} was called: make sure ${picocolors_1.default.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
+                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+                    return pageContextHttpWithError;
+                }
+                // `throw redirect()` / `throw render(url)`
+                return handled.pageContextReturn;
             }
-            // `throw redirect()` / `throw render(url)`
-            return handled.pageContextReturn;
-        }
-        if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
-            (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
+            if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
+                (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
+            }
+            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+            return pageContextWithError;
         }
-        const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-        return pageContextWithError;
+        return pageContextErrorPage;
     }
-    return pageContextErrorPage;
 }
 function logHttpRequest(urlOriginal, httpRequestId) {
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info');
@@ -424,7 +417,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             (0, utils_js_1.objectAssign)(pageContext, { pageId: errorPageId });
             (0, utils_js_1.objectAssign)(pageContext, pageContextAbort);
             (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit, true);
-            (0, utils_js_1.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+            (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(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);
         }

package/dist/cjs/shared/createPageContextShared.js CHANGED Viewed

@@ -2,10 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPageContextShared = createPageContextShared;
 exports.createPageContextObject = createPageContextObject;
+const execHook_js_1 = require("./hooks/execHook.js");
+const preparePageContextForPublicUsage_js_1 = require("./preparePageContextForPublicUsage.js");
 const utils_js_1 = require("./utils.js");
-// TODO/now: make this and parents sync
 async function createPageContextShared(pageContextCreated, pageConfigGlobal, vikeConfigPublicGlobal) {
     (0, utils_js_1.objectAssign)(pageContextCreated, vikeConfigPublicGlobal);
+    await (0, execHook_js_1.execHookGlobal)('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
     return pageContextCreated;
 }
 function createPageContextObject() {

package/dist/cjs/shared/route/index.js CHANGED Viewed

@@ -17,7 +17,6 @@ const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const executeOnBeforeRouteHook_js_1 = require("./executeOnBeforeRouteHook.js");
 const debug_js_1 = require("./debug.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-// TODO/next-major-release: make it sync
 async function route(pageContext, skipOnBeforeRouteHook) {
     (0, debug_js_1.debug)('Pages routes:', pageContext._globalContext._pageRoutes);
     const pageContextFromRoute = {};

package/dist/cjs/utils/PROJECT_VERSION.js CHANGED Viewed

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.232-commit-ec54a7e';
+exports.PROJECT_VERSION = '0.4.232';

package/dist/cjs/utils/styleFileRE.js CHANGED Viewed

@@ -2,5 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.styleFileRE = void 0;
 // Copied from https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/css.ts#L90-L91
-// spellcheck-ignore
 exports.styleFileRE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\?)/;

package/dist/esm/client/runtime-client-routing/prefetch.js CHANGED Viewed

@@ -6,7 +6,7 @@ export { addLinkPrefetchHandlers };
 export { addLinkPrefetchHandlers_watch };
 export { addLinkPrefetchHandlers_unwatch };
 import { assert, assertClientRouting, assertUsage, assertWarning, checkIfClientRouting, getGlobalObject, hasProp, objectAssign, } from './utils.js';
-import { isErrorFetchingStaticAssets, loadPageConfigsLazy } from '../shared/loadPageConfigsLazyClientSide.js';
+import { isErrorFetchingStaticAssets, loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
 import { skipLink } from './skipLink.js';
 import { disableClientRouting } from './renderPageClientSide.js';
 import { isClientSideRoutable } from './isClientSideRoutable.js';
@@ -45,7 +45,7 @@ function getPageContextPrefetched(pageContext) {
 }
 async function prefetchAssets(pageContextLink) {
     try {
-        await loadPageConfigsLazy(pageContextLink.pageId, pageContextLink._pageFilesAll, pageContextLink._globalContext._pageConfigs, pageContextLink._globalContext._pageConfigGlobal);
+        await loadPageConfigsLazyClientSide(pageContextLink.pageId, pageContextLink._pageFilesAll, pageContextLink._globalContext._pageConfigs, pageContextLink._globalContext._pageConfigGlobal);
     }
     catch (err) {
         if (isErrorFetchingStaticAssets(err)) {

package/dist/esm/client/runtime-client-routing/renderPageClientSide.js CHANGED Viewed

@@ -9,7 +9,7 @@ import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { addLinkPrefetchHandlers, addLinkPrefetchHandlers_unwatch, addLinkPrefetchHandlers_watch, getPageContextPrefetched, populatePageContextPrefetchCache, } from './prefetch.js';
 import { assertInfo, assertWarning, isReact } from './utils.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
-import { isErrorFetchingStaticAssets, loadPageConfigsLazy, } from '../shared/loadPageConfigsLazyClientSide.js';
+import { isErrorFetchingStaticAssets, loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
 import { pushHistoryState } from './history.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled, } from '../../shared/route/abort.js';
 import { route } from '../../shared/route/index.js';
@@ -20,7 +20,7 @@ import { getErrorPageId } from '../../shared/error-page.js';
 import { setPageContextCurrent } from './getPageContextCurrent.js';
 import { getRouteStringParameterList } from '../../shared/route/resolveRouteString.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
-import { execHooksErrorHandling, execHookErrorHandling, execHook, } from '../../shared/hooks/execHook.js';
+import { execHooksErrorHandling, execHookErrorHandling, } from '../../shared/hooks/execHook.js';
 import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
 import { getHookFromPageContextNew } from '../../shared/hooks/getHook.js';
 import { preparePageContextForPublicUsageClientMinimal } from '../shared/preparePageContextForPublicUsageClientShared.js';
@@ -60,7 +60,7 @@ async function renderPageClientSide(renderArgs) {
     return;
     async function renderPageNominal() {
         const onError = async (err) => {
-            await renderPageOnError({ err });
+            await renderErrorPage({ err });
         };
         const pageContext = await getPageContextBegin(false, pageContextBeginArgs);
         if (isRenderOutdated())
@@ -134,9 +134,8 @@ async function renderPageClientSide(renderArgs) {
             assert(!('urlOriginal' in pageContextFromRoute));
             objectAssign(pageContext, pageContextFromRoute);
         }
-        let pageContextAugmented;
         try {
-            pageContextAugmented = await loadPageConfigsLazyClientSide(pageContext);
+            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal));
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -148,7 +147,6 @@ async function renderPageClientSide(renderArgs) {
                 return;
             }
         }
-        augmentType(pageContext, pageContextAugmented);
         if (isRenderOutdated())
             return;
         setPageContextCurrent(pageContext);
@@ -220,11 +218,7 @@ async function renderPageClientSide(renderArgs) {
             await renderPageView(pageContext);
         }
     }
-    // When the normal page threw an error
-    // - Can be a URL rewrite upon `throw render('/some-url')`
-    // - Can be rendering the error page
-    // - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
-    async function renderPageOnError(args) {
+    async function renderErrorPage(args) {
         const onError = (err) => {
             if (!isSameErrorMessage(err, args.err)) {
                 /* When we can't render the error page, we prefer showing a blank page over letting the server-side try because otherwise:
@@ -253,6 +247,8 @@ async function renderPageClientSide(renderArgs) {
         if (isRenderOutdated())
             return;
         objectAssign(pageContext, { routeParams: {} });
+        if (args.is404)
+            objectAssign(pageContext, { is404: true });
         if (args.pageContextError)
             objectAssign(pageContext, args.pageContextError);
         if ('err' in args) {
@@ -317,9 +313,8 @@ async function renderPageClientSide(renderArgs) {
             redirectHard(urlOriginal);
             return;
         }
-        let pageContextAugmented;
         try {
-            pageContextAugmented = await loadPageConfigsLazyClientSide(pageContext);
+            objectAssign(pageContext, await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal));
         }
         catch (err) {
             if (handleErrorFetchingStaticAssets(err, pageContext, isFirstRender)) {
@@ -331,7 +326,6 @@ async function renderPageClientSide(renderArgs) {
                 return;
             }
         }
-        augmentType(pageContext, pageContextAugmented);
         if (isRenderOutdated())
             return;
         setPageContextCurrent(pageContext);
@@ -367,7 +361,7 @@ async function renderPageClientSide(renderArgs) {
     async function renderPageView(pageContext, isErrorPage) {
         const onError = async (err) => {
             if (!isErrorPage) {
-                await renderPageOnError({ err });
+                await renderErrorPage({ err });
             }
             else {
                 if (!isSameErrorMessage(err, isErrorPage.err)) {
@@ -602,9 +596,3 @@ function areKeysEqual(key1, key2) {
 function getPageContextClient() {
     return globalObject.renderedPageContext ?? null;
 }
-async function loadPageConfigsLazyClientSide(pageContext) {
-    const pageContextAddendum = await loadPageConfigsLazy(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
-    objectAssign(pageContext, pageContextAddendum);
-    await execHook('onCreatePageContext', pageContext, preparePageContextForPublicUsageClient);
-    return pageContext;
-}

package/dist/esm/client/runtime-server-routing/createPageContextClientSide.js CHANGED Viewed

@@ -1,12 +1,10 @@
 export { createPageContextClientSide };
 import { assertUsage, augmentType, objectAssign } from './utils.js';
 import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
-import { loadPageConfigsLazy, } from '../shared/loadPageConfigsLazyClientSide.js';
+import { loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
 import { createPageContextObject, createPageContextShared } from '../../shared/createPageContextShared.js';
 import { getGlobalContextClientInternal } from './globalContext.js';
-import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
-import { execHook } from '../../shared/hooks/execHook.js';
 const urlFirst = getCurrentUrl({ withoutHash: true });
 async function createPageContextClientSide() {
     const globalContext = await getGlobalContextClientInternal();
@@ -22,9 +20,10 @@ async function createPageContextClientSide() {
     });
     objectAssign(pageContextCreated, getPageContextSerializedInHtml());
     // Sets pageContext.config to global configs
-    augmentType(pageContextCreated, await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._vikeConfigPublicGlobal));
+    const pageContextAugmented = await createPageContextShared(pageContextCreated, globalContext._pageConfigGlobal, globalContext._vikeConfigPublicGlobal);
+    augmentType(pageContextCreated, pageContextAugmented);
     // Sets pageContext.config to local configs (overrides the pageContext.config set above)
-    augmentType(pageContextCreated, await loadPageConfigsLazyClientSide(pageContextCreated));
+    objectAssign(pageContextCreated, await loadPageConfigsLazyClientSide(pageContextCreated.pageId, globalContext._pageFilesAll, globalContext._pageConfigs, globalContext._pageConfigGlobal));
     assertPristineUrl();
     return pageContextCreated;
 }
@@ -32,9 +31,3 @@ function assertPristineUrl() {
     const urlCurrent = getCurrentUrl({ withoutHash: true });
     assertUsage(urlFirst === urlCurrent, `The URL was manipulated before the hydration finished ('${urlFirst}' to '${urlCurrent}'). Ensure the hydration has finished before manipulating the URL. Consider using the onHydrationEnd() hook.`);
 }
-async function loadPageConfigsLazyClientSide(pageContext) {
-    const pageContextAddendum = await loadPageConfigsLazy(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
-    objectAssign(pageContext, pageContextAddendum);
-    await execHook('onCreatePageContext', pageContext, preparePageContextForPublicUsageClient);
-    return pageContext;
-}

package/dist/esm/client/shared/loadPageConfigsLazyClientSide.d.ts CHANGED Viewed

@@ -1,19 +1,9 @@
-export { loadPageConfigsLazy };
-export type { PageContext_loadPageConfigsLazyClientSide };
+export { loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
 import { type PageFile, type VikeConfigPublicPageLazy } from '../../shared/getPageFiles.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
-import { PageContextPrepareMinimum } from '../../shared/preparePageContextForPublicUsage.js';
-type PageContext_loadPageConfigsLazyClientSide = {
-    pageId: string;
-    _pageFilesAll: PageFile[];
-    _globalContext: {
-        _pageConfigs: PageConfigRuntime[];
-        _pageConfigGlobal: PageConfigGlobalRuntime;
-    };
-} & PageContextPrepareMinimum;
 type PageContextUserFilesLoaded = VikeConfigPublicPageLazy & {
     _pageFilesLoaded: PageFile[];
 };
-declare function loadPageConfigsLazy(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<PageContextUserFilesLoaded>;
+declare function loadPageConfigsLazyClientSide(pageId: string, pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): Promise<PageContextUserFilesLoaded>;
 declare function isErrorFetchingStaticAssets(err: unknown): boolean;

package/dist/esm/client/shared/loadPageConfigsLazyClientSide.js CHANGED Viewed

@@ -1,4 +1,4 @@
-export { loadPageConfigsLazy };
+export { loadPageConfigsLazyClientSide };
 export { isErrorFetchingStaticAssets };
 import { getPageFilesClientSide } from '../../shared/getPageFiles.js';
 import { resolveVikeConfigPublicPageLazy } from '../../shared/page-configs/resolveVikeConfigPublic.js';
@@ -6,7 +6,7 @@ import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { objectAssign } from '../runtime-server-routing/utils.js';
 const stamp = '__whileFetchingAssets';
-async function loadPageConfigsLazy(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
+async function loadPageConfigsLazyClientSide(pageId, pageFilesAll, pageConfigs, pageConfigGlobal) {
     const pageFilesClientSide = getPageFilesClientSide(pageFilesAll, pageId);
     const pageConfig = findPageConfig(pageConfigs, pageId);
     let pageConfigLoaded;

package/dist/esm/node/prerender/runPrerender.d.ts CHANGED Viewed

@@ -171,7 +171,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
     _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
 } & {
-    urlParsed: import("../runtime/utils.js").UrlPublic;
+    urlParsed: import("../shared/utils.js").UrlPublic;
     urlPathname: string;
     url: string;
 } & {
@@ -292,7 +292,7 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
     _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
 } & {
-    urlParsed: import("../runtime/utils.js").UrlPublic;
+    urlParsed: import("../shared/utils.js").UrlPublic;
     urlPathname: string;
     url: string;
 } & {
@@ -310,259 +310,13 @@ declare function createPageContextPrerendering(urlOriginal: string, prerenderCon
     pageId: string;
     _debugRouteMatches: never[];
     routeParams: {};
-})) & (((({
-    _isOriginalObject: true;
-    isPageContext: true;
-} & {
-    isClientSide: false;
-    isPrerendering: boolean;
-} & Pick<import("../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
-    url?: string;
-    headers?: Record<string, string>;
-} & {
-    _globalContext: {
-        isGlobalContext: true;
-        _isOriginalObject: true;
-        _virtualFileExports: unknown;
-        _pageFilesAll: PageFile[];
-        _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
-        _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
-        _allPageIds: string[];
-        _vikeConfigPublicGlobal: {
-            config: import("../../types/index.js").ConfigResolved;
-            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
-            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
-            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
-        };
-        config: import("../../types/index.js").ConfigResolved;
-        pages: {
-            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
-        };
-    } & ({
-        _isProduction: false;
-        _isPrerendering: false;
-        assetsManifest: null;
-        _viteDevServer: import("vite").ViteDevServer;
-        viteConfig: ResolvedConfig;
-        viteConfigRuntime: {
-            root: string;
-            build: {
-                outDir: string;
-            };
-            _baseViteOriginal: string;
-            vitePluginServerEntry: {
-                inject: boolean | undefined;
-            };
-        };
-        baseServer: string;
-        baseAssets: string;
-        isClientSide: false;
-        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    } | {
-        _isPrerendering: true;
-        viteConfig: ResolvedConfig;
-        _isProduction: true;
-        assetsManifest: import("../../types/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("../../shared/route/loadPageRoutes.js").PageRoutes;
-        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    } | {
-        _isPrerendering: false;
-        viteConfig: null;
-        _isProduction: true;
-        assetsManifest: import("../../types/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("../../shared/route/loadPageRoutes.js").PageRoutes;
-        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    });
-    _pageFilesAll: PageFile[];
-    _baseServer: string;
-    _baseAssets: string;
-    _pageContextInit: import("../runtime/renderPage.js").PageContextInit;
-    _urlRewrite: null;
-    _urlHandler: ((url: string) => string) | null;
-    isClientSideNavigation: boolean;
-} & {
-    config: import("../../types/index.js").ConfigResolved;
-    _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
-    _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
-    _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
-} & {
-    urlParsed: import("../runtime/utils.js").UrlPublic;
-    urlPathname: string;
-    url: string;
-} & {
-    headers: Record<string, string> | null;
-} & {
-    _urlHandler: null;
-    _httpRequestId: null;
-    _urlRewrite: null;
-    _noExtraDir: boolean | null;
-    _prerenderContext: PrerenderContext;
-    _providedByHook: ProvidedByHook;
-    _urlOriginalModifiedByHook: ProvidedByHookTransformer;
-    is404: boolean;
-} & import("../../shared/route/index.js").PageContextFromRoute & Record<"pageId", string>) | ({
-    _isOriginalObject: true;
-    isPageContext: true;
-} & {
-    isClientSide: false;
-    isPrerendering: boolean;
-} & Pick<import("../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
-    url?: string;
-    headers?: Record<string, string>;
-} & {
-    _globalContext: {
-        isGlobalContext: true;
-        _isOriginalObject: true;
-        _virtualFileExports: unknown;
-        _pageFilesAll: PageFile[];
-        _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
-        _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
-        _allPageIds: string[];
-        _vikeConfigPublicGlobal: {
-            config: import("../../types/index.js").ConfigResolved;
-            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
-            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
-            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
-        };
-        config: import("../../types/index.js").ConfigResolved;
-        pages: {
-            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
-        };
-    } & ({
-        _isProduction: false;
-        _isPrerendering: false;
-        assetsManifest: null;
-        _viteDevServer: import("vite").ViteDevServer;
-        viteConfig: ResolvedConfig;
-        viteConfigRuntime: {
-            root: string;
-            build: {
-                outDir: string;
-            };
-            _baseViteOriginal: string;
-            vitePluginServerEntry: {
-                inject: boolean | undefined;
-            };
-        };
-        baseServer: string;
-        baseAssets: string;
-        isClientSide: false;
-        _pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
-        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    } | {
-        _isPrerendering: true;
-        viteConfig: ResolvedConfig;
-        _isProduction: true;
-        assetsManifest: import("../../types/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("../../shared/route/loadPageRoutes.js").PageRoutes;
-        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    } | {
-        _isPrerendering: false;
-        viteConfig: null;
-        _isProduction: true;
-        assetsManifest: import("../../types/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("../../shared/route/loadPageRoutes.js").PageRoutes;
-        _onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
-    });
-    _pageFilesAll: PageFile[];
-    _baseServer: string;
-    _baseAssets: string;
-    _pageContextInit: import("../runtime/renderPage.js").PageContextInit;
-    _urlRewrite: null;
-    _urlHandler: ((url: string) => string) | null;
-    isClientSideNavigation: boolean;
-} & {
-    config: import("../../types/index.js").ConfigResolved;
-    _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
-    _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
-    _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
-} & {
-    urlParsed: import("../runtime/utils.js").UrlPublic;
-    urlPathname: string;
-    url: string;
-} & {
-    headers: Record<string, string> | null;
-} & {
-    _urlHandler: null;
-    _httpRequestId: null;
-    _urlRewrite: null;
-    _noExtraDir: boolean | null;
-    _prerenderContext: PrerenderContext;
-    _providedByHook: ProvidedByHook;
-    _urlOriginalModifiedByHook: ProvidedByHookTransformer;
-    is404: boolean;
-} & {
-    pageId: string;
-    _debugRouteMatches: never[];
-    routeParams: {};
-})) & import("../../shared/getPageFiles.js").VikeConfigPublicPageLazy) & {
+})) & import("../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];
     _pageFilePathsLoaded: string[];
 } & {
     __getPageAssets: () => Promise<import("../runtime/renderPage/getPageAssets.js").PageAsset[]>;
-})) & {
+}) & {
     _usesClientRouter: boolean;
 }>;

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

@@ -29,7 +29,6 @@ import { getOutDirs } from '../vite/shared/getOutDirs.js';
 import fs from 'node:fs';
 import { getProxyForPublicUsage } from '../../shared/getProxyForPublicUsage.js';
 import { getStaticRedirectsForPrerender } from '../runtime/renderPage/resolveRedirects.js';
-import { augmentType } from '../runtime/utils.js';
 const docLink = 'https://vike.dev/i18n#pre-rendering';
 async function runPrerender(options = {}, trigger) {
     setWasPrerenderRun(trigger);
@@ -323,7 +322,7 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
             routeParams: {},
         });
     }
-    augmentType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+    objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
     let usesClientRouter;
     {
         const { pageId } = pageContext;
@@ -726,13 +725,9 @@ function getRedirectHtml(urlTarget) {
   <meta charset="UTF-8">
   <meta http-equiv="refresh" content="0;url=${urlTargetSafe}">
   <title>Redirect ${urlTargetSafe}</title>
-  <style>body{opacity:0}</style>
-  <noscript>
-  <style>body{opacity:1}</style>
-  </noscript>
 </head>
 <body style="min-height: 100vh; margin: 0; font-family: sans-serif; display: flex; justify-content: center; align-items: center; transition: opacity 0.3s;">
-  <script>setTimeout(()=>{document.body.style.opacity=1},2000)</script>
+  <script>document.body.style.opacity=0; setTimeout(()=>{document.body.style.opacity=1},1000);</script>
   <div>
     <h1>Redirect <a href="${urlTargetSafe}"><code style="background-color: #eaeaea; padding: 3px 5px; border-radius: 4px;">${urlTargetSafe}</code></a></h1>
     <p>If you aren't redirected, click the link above.</p>

package/dist/esm/node/runtime/renderPage/execHookServer.js CHANGED Viewed

@@ -2,5 +2,8 @@ export { execHookServer };
 import { execHook } from '../../../shared/hooks/execHook.js';
 import { preparePageContextForPublicUsageServer, } from './preparePageContextForPublicUsageServer.js';
 async function execHookServer(hookName, pageContext) {
-    return await execHook(hookName, pageContext, preparePageContextForPublicUsageServer);
+    return await execHook(hookName, pageContext, (p) => {
+        preparePageContextForPublicUsageServer(p);
+        return p;
+    });
 }

package/dist/esm/node/runtime/renderPage/loadPageConfigsLazyServerSide.d.ts CHANGED Viewed

@@ -1,27 +1,18 @@
 export { loadPageConfigsLazyServerSide };
+export type { PageFiles };
 export type { PageContext_loadPageConfigsLazyServerSide };
-export type { PageConfigsLazy };
 import { PromiseType } from '../utils.js';
 import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
 import { type PageContextDebugRouteMatches } from './debugPageFiles.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
-import { type PageContextExecuteHookServer } from './execHookServer.js';
-type PageContextExecute = Omit<PageContextExecuteHookServer, keyof Awaited<ReturnType<typeof loadPageConfigsLazy>>>;
 type PageContext_loadPageConfigsLazyServerSide = PageContextGetPageAssets & PageContextDebugRouteMatches & {
-    pageId: string;
     urlOriginal: string;
     _globalContext: GlobalContextServerInternal;
 };
-type PageConfigsLazy = PromiseType<ReturnType<typeof loadPageConfigsLazy>>;
-declare function loadPageConfigsLazyServerSide<PageContext extends PageContext_loadPageConfigsLazyServerSide & PageContextExecute>(pageContext: PageContext): Promise<PageContext & import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
-    Page: unknown;
-    _isHtmlOnly: boolean;
-    _passToClient: string[];
-    _pageFilePathsLoaded: string[];
-} & {
-    __getPageAssets: () => Promise<PageAsset[]>;
-}>;
-declare function loadPageConfigsLazy(pageContext: PageContext_loadPageConfigsLazyServerSide): Promise<import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
+type PageFiles = PromiseType<ReturnType<typeof loadPageConfigsLazyServerSide>>;
+declare function loadPageConfigsLazyServerSide(pageContext: {
+    pageId: string;
+} & PageContext_loadPageConfigsLazyServerSide): Promise<import("../../../shared/getPageFiles.js").VikeConfigPublicPageLazy & {
     Page: unknown;
     _isHtmlOnly: boolean;
     _passToClient: string[];

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

@@ -8,14 +8,7 @@ import { debugPageFiles } from './debugPageFiles.js';
 import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
 import { analyzePage } from './analyzePage.js';
 import { loadConfigValues } from '../../../shared/page-configs/loadConfigValues.js';
-import { execHookServer } from './execHookServer.js';
 async function loadPageConfigsLazyServerSide(pageContext) {
-    const pageContextAddendum = await loadPageConfigsLazy(pageContext);
-    objectAssign(pageContext, pageContextAddendum);
-    await execHookServer('onCreatePageContext', pageContext);
-    return pageContext;
-}
-async function loadPageConfigsLazy(pageContext) {
     const pageConfig = findPageConfig(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
     const globalContext = pageContext._globalContext;
     const [{ pageFilesLoaded, pageContextExports }] = await Promise.all([
@@ -91,16 +84,18 @@ async function loadPageConfigsLazy(pageContext) {
             return pageAssetsOldFormat;
         },
     });
-    debugPageFiles({
-        pageContext,
-        isHtmlOnly,
-        isClientRouting,
-        pageFilesLoaded,
-        pageFilesClientSide,
-        pageFilesServerSide,
-        clientEntries,
-        clientDependencies,
-    });
+    {
+        debugPageFiles({
+            pageContext,
+            isHtmlOnly,
+            isClientRouting,
+            pageFilesLoaded,
+            pageFilesClientSide,
+            pageFilesServerSide,
+            clientEntries,
+            clientDependencies,
+        });
+    }
     return pageContextAddendum;
 }
 async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {

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

@@ -3,7 +3,7 @@ export { prerenderPage };
 export type { PageContextAfterRender };
 import { type PageContextUrlInternal } from '../../../shared/getPageContextUrlComputed.js';
 import { HttpResponse } from './createHttpResponse.js';
-import { PageContext_loadPageConfigsLazyServerSide, type PageConfigsLazy } from './loadPageConfigsLazyServerSide.js';
+import { PageContext_loadPageConfigsLazyServerSide, type PageFiles } from './loadPageConfigsLazyServerSide.js';
 import type { PageContextCreated } from './createPageContextServerSide.js';
 type PageContextAfterRender = {
     httpResponse: HttpResponse;
@@ -17,7 +17,7 @@ declare function renderPageAlreadyRouted<PageContext extends {
     errorWhileRendering: null | Error;
     _httpRequestId: number;
 } & PageContextCreated & PageContextUrlInternal & PageContext_loadPageConfigsLazyServerSide>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;
-declare function prerenderPage(pageContext: PageContextCreated & PageConfigsLazy & {
+declare function prerenderPage(pageContext: PageContextCreated & PageFiles & {
     routeParams: Record<string, string>;
     pageId: string;
     _urlRewrite: null;

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

@@ -2,7 +2,7 @@ export { renderPageAlreadyRouted };
 export { prerenderPage };
 import { getErrorPageId } from '../../../shared/error-page.js';
 import { getHtmlString } from '../html/renderHtml.js';
-import { assert, assertUsage, augmentType, hasProp, objectAssign } from '../utils.js';
+import { assert, assertUsage, hasProp, objectAssign } from '../utils.js';
 import { getPageContextClientSerialized } from '../html/serializeContext.js';
 import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
 import { loadPageConfigsLazyServerSide, } from './loadPageConfigsLazyServerSide.js';
@@ -23,7 +23,7 @@ async function renderPageAlreadyRouted(pageContext) {
     assert(isError ===
         (pageContext.pageId ===
             getErrorPageId(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs)));
-    augmentType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+    objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
     if (!isError) {
         await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext));
     }

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

@@ -3,7 +3,7 @@ export { renderPage_addAsyncHookwrapper };
 import { renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { createPageContextServerSide, createPageContextServerSideWithoutGlobalContext, } from './renderPage/createPageContextServerSide.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, augmentType, } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled, } from '../../shared/route/abort.js';
 import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.js';
@@ -138,66 +138,59 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
     else {
         assert(errNominalPage);
         assert(pageContextNominalPageSuccess === undefined);
-        return await renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite);
-    }
-}
-// When the normal page threw an error
-// - Can be a URL rewrite upon `throw render('/some-url')`
-// - Can be rendering the error page
-// - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
-async function renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite) {
-    assert(pageContextNominalPageBegin);
-    assert(hasProp(pageContextNominalPageBegin, 'urlOriginal', 'string'));
-    const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
-    // Handle `throw redirect()` and `throw render()` while rendering nominal page
-    if (isAbortError(errNominalPage)) {
-        const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-        if (handled.pageContextReturn) {
-            // - throw redirect()
-            // - throw render(url)
-            // - throw render(abortStatusCode) if .pageContext.json request
-            return handled.pageContextReturn;
-        }
-        else {
-            // - throw render(abortStatusCode) if not .pageContext.json request
+        assert(pageContextNominalPageBegin);
+        assert(hasProp(pageContextNominalPageBegin, 'urlOriginal', 'string'));
+        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
+        // Handle `throw redirect()` and `throw render()` while rendering nominal page
+        if (isAbortError(errNominalPage)) {
+            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+            if (handled.pageContextReturn) {
+                // - throw redirect()
+                // - throw render(url)
+                // - throw render(abortStatusCode) if .pageContext.json request
+                return handled.pageContextReturn;
+            }
+            else {
+                // - throw render(abortStatusCode) if not .pageContext.json request
+            }
+            Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
         }
-        Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
-    }
-    {
-        const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
-        if (!errorPageId) {
-            objectAssign(pageContextErrorPageInit, { pageId: null });
-            return handleErrorWithoutErrorPage(pageContextErrorPageInit);
+        {
+            const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
+            if (!errorPageId) {
+                objectAssign(pageContextErrorPageInit, { pageId: null });
+                return handleErrorWithoutErrorPage(pageContextErrorPageInit);
+            }
+            else {
+                objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
+            }
         }
-        else {
-            objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
+        let pageContextErrorPage;
+        try {
+            pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
         }
-    }
-    let pageContextErrorPage;
-    try {
-        pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
-    }
-    catch (errErrorPage) {
-        // Handle `throw redirect()` and `throw render()` while rendering error page
-        if (isAbortError(errErrorPage)) {
-            const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-            // throw render(abortStatusCode)
-            if (!handled.pageContextReturn) {
-                const pageContextAbort = errErrorPage._pageContextAbort;
-                assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
-                const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-                return pageContextHttpWithError;
+        catch (errErrorPage) {
+            // Handle `throw redirect()` and `throw render()` while rendering error page
+            if (isAbortError(errErrorPage)) {
+                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+                // throw render(abortStatusCode)
+                if (!handled.pageContextReturn) {
+                    const pageContextAbort = errErrorPage._pageContextAbort;
+                    assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
+                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+                    return pageContextHttpWithError;
+                }
+                // `throw redirect()` / `throw render(url)`
+                return handled.pageContextReturn;
             }
-            // `throw redirect()` / `throw render(url)`
-            return handled.pageContextReturn;
-        }
-        if (isNewError(errErrorPage, errNominalPage)) {
-            logRuntimeError(errErrorPage, httpRequestId);
+            if (isNewError(errErrorPage, errNominalPage)) {
+                logRuntimeError(errErrorPage, httpRequestId);
+            }
+            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+            return pageContextWithError;
         }
-        const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-        return pageContextWithError;
+        return pageContextErrorPage;
     }
-    return pageContextErrorPage;
 }
 function logHttpRequest(urlOriginal, httpRequestId) {
     logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info');
@@ -419,7 +412,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
             objectAssign(pageContext, pageContextErrorPageInit, true);
-            augmentType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+            objectAssign(pageContext, await loadPageConfigsLazyServerSide(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = getPageContextClientSerialized(pageContext);
         }

package/dist/esm/shared/createPageContextShared.js CHANGED Viewed

@@ -1,9 +1,11 @@
 export { createPageContextShared };
 export { createPageContextObject };
+import { execHookGlobal } from './hooks/execHook.js';
+import { preparePageContextForPublicUsage } from './preparePageContextForPublicUsage.js';
 import { changeEnumerable, objectAssign } from './utils.js';
-// TODO/now: make this and parents sync
 async function createPageContextShared(pageContextCreated, pageConfigGlobal, vikeConfigPublicGlobal) {
     objectAssign(pageContextCreated, vikeConfigPublicGlobal);
+    await execHookGlobal('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage);
     return pageContextCreated;
 }
 function createPageContextObject() {

package/dist/esm/shared/hooks/execHook.d.ts CHANGED Viewed

@@ -19,7 +19,6 @@ import type { PageContextForPublicUsageServer } from '../../node/runtime/renderP
 import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
 import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
 import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
-type PageContextPrepareMinimum2 = PageContextPrepareMinimum & VikeConfigPublicPageLazy;
 type PageContextExecuteHook = VikeConfigPublicPageLazy & PageContextForPublicUsage;
 type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
 type HookWithResult = Hook & {
@@ -29,8 +28,8 @@ declare function execHookSingle<PageContext extends PageContextExecuteHook>(hook
 declare function execHookSingleWithReturn<PageContext extends PageContextExecuteHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
     hookReturn: unknown;
 }>;
-declare function execHook<PageContext extends PageContextPrepareMinimum2>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
-declare function execHookErrorHandling<PageContext extends PageContextPrepareMinimum2>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
+declare function execHook<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookErrorHandling<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
     hooks: HookWithResult[];
     err?: undefined;
 } | {

package/dist/esm/shared/route/index.js CHANGED Viewed

@@ -12,7 +12,6 @@ import { resolveRouteFunction } from './resolveRouteFunction.js';
 import { executeOnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
 import { debug } from './debug.js';
 import pc from '@brillout/picocolors';
-// TODO/next-major-release: make it sync
 async function route(pageContext, skipOnBeforeRouteHook) {
     debug('Pages routes:', pageContext._globalContext._pageRoutes);
     const pageContextFromRoute = {};

package/dist/esm/utils/PROJECT_VERSION.d.ts CHANGED Viewed

	@@ -1 +1 @@
1	- export declare const PROJECT_VERSION: "0.4.232~~-commit-ec54a7e~~";
1	+ export declare const PROJECT_VERSION: "0.4.232";

package/dist/esm/utils/PROJECT_VERSION.js CHANGED Viewed

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.232-commit-ec54a7e';
+export const PROJECT_VERSION = '0.4.232';

package/dist/esm/utils/styleFileRE.js CHANGED Viewed

@@ -1,3 +1,2 @@
 // Copied from https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/css.ts#L90-L91
-// spellcheck-ignore
 export const styleFileRE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\?)/;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.232-commit-ec54a7e",
+  "version": "0.4.232",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {