vike 0.4.228-commit-67e28cd → 0.4.228-commit-ae4784f

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

@@ -3,13 +3,13 @@ export { getRenderCount };
 export { disableClientRouting };
 export { firstRenderStartPromise };
 export { getPageContextClient };
-import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, executeHook, hasProp, augmentType, genPromise, isCallable, catchInfiniteLoop } from './utils.js';
+import { assert, isSameErrorMessage, objectAssign, redirectHard, getGlobalObject, hasProp, augmentType, genPromise, isCallable, catchInfiniteLoop } from './utils.js';
 import { getPageContextFromClientHooks, getPageContextFromServerHooks, getPageContextFromHooks_isHydration, getPageContextFromHooks_serialized, setPageContextInitIsPassedToClient } from './getPageContextFromHooks.js';
 import { createPageContext } from './createPageContext.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 { assertHook, getHook } from '../../shared/hooks/getHook.js';
+import { assertHook, getHookFromPageContext } from '../../shared/hooks/getHook.js';
 import { isErrorFetchingStaticAssets, loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { pushHistoryState } from './history.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled } from '../../shared/route/abort.js';
@@ -21,12 +21,14 @@ 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 { executeHook } from '../../shared/hooks/executeHook.js';
 const globalObject = getGlobalObject('client-routing-runtime/renderPageClientSide.ts', (() => {
     const { promise: firstRenderStartPromise, resolve: firstRenderStartPromiseResolve } = genPromise();
     return {
         renderCounter: 0,
         firstRenderStartPromise,
-        firstRenderStartPromiseResolve
+        firstRenderStartPromiseResolve,
+        globalContext: {}
     };
 })());
 const { firstRenderStartPromise } = globalObject;
@@ -62,7 +64,7 @@ async function renderPageClientSide(renderArgs) {
             assertHook(previousPageContext, 'onPageTransitionStart');
             if (!globalObject.isTransitioning) {
                 globalObject.isTransitioning = true;
-                const onPageTransitionStartHook = getHook(previousPageContext, 'onPageTransitionStart');
+                const onPageTransitionStartHook = getHookFromPageContext(previousPageContext, 'onPageTransitionStart');
                 if (onPageTransitionStartHook) {
                     const hook = onPageTransitionStartHook;
                     const { hookFn } = hook;
@@ -429,7 +431,7 @@ async function renderPageClientSide(renderArgs) {
         // onHydrationEnd()
         if (isFirstRender && !onRenderClientError) {
             assertHook(pageContext, 'onHydrationEnd');
-            const hook = getHook(pageContext, 'onHydrationEnd');
+            const hook = getHookFromPageContext(pageContext, 'onHydrationEnd');
             if (hook) {
                 const { hookFn } = hook;
                 try {
@@ -452,7 +454,7 @@ async function renderPageClientSide(renderArgs) {
             globalObject.isTransitioning = undefined;
             assert(previousPageContext);
             assertHook(previousPageContext, 'onPageTransitionEnd');
-            const hook = getHook(previousPageContext, 'onPageTransitionEnd');
+            const hook = getHookFromPageContext(previousPageContext, 'onPageTransitionEnd');
             if (hook) {
                 const { hookFn } = hook;
                 try {

package/dist/esm/client/client-routing-runtime/utils.d.ts

@@ -1,6 +1,5 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/assertSingleInstance.js';
-export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/hasProp.js';
 export * from '../../utils/isBrowser.js';

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

@@ -4,7 +4,6 @@ import { onLoad } from './onLoad.js';
 onLoad();
 export * from '../../utils/assert.js';
 export * from '../../utils/assertSingleInstance.js';
-export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/hasProp.js';
 export * from '../../utils/isBrowser.js';

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

@@ -1,6 +1,5 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/assertSingleInstance.js';
-export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/checkType.js';
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/hasProp.js';

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

@@ -4,7 +4,6 @@ import { onLoad } from './onLoad.js';
 onLoad();
 export * from '../../utils/assert.js';
 export * from '../../utils/assertSingleInstance.js';
-export * from '../../shared/hooks/executeHook.js';
 export * from '../../utils/checkType.js'; // Only used by Server Routing (not needed for Client Routing)
 export * from '../../utils/getGlobalObject.js';
 export * from '../../utils/hasProp.js';

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

@@ -1,18 +1,19 @@
 export { executeOnRenderClientHook };
-import { assert, assertUsage, executeHook } from '../server-routing-runtime/utils.js';
-import { getHook } from '../../shared/hooks/getHook.js';
+import { assert, assertUsage } from '../server-routing-runtime/utils.js';
+import { getHookFromPageContext } from '../../shared/hooks/getHook.js';
 import { preparePageContextForUserConsumptionClientSide } from './preparePageContextForUserConsumptionClientSide.js';
+import { executeHook } from '../../shared/hooks/executeHook.js';
 async function executeOnRenderClientHook(pageContext, isClientRouting) {
     const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide(pageContext, isClientRouting);
     let hook = null;
     let hookName;
     {
-        const renderHook = getHook(pageContext, 'render');
+        const renderHook = getHookFromPageContext(pageContext, 'render');
         hook = renderHook;
         hookName = 'render';
     }
     {
-        const renderHook = getHook(pageContext, 'onRenderClient');
+        const renderHook = getHookFromPageContext(pageContext, 'onRenderClient');
         if (renderHook) {
             hook = renderHook;
             hookName = 'onRenderClient';

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

@@ -6,6 +6,7 @@ import { assert } from './utils.js';
 //   - https://github.com/rakkasjs/rakkasjs/blob/7d75ccc915e93bca04e6bab37dc6abdb68a85e4a/packages/rakkasjs/src/features/pages/middleware.tsx#L701
 // - https://github.com/remix-run/remix/issues/8830
 function removeFoucBuster() {
+    // In production removeFoucBuster() is expected to be have been removed by tree shaking
     assert(import.meta.env.DEV);
     let sleep = 2;
     setTimeout(runClean, sleep);

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

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

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

@@ -5,7 +5,8 @@ export { runPrerender_forceExit };
 import path from 'path';
 import { route } from '../../shared/route/index.js';
 import { assert, assertUsage, assertWarning, hasProp, objectAssign, isObjectWithKeys, isCallable, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, onSetupPrerender, makePublicCopy, PROJECT_VERSION, preservePropertyGetters } from './utils.js';
-import { prerenderPage, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
+import { prerenderPage } from '../runtime/renderPage/renderPageAlreadyRouted.js';
+import { createPageContextServerSide } from '../runtime/renderPage/createPageContextServerSide.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
 import { getGlobalContextInternal, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
@@ -109,10 +110,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);
@@ -257,7 +258,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) {
                 objectAssign(pageContextNew, { _pageContextAlreadyProvidedByOnPrerenderHook: true });
@@ -303,22 +304,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 getPageContextInitEnhanced(pageContextInit, globalContext, true);
+    const pageContext = await createPageContextServerSide(pageContextInit, globalContext, { isPrerendering: true });
     assert(pageContext.isPrerendering === true);
     objectAssign(pageContext, {
         _urlHandler: null,

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,85 @@
+export { createPageContextServerSide };
+export { createPageContextServerSideWithoutGlobalContext };
+export type { PageContextServerSideCreated };
+import type { GlobalContextInternal } from '../globalContext.js';
+import type { PageContextInit } from '../renderPage.js';
+type PageContextServerSideCreated = Awaited<ReturnType<typeof createPageContextServerSide>>;
+declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextInternal, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } }: {
+    isPrerendering: false;
+    ssr: {
+        urlHandler: null | ((url: string) => string);
+        isClientSideNavigation: boolean;
+    };
+} | {
+    isPrerendering: true;
+    ssr?: undefined;
+}): Promise<{
+    _isPageContextObject: boolean;
+    isClientSide: boolean;
+    isPrerendering: boolean;
+} & Pick<import("../../../shared/types.js").PageContextBuiltInServerInternal, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+} & {
+    _objectCreatedByVike: boolean;
+    _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;
+    _globalContext: GlobalContextInternal;
+    /** @experimental This is a beta feature https://vike.dev/getGlobalContext */
+    globalContext: Pick<{
+        viteConfigRuntime: import("../../plugin/shared/getViteConfigRuntime.js").ViteConfigRuntime;
+        config: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigUserFriendly["config"];
+        pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    } & import("../../shared/resolveBase.js").BaseUrlsResolved & ({
+        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;
+        pages: import("../../../shared/page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+        config: import("../../../types/index.js").ConfigResolved;
+    } & ({
+        isProduction: false;
+        isPrerendering: false;
+        viteConfig: import("vite").ResolvedConfig;
+        viteDevServer: import("vite").ViteDevServer;
+        assetsManifest: null;
+    } | ({
+        isProduction: true;
+        assetsManifest: import("../../shared/ViteManifest.js").ViteManifest;
+        viteDevServer: null;
+    } & ({
+        isPrerendering: false;
+        viteConfig: null;
+    } | {
+        isPrerendering: true;
+        usesClientRouter: boolean;
+        viteConfig: import("vite").ResolvedConfig;
+    })))), "pages" | "baseServer" | "baseAssets" | "config" | "assetsManifest" | "viteConfig" | "viteConfigRuntime">;
+    _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;
+}>;
+declare function createPageContextServerSideWithoutGlobalContext(pageContextInit: PageContextInit): {
+    _isPageContextObject: boolean;
+    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, normalizeHeaders, objectAssign } from '../utils.js';
+import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComputed.js';
+import { executeHookGenericGlobalCumulative } from './executeHookGeneric.js';
+async function createPageContextServerSide(pageContextInit, globalContext, { isPrerendering, ssr: { urlHandler, isClientSideNavigation } = {
+    urlHandler: null,
+    isClientSideNavigation: false
+} }) {
+    assert(pageContextInit.urlOriginal);
+    const pageContextCreated = createPageContext(pageContextInit, isPrerendering);
+    objectAssign(pageContextCreated, pageContextInit);
+    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 = 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 });
+    }
+    await 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
+    };
+    objectAssign(pageContext, pageContextInit);
+    return pageContext;
+}

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

@@ -0,0 +1,9 @@
+export { executeHookGeneric };
+export { executeHookGenericGlobalCumulative };
+import type { PageConfigUserFriendlyOld } from '../../../shared/getPageFiles.js';
+import { type HookName } from '../../../shared/hooks/getHook.js';
+import type { HookNameGlobal } from '../../../shared/page-configs/Config.js';
+import type { GlobalContextInternal } from '../globalContext.js';
+import type { PageContextServerSideCreated } from './createPageContextServerSide.js';
+declare function executeHookGeneric(hookName: HookName, pageContext: PageConfigUserFriendlyOld): Promise<void>;
+declare function executeHookGenericGlobalCumulative(hookName: HookNameGlobal, globalContext: GlobalContextInternal, pageContext: PageContextServerSideCreated): Promise<void>;

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

@@ -0,0 +1,16 @@
+export { executeHookGeneric }; // TO-DO/refactor: start using executeHookGeneric() and, eventually, prominently use it
+export { executeHookGenericGlobalCumulative };
+import { executeHook } from '../../../shared/hooks/executeHook.js';
+import { getHookFromPageContext, getHookFromPageConfigGlobalCumulative } from '../../../shared/hooks/getHook.js';
+async function executeHookGeneric(hookName, pageContext) {
+    const hook = getHookFromPageContext(pageContext, hookName);
+    if (!hook)
+        return;
+    await executeHook(() => hook.hookFn(pageContext), hook, pageContext);
+}
+async function executeHookGenericGlobalCumulative(hookName, globalContext, pageContext) {
+    const hooks = getHookFromPageConfigGlobalCumulative(globalContext.pageConfigGlobal, hookName);
+    await Promise.all(hooks.map(async (hook) => {
+        await executeHook(() => hook.hookFn(pageContext), hook, null);
+    }));
+}

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.js

@@ -1,6 +1,6 @@
 export { executeOnRenderHtmlHook };
 import { isDocumentHtml, renderDocumentHtml, dangerouslySkipEscape } from '../html/renderHtml.js';
-import { getHook } from '../../../shared/hooks/getHook.js';
+import { getHookFromPageContext } from '../../../shared/hooks/getHook.js';
 import { assert, assertUsage, assertWarning, isObject, objectAssign, isPromise, isCallable } from '../utils.js';
 import { isStream } from '../html/stream.js';
 import { assertPageContextProvidedByUser } from '../../../shared/assertPageContextProvidedByUser.js';
@@ -36,12 +36,12 @@ function getRenderHook(pageContext) {
     {
         let hook;
         let hookName = undefined;
-        hook = getHook(pageContext, 'onRenderHtml');
+        hook = getHookFromPageContext(pageContext, 'onRenderHtml');
         if (hook) {
             hookName = 'onRenderHtml';
         }
         else {
-            hook = getHook(pageContext, 'render');
+            hook = getHookFromPageContext(pageContext, 'render');
             if (hook) {
                 hookName = 'render';
             }

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

@@ -1,7 +1,6 @@
 export { retrieveAssetsDev };
 import { assert, styleFileRE } from '../../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'))
@@ -20,7 +19,7 @@ async function retrieveAssetsDev(clientDependencies, viteDevServer) {
             return;
         }
         assert(mod, { id });
-        collectCss(mod, assetUrls, visitedModules);
+        collectCss(mod, assetUrls, new Set());
     }));
     return Array.from(assetUrls);
 }
@@ -50,9 +49,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);
@@ -67,15 +63,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
-  })
-}
-//*/