vike 0.0.0-alpha.0 → 0.4.142-commit-6eb0dd3

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

@@ -0,0 +1,10 @@
+export { renderPage } from './renderPage.js';
+export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
+export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
+export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
+export { createPageRenderer } from '../createPageRenderer.js';
+declare global {
+    var _isVitePluginSsr: true;
+    var _isVike: true;
+}
+import './page-files/setup.js';

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

@@ -0,0 +1,11 @@
+export { renderPage } from './renderPage.js';
+export { escapeInject, dangerouslySkipEscape } from './html/renderHtml.js';
+export { pipeWebStream, pipeNodeStream, pipeStream, stampPipe } from './html/stream.js';
+// TODO/v1-release: remove
+export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
+// TODO/v1-release: remove
+export { createPageRenderer } from '../createPageRenderer.js';
+// Help Telefunc detect the user's stack
+globalThis._isVitePluginSsr = true;
+globalThis._isVike = true;
+import './page-files/setup.js';

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

@@ -0,0 +1,17 @@
+export * from './index-common.js';
+export * from '../../types/index-dreprecated.js';
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import { RenderErrorPage } from 'vike'
+ *   ```
+ * With:
+ *   ```
+ *   import { render } from 'vike/abort'
+ *   ```
+ *
+ * See https://vike.dev/render
+ */
+export declare const RenderErrorPage: (args_0?: {
+    pageContext?: Record<string, unknown> | undefined;
+} | undefined) => Error;

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

@@ -0,0 +1,40 @@
+// TODO/v1-release: replace this with:
+// assertUsage(false, "`import { something } from 'vike'` doesn't exist: instead import from 'vike/server', 'vike/client', 'vike/plugin', ...")
+export * from './index-common.js';
+export * from '../../types/index-dreprecated.js';
+import { assertWarning } from './utils.js';
+import pc from '@brillout/picocolors';
+import { RenderErrorPage as RenderErrorPage_ } from '../../shared/route/abort.js';
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import { RenderErrorPage } from 'vike'
+ *   ```
+ * With:
+ *   ```
+ *   import { render } from 'vike/abort'
+ *   ```
+ *
+ * See https://vike.dev/render
+ */
+export const RenderErrorPage = (...args) => {
+    assertWarning(false, [
+        'Replace:',
+        pc.red("  import { RenderErrorPage } from 'vike'"),
+        'With:',
+        pc.green("  import { render } from 'vike/abort'"),
+        'See https://vike.dev/render'
+    ].join('\n'), { onlyOnce: true, showStackTrace: true });
+    return RenderErrorPage_(...args);
+};
+assertWarning(false, [
+    'You have following imports which are outdated:',
+    pc.red("  import { something } from 'vike'"),
+    'Replace them with:',
+    pc.green("  import { something } from 'vike/server'"),
+    `Or if ${pc.cyan('something')} is a type:`,
+    pc.green("  import type { something } from 'vike/types'"),
+    "Make sure to import renderPage(), escapeInject, html, dangerouslySkipEscape(), pipeWebStream(), pipeNodeStream(), pipeStream(), stampPipe() from 'vike/server'. (Or inspect the error stack below to find the import causing this warning.)"
+].join('\n'), { showStackTrace: true, onlyOnce: true });
+import { isBrowser, assertUsage } from './utils.js';
+assertUsage(!isBrowser(), "It's forbidden to `import { something } from 'vike'` in code loaded in the browser: the module 'vike' is a server-only module.", { showStackTrace: true });

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

@@ -0,0 +1 @@
+export * from './index-common.js';

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

@@ -0,0 +1,3 @@
+export * from './index-common.js';
+import { isBrowser, assertUsage } from './utils.js';
+assertUsage(!isBrowser(), "It's forbidden to `import { something } from 'vike/server'` in code loaded on the client-side: the module 'vike/server' is a server-only module.", { showStackTrace: true });

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

@@ -0,0 +1,2 @@
+export { onLoad };
+declare function onLoad(): void;

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

@@ -0,0 +1,9 @@
+export { onLoad };
+import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+import { assertNodeVersion } from '../../utils/assertNodeVersion.js';
+import { installRequireShim } from '@brillout/require-shim';
+function onLoad() {
+    assertIsNotBrowser();
+    assertNodeVersion();
+    installRequireShim();
+}

package/dist/esm/node/runtime/page-files/setup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/node/runtime/page-files/setup.js

@@ -0,0 +1,21 @@
+import { setPageFilesAsync } from '../../../shared/getPageFiles.js';
+import { assert, debugGlob, isObject } from '../utils.js';
+import { getViteDevServer } from '../globalContext.js';
+import { virtualFileIdImportUserCodeServer } from '../../shared/virtual-files/virtualFileImportUserCode.js';
+setPageFilesAsync(getPageFilesExports);
+async function getPageFilesExports() {
+    const viteDevServer = getViteDevServer();
+    assert(viteDevServer);
+    let moduleExports;
+    try {
+        moduleExports = await viteDevServer.ssrLoadModule(virtualFileIdImportUserCodeServer);
+    }
+    catch (err) {
+        debugGlob(`Glob error: ${virtualFileIdImportUserCodeServer} transpile error: `, err);
+        throw err;
+    }
+    moduleExports = moduleExports.default || moduleExports;
+    debugGlob('Glob result: ', moduleExports);
+    assert(isObject(moduleExports));
+    return moduleExports;
+}

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

@@ -0,0 +1,5 @@
+export { analyzePage };
+import type { PageFile } from '../../../shared/getPageFiles/getPageFileObject.js';
+import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import { type AnalysisResult } from '../../../shared/getPageFiles/analyzePageClientSide.js';
+declare function analyzePage(pageFilesAll: PageFile[], pageConfig: null | PageConfig, pageId: string): AnalysisResult;

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

@@ -0,0 +1,66 @@
+export { analyzePage };
+import { getVikeClientEntry } from '../../../shared/getPageFiles/analyzePageClientSide/determineClientEntry.js';
+import { analyzePageClientSide } from '../../../shared/getPageFiles/analyzePageClientSide.js';
+import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
+import { getGlobalContext } from '../globalContext.js';
+import { getClientEntryFilePath } from '../../shared/getClientEntryFilePath.js';
+function analyzePage(pageFilesAll, pageConfig, pageId) {
+    if (pageConfig) {
+        const { isClientSideRenderable, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
+        const clientFilePath = getClientEntryFilePath(pageConfig);
+        const clientEntry = !isClientSideRenderable ? clientFilePath : getVikeClientEntry(isClientRouting);
+        const clientDependencies = [];
+        clientDependencies.push({
+            id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, true),
+            onlyAssets: false,
+            eagerlyImported: false
+        });
+        // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
+        if (!getGlobalContext().isProduction) {
+            clientDependencies.push({
+                id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, false),
+                onlyAssets: true,
+                eagerlyImported: false
+            });
+        }
+        /* Remove?
+        Object.values(pageConfig.configElements).forEach((configElement) => {
+          if (configElement.importFilePath) {
+            const { env } = configElement
+            assert(env)
+            const onlyAssets = env === 'server-only'
+            const eagerlyImported = env === '_routing-eager'
+            if (onlyAssets || eagerlyImported) {
+              clientDependencies.push({
+                id: configElement.importFilePath,
+                onlyAssets,
+                eagerlyImported
+              })
+            }
+          }
+        })
+        */
+        const clientEntries = [];
+        if (clientEntry) {
+            clientDependencies.push({
+                id: clientEntry,
+                onlyAssets: false,
+                eagerlyImported: false
+            });
+            clientEntries.push(clientEntry);
+        }
+        return {
+            isHtmlOnly: !isClientSideRenderable,
+            isClientRouting,
+            clientEntries,
+            clientDependencies,
+            // pageFilesClientSide and pageFilesServerSide are only used for debugging
+            pageFilesClientSide: [],
+            pageFilesServerSide: []
+        };
+    }
+    else {
+        return analyzePageClientSide(pageFilesAll, pageId);
+    }
+}

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

@@ -0,0 +1,2 @@
+export { assertArguments };
+declare function assertArguments(...args: unknown[]): void;

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

@@ -0,0 +1,37 @@
+export { assertArguments };
+import { assert, assertUsage, assertWarning, hasProp, isObject } from '../utils.js';
+import pc from '@brillout/picocolors';
+function assertArguments(...args) {
+    const prefix = `[renderPage(${pc.cyan('pageContextInit')})]`;
+    const pageContextInit = args[0];
+    assertUsage(pageContextInit !== undefined && pageContextInit !== null, prefix + ` argument ${pc.cyan('pageContextInit')} is missing`, { showStackTrace: true });
+    const len = args.length;
+    assertUsage(len === 1, `${prefix} You passed ${len} arguments but renderPage() accepts only one argument.'`, {
+        showStackTrace: true
+    });
+    assertUsage(isObject(pageContextInit), `${prefix} ${pc.cyan('pageContextInit')} should be an object, but ${pc.cyan(`typeof pageContextInit === ${JSON.stringify(typeof pageContextInit)}`)}`, { showStackTrace: true });
+    // TODO/v1-release: remove
+    if ('url' in pageContextInit) {
+        assertWarning(false, '`pageContextInit.url` has been renamed to `pageContextInit.urlOriginal`: replace `renderPage({ url })` with `renderPage({ urlOriginal })`. (See https://vike.dev/migration/0.4.23 for more information.)', { showStackTrace: true, onlyOnce: true });
+        pageContextInit.urlOriginal = pageContextInit.url;
+        delete pageContextInit.url;
+    }
+    assert(!('url' in pageContextInit));
+    assertUsage(hasProp(pageContextInit, 'urlOriginal'), prefix + ` ${pc.cyan('pageContextInit')} is missing the property ${pc.cyan('pageContextInit.urlOriginal')}`, { showStackTrace: true });
+    const { urlOriginal } = pageContextInit;
+    assertUsage(typeof urlOriginal === 'string', prefix +
+        ` ${pc.cyan('pageContextInit.urlOriginal')} should be a string but ${pc.cyan(`typeof pageContextInit.urlOriginal === ${JSON.stringify(typeof urlOriginal)}`)}`, { showStackTrace: true });
+    assertUsage(urlOriginal.startsWith('/') || urlOriginal.startsWith('https://') || urlOriginal.startsWith('http://'), prefix +
+        ` ${pc.cyan('pageContextInit.urlOriginal')} should start with ${pc.cyan('/')} (e.g. ${pc.cyan('/product/42')}), ${pc.cyan('http://')}, or ${pc.cyan('https://')} (e.g. ${pc.cyan('https://example.com/product/42')}), but ${pc.cyan(`pageContextInit.urlOriginal === ${JSON.stringify(urlOriginal)}`)}`, { showStackTrace: true });
+    const urlOriginalWithoutOrigin = urlOriginal.startsWith('http')
+        ? urlOriginal
+        : 'http://fake-origin.example.org' + urlOriginal;
+    try {
+        // We use `new URL()` to validate the URL. (`new URL(url)` throws an error if `url` isn't a valid URL.)
+        new URL(urlOriginalWithoutOrigin);
+    }
+    catch (err) {
+        assertUsage(false, prefix +
+            ` ${pc.cyan('pageContextInit.urlOriginal')} should be a URL but ${pc.cyan(`pageContextInit.urlOriginal === ${JSON.stringify(urlOriginal)}`)}`, { showStackTrace: true });
+    }
+}

package/dist/esm/node/runtime/renderPage/createHttpResponseObject/assertNoInfiniteHttpRedirect.d.ts

@@ -0,0 +1,2 @@
+export { assertNoInfiniteHttpRedirect };
+declare function assertNoInfiniteHttpRedirect(urlRedirectOriginal: string, urlRedirectPathnameLogical: string): void;

package/dist/esm/node/runtime/renderPage/createHttpResponseObject/assertNoInfiniteHttpRedirect.js

@@ -0,0 +1,38 @@
+export { assertNoInfiniteHttpRedirect };
+import { assert, assertUsage, getGlobalObject } from '../../utils.js';
+import pc from '@brillout/picocolors';
+const globalObject = getGlobalObject('assertNoInfiniteHttpRedirect.ts', {
+    redirectGraph: {}
+});
+function assertNoInfiniteHttpRedirect(urlRedirectOriginal, urlRedirectPathnameLogical) {
+    if (urlRedirectOriginal.startsWith('http')) {
+        // We assume that the redirect points to an external origin, and we can therefore assume that the app doesn't define an infinite loop (in itself).
+        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin: the user usually passes the URL without origin.
+        //    ```js
+        //    // URL origin is usually missing
+        //    renderPage({ urlOriginal: '/some/pathname' })
+        //    ```
+        return;
+    }
+    assert(urlRedirectOriginal.startsWith('/'));
+    assert(urlRedirectPathnameLogical.startsWith('/'));
+    const graph = copy(globalObject.redirectGraph);
+    graph[urlRedirectOriginal] ?? (graph[urlRedirectOriginal] = new Set());
+    graph[urlRedirectOriginal].add(urlRedirectPathnameLogical);
+    validate(graph);
+    globalObject.redirectGraph = graph;
+}
+function copy(G) {
+    return Object.fromEntries(Object.entries(G).map(([key, val]) => [key, new Set(val)]));
+}
+// Adapted from: https://stackoverflow.com/questions/60904464/detect-cycle-in-directed-graph/60907076#60907076
+function check(G, n, path) {
+    if (path.includes(n)) {
+        const cycle = path.slice(path.indexOf(n)).concat(n);
+        assertUsage(false, `Infinite loop of HTTP URL redirects: ${cycle.map(pc.cyan).join(' -> ')}`);
+    }
+    G[n]?.forEach((node) => check(G, node, [...path, n]));
+}
+function validate(G) {
+    Object.keys(G).forEach((n) => check(G, n, []));
+}

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

@@ -0,0 +1,28 @@
+export { createHttpResponseObject };
+export { createHttpResponsePageContextJson };
+export { createHttpResponseObjectRedirect };
+export type { HttpResponse };
+import type { GetPageAssets } from './getPageAssets.js';
+import type { HtmlRender } from '../html/renderHtml.js';
+import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import type { RenderHook } from './executeOnRenderHtmlHook.js';
+import type { RedirectStatusCode, AbortStatusCode, UrlRedirect } from '../../../shared/route/abort.js';
+import { HttpResponseBody } from './getHttpResponseBody.js';
+import { type EarlyHint } from './getEarlyHints.js';
+type HttpResponse = {
+    statusCode: 200 | 404 | 500 | RedirectStatusCode | AbortStatusCode;
+    headers: [string, string][];
+    earlyHints: EarlyHint[];
+    /** **Deprecated**: use `headers` instead, see https://vike.dev/migration/0.4.134 */
+    contentType: 'application/json' | 'text/html;charset=utf-8';
+} & HttpResponseBody;
+declare function createHttpResponseObject(htmlRender: null | HtmlRender, renderHook: null | RenderHook, pageContext: {
+    _pageId: null | string;
+    is404: null | boolean;
+    errorWhileRendering: null | Error;
+    __getPageAssets: GetPageAssets;
+    _pageConfigs: PageConfig[];
+    abortStatusCode?: AbortStatusCode;
+}): Promise<HttpResponse | null>;
+declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
+declare function createHttpResponseObjectRedirect({ url, statusCode }: UrlRedirect, urlPathnameLogical: string): HttpResponse;

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

@@ -0,0 +1,65 @@
+export { createHttpResponseObject };
+export { createHttpResponsePageContextJson };
+export { createHttpResponseObjectRedirect };
+import { assert, assertWarning } from '../utils.js';
+import { isErrorPage } from '../../../shared/error-page.js';
+import { getHttpResponseBody, getHttpResponseBodyStreamHandlers } from './getHttpResponseBody.js';
+import { getEarlyHints } from './getEarlyHints.js';
+import { assertNoInfiniteHttpRedirect } from './createHttpResponseObject/assertNoInfiniteHttpRedirect.js';
+async function createHttpResponseObject(htmlRender, renderHook, pageContext) {
+    if (htmlRender === null) {
+        return null;
+    }
+    let statusCode = pageContext.abortStatusCode;
+    if (!statusCode) {
+        const isError = !pageContext._pageId || isErrorPage(pageContext._pageId, pageContext._pageConfigs);
+        if (pageContext.errorWhileRendering) {
+            assert(isError);
+        }
+        if (!isError) {
+            assert(pageContext.is404 === null);
+            statusCode = 200;
+        }
+        else {
+            assert(pageContext.is404 === true || pageContext.is404 === false);
+            statusCode = pageContext.is404 ? 404 : 500;
+        }
+    }
+    const earlyHints = getEarlyHints(await pageContext.__getPageAssets());
+    return getHttpResponse(statusCode, 'text/html;charset=utf-8', [], htmlRender, earlyHints, renderHook);
+}
+async function createHttpResponsePageContextJson(pageContextSerialized) {
+    const httpResponse = getHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
+    return httpResponse;
+}
+function createHttpResponseObjectRedirect({ url, statusCode }, 
+// The URL pathname we assume the redirect to be logically based on
+urlPathnameLogical) {
+    assertNoInfiniteHttpRedirect(url, urlPathnameLogical);
+    assert(url);
+    assert(statusCode);
+    assert(300 <= statusCode && statusCode <= 399);
+    const headers = [['Location', url]];
+    return getHttpResponse(statusCode, 'text/html;charset=utf-8', headers, 
+    // For bots / programmatic crawlig: show what's going on.
+    // For users: showing a blank page is probably better than a flickering text.
+    `<p style="display: none">Redirecting to ${url}</p>`);
+}
+function getHttpResponse(statusCode, contentType, headers, htmlRender, earlyHints = [], renderHook = null) {
+    headers.push(['Content-Type', contentType]);
+    assert(renderHook || typeof htmlRender === 'string');
+    return {
+        statusCode,
+        headers,
+        // TODO/v1-release: remove
+        get contentType() {
+            assertWarning(false, 'pageContext.httpResponse.contentType is deprecated and will be removed in the next major release. Use pageContext.httpResponse.headers instead, see https://vike.dev/migration/0.4.134', { onlyOnce: true });
+            return contentType;
+        },
+        earlyHints,
+        get body() {
+            return getHttpResponseBody(htmlRender, renderHook);
+        },
+        ...getHttpResponseBodyStreamHandlers(htmlRender, renderHook)
+    };
+}

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

@@ -0,0 +1,24 @@
+export { debugPageFiles };
+export type { PageContextDebug };
+import { RouteMatches } from '../../../shared/route/index.js';
+import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
+import type { PageFile } from '../../../shared/getPageFiles.js';
+import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+type PageContextDebug = {
+    _routeMatches: 'ROUTE_ERROR' | RouteMatches;
+};
+declare function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoaded, pageFilesServerSide, pageFilesClientSide, clientEntries, clientDependencies }: {
+    pageContext: {
+        urlOriginal: string;
+        _pageId: string;
+        _pageFilesAll: PageFile[];
+        _pageConfigs: PageConfig[];
+    } & PageContextDebug;
+    isHtmlOnly: boolean;
+    isClientRouting: boolean;
+    pageFilesLoaded: PageFile[];
+    pageFilesClientSide: PageFile[];
+    pageFilesServerSide: PageFile[];
+    clientEntries: string[];
+    clientDependencies: ClientDependency[];
+}): void;

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

@@ -0,0 +1,47 @@
+export { debugPageFiles };
+import pc from '@brillout/picocolors';
+import { assert, makeFirst, createDebugger } from '../utils.js';
+function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoaded, pageFilesServerSide, pageFilesClientSide, clientEntries, clientDependencies }) {
+    const debug = createDebugger('vike:pageFiles', { serialization: { emptyArray: 'None' } });
+    const padding = '   - ';
+    debug('All page files:', printPageFiles(pageContext._pageFilesAll, true)); // TODO
+    debug(`URL:`, pageContext.urlOriginal);
+    debug.options({ serialization: { emptyArray: 'No match' } })(`Routing:`, printRouteMatches(pageContext._routeMatches));
+    debug(`pageId:`, pageContext._pageId);
+    debug('Page type:', isHtmlOnly ? 'HTML-only' : 'SSR/SPA');
+    debug(`Routing type:`, !isHtmlOnly && isClientRouting ? 'Client Routing' : 'Server Routing');
+    debug('Server-side page files:', printPageFiles(pageFilesLoaded));
+    assert(samePageFiles(pageFilesLoaded, pageFilesServerSide));
+    debug('Client-side page files:', printPageFiles(pageFilesClientSide));
+    debug('Client-side entries:', clientEntries);
+    debug('Client-side dependencies:', clientDependencies);
+    return;
+    function printRouteMatches(routeMatches) {
+        if (routeMatches === 'ROUTE_ERROR') {
+            return 'Routing Failed';
+        }
+        if (routeMatches === 'CUSTOM_ROUTE') {
+            return 'Custom Routing';
+        }
+        return routeMatches;
+    }
+    function printPageFiles(pageFiles, genericPageFilesLast = false) {
+        if (pageFiles.length === 0) {
+            return 'None';
+        }
+        return ('\n' +
+            pageFiles
+                .sort((p1, p2) => p1.filePath.localeCompare(p2.filePath))
+                .sort(makeFirst((p) => (p.isRendererPageFile ? !genericPageFilesLast : null)))
+                .sort(makeFirst((p) => (p.isDefaultPageFile ? !genericPageFilesLast : null)))
+                .map((p) => p.filePath)
+                .map((s) => s.split('_default.page.').join(`${pc.blue('_default')}.page.`))
+                .map((s) => s.split('/renderer/').join(`/${pc.red('renderer')}/`))
+                .map((s) => padding + s)
+                .join('\n'));
+    }
+}
+function samePageFiles(pageFiles1, pageFiles2) {
+    return (pageFiles1.every((p1) => pageFiles2.some((p2) => p2.filePath === p1.filePath)) &&
+        pageFiles2.every((p2) => pageFiles1.some((p1) => p1.filePath === p2.filePath)));
+}

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

@@ -0,0 +1,7 @@
+export { executeOnBeforeRenderHooks };
+import { type PageContextExports } from '../../../shared/getPageFiles.js';
+import { type PageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
+declare function executeOnBeforeRenderHooks(pageContext: {
+    _pageId: string;
+    _pageContextAlreadyProvidedByOnPrerenderHook?: true;
+} & PageContextExports & PageContextForUserConsumptionServerSide): Promise<void>;

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

@@ -0,0 +1,20 @@
+export { executeOnBeforeRenderHooks };
+import { getHook } from '../../../shared/hooks/getHook.js';
+import { preparePageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
+import { executeHook } from '../utils.js';
+import { assertOnBeforeRenderHookReturn } from '../../../shared/assertOnBeforeRenderHookReturn.js';
+async function executeOnBeforeRenderHooks(pageContext) {
+    if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
+        return;
+    }
+    const hook = getHook(pageContext, 'onBeforeRender');
+    if (!hook) {
+        return;
+    }
+    const onBeforeRender = hook.hookFn;
+    preparePageContextForUserConsumptionServerSide(pageContext);
+    const hookResult = await executeHook(() => onBeforeRender(pageContext), 'onBeforeRender', hook.hookFilePath);
+    assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
+    const pageContextFromHook = hookResult?.pageContext;
+    Object.assign(pageContext, pageContextFromHook);
+}

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

@@ -0,0 +1,25 @@
+export { executeOnRenderHtmlHook };
+export type { RenderHook };
+import { type HtmlRender } from '../html/renderHtml.js';
+import type { PageAsset } from './getPageAssets.js';
+import { type PageContextForUserConsumptionServerSide } from './preparePageContextForUserConsumptionServerSide.js';
+import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+import type { PageContextSerialization } from '../html/serializePageContextClientSide.js';
+type GetPageAssets = () => Promise<PageAsset[]>;
+type RenderHook = {
+    hookFilePath: string;
+    hookName: HookName;
+};
+type HookName = 'onRenderHtml' | 'render';
+declare function executeOnRenderHtmlHook(pageContext: PageContextForUserConsumptionServerSide & PageContextSerialization & {
+    _pageId: string;
+    _pageConfigs: PageConfig[];
+    __getPageAssets: GetPageAssets;
+    _isHtmlOnly: boolean;
+    _baseServer: string;
+    _pageFilePathsLoaded: string[];
+    _httpRequestId: number | null;
+}): Promise<{
+    renderHook: RenderHook;
+    htmlRender: null | HtmlRender;
+}>;