vike 0.4.247-commit-a642bde → 0.4.247-commit-14351e3

package/dist/server/runtime/renderPageServer/createPageContextServerSide.d.ts

@@ -0,0 +1,159 @@
+export { createPageContextServerSide };
+export { createPageContextServerSideWithoutGlobalContext };
+export type { PageContextCreated };
+import type { GlobalContextServerInternal } from '../globalContext.js';
+import type { PageContextInit } from '../renderPageServer.js';
+type PageContextCreated = Awaited<ReturnType<typeof createPageContextServerSide>>;
+declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, args: {
+    requestId: number;
+} & ({
+    isPrerendering: true;
+} | {
+    isPrerendering: false;
+    urlHandler: null | ((url: string) => string);
+    isClientSideNavigation: boolean;
+})): {
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
+    isPrerendering: boolean;
+    _requestId: number;
+} & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+} & {
+    _globalContext: ({
+        _globalConfigPublic: {
+            pages: {
+                [k: string]: {
+                    config: import("../../../types/index.js").ConfigResolved;
+                    _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+                    _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+                    _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+                } & ({
+                    route: import("../../../types/Config.js").Route;
+                    isErrorPage?: undefined;
+                } | {
+                    route?: undefined;
+                    isErrorPage: true;
+                });
+            };
+            config: import("../../../types/index.js").ConfigResolved;
+            _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        };
+        pages: {
+            [k: string]: {
+                config: import("../../../types/index.js").ConfigResolved;
+                _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../../../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../../../types/index.js").ConfigResolved;
+        _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        isGlobalContext: true;
+        _isOriginalObject: true;
+        _virtualFileExportsGlobalEntry: unknown;
+        _pageFilesAll: import("../../__internal/index.js").PageFile[];
+        _pageConfigs: import("../../__internal/index.js").PageConfig[];
+        _pageConfigGlobal: import("../../../types/PageConfig.js").PageConfigGlobalRuntime;
+        _allPageIds: string[];
+    } & (({
+        _isProduction: false;
+        _isPrerendering: false;
+        assetsManifest: null;
+        _viteDevServer: import("vite").ViteDevServer | undefined;
+        viteConfig: import("vite").ResolvedConfig | undefined;
+        isClientSide: false;
+        _pageRoutes: import("../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").Hook | null;
+    } | {
+        _isPrerendering: true;
+        viteConfig: import("vite").ResolvedConfig;
+        _isProduction: true;
+        assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        _usesClientRouter: boolean;
+        isClientSide: false;
+        _pageRoutes: import("../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").Hook | null;
+    } | {
+        _isPrerendering: false;
+        viteConfig: null;
+        _isProduction: true;
+        assetsManifest: import("../../../types/ViteManifest.js").ViteManifest;
+        _viteDevServer: null;
+        _usesClientRouter: boolean;
+        isClientSide: false;
+        _pageRoutes: import("../../__internal/index.js").PageRoutes;
+        _onBeforeRouteHook: import("../../../shared-server-client/hooks/getHook.js").Hook | null;
+    }) & {
+        baseServer: string;
+        baseAssets: string;
+        viteConfigRuntime: {
+            root: string;
+            build: {
+                outDir: string;
+            };
+            _baseViteOriginal: string;
+            vitePluginServerEntry: {
+                inject: boolean | undefined;
+            };
+        };
+    })) & {
+        prerenderContext: import("../../../types/index.js").PrerenderContext | undefined;
+    };
+    _pageFilesAll: import("../../__internal/index.js").PageFile[];
+    _baseServer: string;
+    _baseAssets: string;
+    _pageContextInit: PageContextInit;
+    _urlHandler: ((url: string) => string) | null;
+    isClientSideNavigation: boolean;
+} & {
+    pages: {
+        [k: string]: {
+            config: import("../../../types/index.js").ConfigResolved;
+            _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../../../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
+    config: import("../../../types/index.js").ConfigResolved;
+    _source: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("../../../shared-server-client/page-configs/resolveVikeConfigPublic.js").From;
+} & {
+    urlParsed: import("../../utils.js").UrlPublic;
+    urlPathname: string;
+    url: string;
+} & {
+    headers: Record<string, string> | null;
+};
+declare function createPageContextServerSideWithoutGlobalContext(pageContextInit: PageContextInit, requestId: number): {
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
+    isPrerendering: boolean;
+    _requestId: number;
+} & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+    url?: string;
+    headers?: Record<string, string>;
+};

package/dist/server/runtime/renderPageServer/createPageContextServerSide.js

@@ -0,0 +1,57 @@
+export { createPageContextServerSide };
+export { createPageContextServerSideWithoutGlobalContext };
+import { assert, assertUsage, assertWarning, updateType, normalizeHeaders, objectAssign } from '../../utils.js';
+import { getPageContextUrlComputed } from '../../../shared-server-client/getPageContextUrlComputed.js';
+import { createPageContextObject, createPageContextShared, } from '../../../shared-server-client/createPageContextShared.js';
+function createPageContextServerSide(pageContextInit, globalContext, args) {
+    assert(pageContextInit.urlOriginal);
+    const pageContextCreated = createPageContext(pageContextInit, args.isPrerendering, args.requestId);
+    objectAssign(pageContextCreated, {
+        _globalContext: globalContext,
+        _pageFilesAll: globalContext._pageFilesAll, // TO-DO/next-major-release: remove
+        // We use pageContext._baseServer and pageContext._baseAssets instead of pageContext._globalContext.baseServer and pageContext._globalContext.baseAssets because the Base URLs can (eventually one day if needed) be made non-global
+        _baseServer: globalContext.baseServer,
+        _baseAssets: globalContext.baseAssets,
+        _pageContextInit: pageContextInit,
+        _urlHandler: args.isPrerendering ? null : args.urlHandler,
+        isClientSideNavigation: args.isPrerendering ? false : args.isClientSideNavigation,
+    });
+    objectAssign(pageContextCreated, globalContext._globalConfigPublic);
+    // 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;
+            // TO-DO/next-major-release: remove
+            assertWarning(false, 'Setting pageContextInit.headers is deprecated: set pageContextInit.headersOriginal instead, see https://vike.dev/headers', { onlyOnce: true });
+        }
+        else {
+            headers = null;
+        }
+        objectAssign(pageContextCreated, { headers });
+    }
+    const pageContextAugmented = createPageContextShared(pageContextCreated, globalContext._globalConfigPublic);
+    updateType(pageContextCreated, pageContextAugmented);
+    return pageContextCreated;
+}
+function createPageContextServerSideWithoutGlobalContext(pageContextInit, requestId) {
+    const pageContext = createPageContext(pageContextInit, false, requestId);
+    return pageContext;
+}
+function createPageContext(pageContextInit, isPrerendering, requestId) {
+    const pageContext = createPageContextObject();
+    objectAssign(pageContext, {
+        isClientSide: false,
+        isPrerendering,
+        _requestId: requestId,
+    });
+    objectAssign(pageContext, pageContextInit);
+    return pageContext;
+}

package/dist/server/runtime/renderPageServer/csp.d.ts

@@ -0,0 +1,12 @@
+export { resolvePageContextCspNone };
+export { inferNonceAttr };
+export { addCspResponseHeader };
+export type { PageContextCspNonce };
+import type { PageContextConfig } from '../../../shared-server-client/getPageFiles.js';
+import type { PageContextServer } from '../../../types/PageContext.js';
+declare function resolvePageContextCspNone(pageContext: PageContextConfig & Partial<PageContextCspNonce>): Promise<null | {
+    cspNonce: string | null;
+}>;
+type PageContextCspNonce = Pick<PageContextServer, 'cspNonce'>;
+declare function inferNonceAttr(pageContext: PageContextCspNonce): string;
+declare function addCspResponseHeader(pageContext: PageContextCspNonce, headersResponse: Headers): void;

package/dist/server/runtime/renderPageServer/csp.js

@@ -0,0 +1,45 @@
+export { resolvePageContextCspNone };
+export { inferNonceAttr };
+export { addCspResponseHeader };
+import { import_ } from '@brillout/import';
+import { assert } from '../../utils.js';
+async function resolvePageContextCspNone(pageContext) {
+    if (pageContext.cspNonce)
+        return null; // already set by user e.g. `renderPage({ cspNonce: '123456789' })`
+    const { csp } = pageContext.config;
+    const pageContextAddendum = { cspNonce: null };
+    if (csp?.nonce) {
+        if (csp.nonce === true) {
+            pageContextAddendum.cspNonce = await generateNonce();
+        }
+        else {
+            pageContextAddendum.cspNonce = await csp.nonce(pageContext);
+        }
+    }
+    return pageContextAddendum;
+}
+// Generate a cryptographically secure nonce for Content Security Policy (CSP).
+// Returns a base64url-encoded nonce string (URL-safe, no padding).
+// https://github.com/vikejs/vike/issues/1554#issuecomment-3181128304
+async function generateNonce() {
+    let cryptoModule;
+    try {
+        cryptoModule = (await import_('crypto')).default;
+    }
+    catch {
+        return Math.random().toString(36).substring(2, 18);
+    }
+    return cryptoModule.randomBytes(16).toString('base64url');
+}
+function inferNonceAttr(pageContext) {
+    const nonceAttr = pageContext.cspNonce ? ` nonce="${pageContext.cspNonce}"` : '';
+    return nonceAttr;
+}
+function addCspResponseHeader(pageContext, headersResponse) {
+    assert(pageContext.cspNonce === null || typeof pageContext.cspNonce === 'string'); // ensure resolvePageContextCspNone() is called before addCspResponseHeader()
+    if (!pageContext.cspNonce)
+        return;
+    if (headersResponse.get('Content-Security-Policy'))
+        return;
+    headersResponse.set('Content-Security-Policy', `script-src 'self' 'nonce-${pageContext.cspNonce}'`);
+}

package/dist/server/runtime/renderPageServer/execHookDataAndOnBeforeRender.js

@@ -0,0 +1,29 @@
+export { execHookDataAndOnBeforeRender };
+import { assertOnBeforeRenderHookReturn } from '../../../shared-server-client/assertOnBeforeRenderHookReturn.js';
+import { execHookServer } from './execHookServer.js';
+async function execHookDataAndOnBeforeRender(pageContext) {
+    if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
+        return;
+    }
+    const hooks = await execHookServer('data', pageContext);
+    const dataHook = hooks[0]; // TO-DO/soon/cumulative-hooks: support cumulative
+    if (dataHook) {
+        // Note: hookReturn can be anything (e.g. an object) and is to be assigned to pageContext.data
+        const pageContextFromHook = {
+            data: dataHook.hookReturn,
+        };
+        Object.assign(pageContext, pageContextFromHook);
+        // Execute +onData
+        if (!pageContext.isClientSideNavigation) {
+            await execHookServer('onData', pageContext);
+        }
+    }
+    const res = await execHookServer('onBeforeRender', pageContext);
+    const onBeforeRenderHook = res[0]; // TO-DO/soon/cumulative-hooks: support cumulative
+    if (onBeforeRenderHook) {
+        const { hookReturn } = onBeforeRenderHook;
+        assertOnBeforeRenderHookReturn(hookReturn, onBeforeRenderHook.hookFilePath);
+        const pageContextFromHook = hookReturn?.pageContext;
+        Object.assign(pageContext, pageContextFromHook);
+    }
+}

package/dist/server/runtime/renderPageServer/execHookOnError.d.ts

@@ -0,0 +1,3 @@
+export { execHookOnError };
+import type { PageContext_logRuntime } from '../loggerRuntime.js';
+declare function execHookOnError(err: unknown, pageContext: PageContext_logRuntime): void;

package/dist/server/runtime/renderPageServer/execHookOnError.js

@@ -0,0 +1,26 @@
+export { execHookOnError };
+import { isObject, getGlobalObject } from '../../utils.js';
+import { getGlobalContextServerInternalOptional } from '../globalContext.js';
+import { getHookFromPageConfigGlobalCumulative } from '../../../shared-server-client/hooks/getHook.js';
+const globalObject = getGlobalObject('renderPageServer/execHookOnError.ts', {
+    seen: new WeakSet(),
+});
+function execHookOnError(err, pageContext) {
+    if (isObject(err)) {
+        if (globalObject.seen.has(err))
+            return;
+        globalObject.seen.add(err);
+    }
+    const globalContext = getGlobalContextServerInternalOptional();
+    if (!globalContext)
+        return;
+    const hooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onError');
+    for (const hook of hooks) {
+        try {
+            hook.hookFn(err, pageContext);
+        }
+        catch (hookErr) {
+            console.error(hookErr);
+        }
+    }
+}

package/dist/server/runtime/renderPageServer/execHookOnRenderHtml.d.ts

@@ -0,0 +1,24 @@
+export { execHookOnRenderHtml };
+export type { RenderHook };
+import { type HtmlRender } from './html/renderHtml.js';
+import { type Hook } from '../../../shared-server-client/hooks/getHook.js';
+import type { PageAsset } from './getPageAssets.js';
+import { type PageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
+import type { PageContextSerialization } from './html/serializeContext.js';
+import type { GlobalContextServerInternal } from '../globalContext.js';
+type GetPageAssets = () => Promise<PageAsset[]>;
+type RenderHook = Hook & {
+    hookName: HookName;
+};
+type HookName = 'onRenderHtml' | 'render';
+declare function execHookOnRenderHtml(pageContext: PageContextForPublicUsageServer & PageContextSerialization & {
+    pageId: string;
+    _globalContext: GlobalContextServerInternal;
+    __getPageAssets: GetPageAssets;
+    _isHtmlOnly: boolean;
+    _baseServer: string;
+    _requestId: number;
+}): Promise<{
+    renderHook: RenderHook;
+    htmlRender: HtmlRender;
+}>;

package/dist/server/runtime/renderPageServer/execHookOnRenderHtml.js

@@ -0,0 +1,115 @@
+export { execHookOnRenderHtml };
+import { isDocumentHtml, renderDocumentHtml, dangerouslySkipEscape, } from './html/renderHtml.js';
+import { getHookFromPageContext } from '../../../shared-server-client/hooks/getHook.js';
+import { assert, assertUsage, assertWarning, isObject, objectAssign, isPromise, isCallable } from '../../utils.js';
+import { isStream } from './html/stream.js';
+import { assertPageContextProvidedByUser } from '../../../shared-server-client/assertPageContextProvidedByUser.js';
+import { preparePageContextForPublicUsageServer, } from './preparePageContextForPublicUsageServer.js';
+import { assertHookReturnedObject } from '../../../shared-server-client/assertHookReturnedObject.js';
+import { logRuntimeError } from '../loggerRuntime.js';
+import pc from '@brillout/picocolors';
+import { execHookDirectSingleWithReturn } from '../../../shared-server-client/hooks/execHook.js';
+async function execHookOnRenderHtml(pageContext) {
+    const hook = getRenderHook(pageContext);
+    objectAssign(pageContext, { _renderHook: hook });
+    const { hookReturn } = await execHookDirectSingleWithReturn(hook, pageContext, preparePageContextForPublicUsageServer);
+    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
+    Object.assign(pageContext, pageContextProvidedByRenderHook);
+    objectAssign(pageContext, { _pageContextPromise: pageContextPromise });
+    const onErrorWhileStreaming = (err) => {
+        // Should the stream inject the following?
+        // ```
+        // <script>console.error("An error occurred on the server side while streaming the page to HTML, see server logs.")</script>
+        // ```
+        logRuntimeError(err, pageContext);
+        if (!pageContext.errorWhileRendering) {
+            pageContext.errorWhileRendering = err;
+        }
+    };
+    const htmlRender = await renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreaming, injectFilter);
+    assert(typeof htmlRender === 'string' || isStream(htmlRender));
+    return { htmlRender, renderHook: hook };
+}
+function getRenderHook(pageContext) {
+    let hookFound;
+    {
+        let hook;
+        let hookName = undefined;
+        hook = getHookFromPageContext(pageContext, 'onRenderHtml');
+        if (hook) {
+            hookName = 'onRenderHtml';
+        }
+        else {
+            hook = getHookFromPageContext(pageContext, 'render');
+            if (hook) {
+                hookName = 'render';
+            }
+        }
+        if (hook) {
+            assert(hookName);
+            const { hookFilePath, hookFn, hookTimeout } = hook;
+            hookFound = { hookFn, hookFilePath, hookName, hookTimeout };
+        }
+    }
+    if (!hookFound) {
+        const hookName = pageContext._globalContext._pageConfigs.length > 0 ? 'onRenderHtml' : 'render';
+        assertUsage(false, `No ${hookName}() hook found, see https://vike.dev/${hookName}`);
+    }
+    return hookFound;
+}
+function processHookReturnValue(hookReturnValue, renderHook) {
+    let documentHtml;
+    let pageContextPromise = null;
+    let pageContextProvidedByRenderHook = null;
+    let injectFilter = null;
+    if (isDocumentHtml(hookReturnValue)) {
+        documentHtml = hookReturnValue;
+        return { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter };
+    }
+    const errPrefix = `The ${renderHook.hookName}() hook defined at ${renderHook.hookFilePath}`;
+    const errSuffix = `a string generated with ${pc.cyan('escapeInject`<html>...</html>`')} or the value returned by ${pc.cyan('dangerouslySkipEscape()')}, see https://vike.dev/escapeInject`;
+    if (typeof hookReturnValue === 'string') {
+        assertWarning(false, [
+            errPrefix,
+            `returned a plain JavaScript string which is ${pc.red(pc.bold('dangerous'))}: it should instead return`,
+            errSuffix,
+        ].join(' '), { onlyOnce: true });
+        hookReturnValue = dangerouslySkipEscape(hookReturnValue);
+    }
+    const wrongReturnValue = `should return the value ${pc.cyan('documentHtml')} or an object ${pc.cyan('{ documentHtml }')} where ${pc.cyan('documentHtml')} is ${errSuffix}`;
+    assertUsage(isObject(hookReturnValue), `${errPrefix} ${wrongReturnValue}`);
+    assertHookReturnedObject(hookReturnValue, ['documentHtml', 'pageContext', 'injectFilter'], errPrefix);
+    assertUsage(hookReturnValue.documentHtml, `${errPrefix} returned an object that is missing the ${pc.code('documentHtml')} property: it ${wrongReturnValue}`);
+    if (hookReturnValue.injectFilter) {
+        assertUsage(isCallable(hookReturnValue.injectFilter), 'injectFilter should be a function');
+        injectFilter = hookReturnValue.injectFilter;
+    }
+    {
+        let val = hookReturnValue.documentHtml;
+        const errBegin = `${errPrefix} returned ${pc.cyan('{ documentHtml }')}, but ${pc.cyan('documentHtml')}`;
+        if (typeof val === 'string') {
+            assertWarning(false, [
+                errBegin,
+                `is a plain JavaScript string which is ${pc.bold(pc.red('dangerous'))}: ${pc.cyan('documentHtml')} should be`,
+                errSuffix,
+            ].join(' '), { onlyOnce: true });
+            val = dangerouslySkipEscape(val);
+        }
+        assertUsage(isDocumentHtml(val), [errBegin, 'should be', errSuffix].join(' '));
+        documentHtml = val;
+    }
+    if (hookReturnValue.pageContext) {
+        const val = hookReturnValue.pageContext;
+        const errBegin = `${errPrefix} returned ${pc.cyan('{ pageContext }')}, but ${pc.cyan('pageContext')}`;
+        if (isPromise(val) || isCallable(val)) {
+            assertWarning(!isPromise(val), `${errBegin} is a promise which is deprecated in favor of async functions, see https://vike.dev/streaming#initial-data-after-stream-end`, { onlyOnce: true });
+            pageContextPromise = val;
+        }
+        else {
+            assertUsage(isObject(val), `${errBegin} should be an object or an async function, see https://vike.dev/streaming#initial-data-after-stream-end`);
+            assertPageContextProvidedByUser(val, renderHook);
+            pageContextProvidedByRenderHook = val;
+        }
+    }
+    return { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter };
+}

package/dist/server/runtime/renderPageServer/execHookServer.d.ts

@@ -0,0 +1,12 @@
+export { execHookServer };
+export type { PageContextExecHookServer };
+import { type PageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
+import type { PageContextConfig } from '../../../shared-server-client/getPageFiles.js';
+import type { HookName } from '../../../types/Config.js';
+type PageContextExecHookServer = PageContextConfig & PageContextForPublicUsageServer;
+declare function execHookServer(hookName: HookName, pageContext: PageContextExecHookServer): Promise<(import("../../../shared-server-client/hooks/getHook.js").HookLoc & {
+    hookFn: (arg: import("../../../shared-server-client/preparePageContextForPublicUsage.js").PageContextPrepareMinimum, ...rest: unknown[]) => unknown;
+    hookTimeout: import("../../../shared-server-client/hooks/getHook.js").HookTimeout;
+} & {
+    hookReturn: unknown;
+})[]>;

package/dist/server/runtime/renderPageServer/execHookServer.js

@@ -0,0 +1,6 @@
+export { execHookServer };
+import { execHook } from '../../../shared-server-client/hooks/execHook.js';
+import { preparePageContextForPublicUsageServer, } from './preparePageContextForPublicUsageServer.js';
+async function execHookServer(hookName, pageContext) {
+    return await execHook(hookName, pageContext, preparePageContextForPublicUsageServer);
+}

package/dist/server/runtime/renderPageServer/getCacheControl.js

@@ -0,0 +1,21 @@
+export { getCacheControl };
+export { cacheControlDisable };
+import { getPageConfig } from '../../../shared-server-client/page-configs/helpers.js';
+import { getConfigValueRuntime } from '../../../shared-server-client/page-configs/getConfigValueRuntime.js';
+const cacheControlDisable = 'no-store, max-age=0';
+function getCacheControl(pageId, pageConfigs) {
+    // TO-DO/next-major-release: remove this line
+    if (pageConfigs.length === 0)
+        return cacheControlDisable;
+    if (pageId) {
+        const pageConfig = getPageConfig(pageId, pageConfigs);
+        const configValue = getConfigValueRuntime(pageConfig, 'cacheControl', 'string');
+        const value = configValue?.value;
+        if (value)
+            return value;
+    }
+    // - Disabling caching by default is the safest strategy, because caching is problematic with authentication as described in https://github.com/vikejs/vike/issues/1275#issuecomment-1824366875
+    // - Are there use cases when we don't need to disable caching?
+    //   - When there isn't any <script id="vike_pageContext" type="application/json"> then we can safely have caching. (We don't implement this exception because we're lazy and it's quite a rare situation.)
+    return cacheControlDisable;
+}

package/dist/server/runtime/renderPageServer/getHttpResponseBody.js

@@ -0,0 +1,132 @@
+export { getHttpResponseBody };
+export { getHttpResponseBodyStreamHandlers };
+import { isStream, getStreamName, inferStreamName, isStreamWritableWeb, isStreamWritableNode, isStreamReadableWeb, isStreamReadableNode, isStreamPipeWeb, isStreamPipeNode, getStreamReadableNode, getStreamReadableWeb, pipeToStreamWritableWeb, pipeToStreamWritableNode, } from './html/stream.js';
+import { assert, assertUsage, assertWarning } from '../../utils.js';
+import { getHtmlString } from './html/renderHtml.js';
+import pc from '@brillout/picocolors';
+const streamDocs = 'See https://vike.dev/streaming for more information.';
+function getHttpResponseBody(htmlRender, renderHook) {
+    if (typeof htmlRender !== 'string') {
+        assertUsage(false, getErrMsg(htmlRender, renderHook, 'body', `Use ${pc.cyan('pageContext.httpResponse.pipe()')} instead`));
+    }
+    const body = htmlRender;
+    return body;
+}
+function getHttpResponseBodyStreamHandlers(htmlRender, renderHook) {
+    return {
+        pipe(writable) {
+            const getErrMsgMixingStreamTypes = (writableType) => `The ${getErrMsgBody(htmlRender, renderHook)} while a ${writableType} was passed to pageContext.httpResponse.pipe() which is contradictory. You cannot mix a Web Stream with a Node.js Stream.`;
+            if (isStreamWritableWeb(writable)) {
+                const success = pipeToStreamWritableWeb(htmlRender, writable);
+                if (success) {
+                    return;
+                }
+                else {
+                    assert(isStreamReadableNode(htmlRender) || isStreamPipeNode(htmlRender));
+                    assertUsage(false, getErrMsgMixingStreamTypes('Web Writable'));
+                }
+            }
+            if (isStreamWritableNode(writable)) {
+                const success = pipeToStreamWritableNode(htmlRender, writable);
+                if (success) {
+                    return;
+                }
+                else {
+                    assert(isStreamReadableWeb(htmlRender) || isStreamPipeWeb(htmlRender));
+                    assertUsage(false, getErrMsgMixingStreamTypes('Node.js Writable'));
+                }
+            }
+            assertUsage(false, `The argument ${pc.cyan('writable')} passed to ${pc.cyan('pageContext.httpResponse.pipe(writable)')} doesn't seem to be ${getStreamName('writable', 'web')} nor ${getStreamName('writable', 'node')}.`);
+        },
+        getReadableWebStream() {
+            const webStream = getStreamReadableWeb(htmlRender);
+            if (webStream === null) {
+                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getReadableWebStream()', getFixMsg('readable', 'web')));
+            }
+            return webStream;
+        },
+        async getReadableNodeStream() {
+            const nodeStream = await getStreamReadableNode(htmlRender);
+            if (nodeStream === null) {
+                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getReadableNodeStream()', getFixMsg('readable', 'node')));
+            }
+            return nodeStream;
+        },
+        async getBody() {
+            const body = await getHtmlString(htmlRender);
+            return body;
+        },
+        // TO-DO/next-major-release: remove
+        async getNodeStream() {
+            assertWarning(false, '`pageContext.httpResponse.getNodeStream()` is outdated, use `pageContext.httpResponse.getReadableNodeStream()` instead. ' +
+                streamDocs, { onlyOnce: true, showStackTrace: true });
+            const nodeStream = await getStreamReadableNode(htmlRender);
+            if (nodeStream === null) {
+                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getNodeStream()', getFixMsg('readable', 'node')));
+            }
+            return nodeStream;
+        },
+        // TO-DO/next-major-release: remove
+        getWebStream() {
+            assertWarning(false, '`pageContext.httpResponse.getWebStream(res)` is outdated, use `pageContext.httpResponse.getReadableWebStream(res)` instead. ' +
+                streamDocs, { onlyOnce: true, showStackTrace: true });
+            const webStream = getStreamReadableWeb(htmlRender);
+            if (webStream === null) {
+                assertUsage(false, getErrMsg(htmlRender, renderHook, 'getWebStream()', getFixMsg('readable', 'web')));
+            }
+            return webStream;
+        },
+        // TO-DO/next-major-release: remove
+        pipeToWebWritable(writable) {
+            assertWarning(false, '`pageContext.httpResponse.pipeToWebWritable(res)` is outdated, use `pageContext.httpResponse.pipe(res)` instead. ' +
+                streamDocs, { onlyOnce: true, showStackTrace: true });
+            const success = pipeToStreamWritableWeb(htmlRender, writable);
+            if (!success) {
+                assertUsage(false, getErrMsg(htmlRender, renderHook, 'pipeToWebWritable()'));
+            }
+        },
+        // TO-DO/next-major-release: remove
+        pipeToNodeWritable(writable) {
+            assertWarning(false, '`pageContext.httpResponse.pipeToNodeWritable(res)` is outdated, use `pageContext.httpResponse.pipe(res)` instead. ' +
+                streamDocs, { onlyOnce: true, showStackTrace: true });
+            const success = pipeToStreamWritableNode(htmlRender, writable);
+            if (!success) {
+                assertUsage(false, getErrMsg(htmlRender, renderHook, 'pipeToNodeWritable()'));
+            }
+        },
+    };
+    function getFixMsg(kind, type) {
+        const streamName = getStreamName(kind, type);
+        assert(['a ', 'an ', 'the '].some((s) => streamName.startsWith(s)));
+        assert(renderHook);
+        const { hookFilePath, hookName } = renderHook;
+        return `Make sure the ${hookName}() hook defined by ${hookFilePath} provides ${streamName} instead`;
+    }
+}
+function getErrMsg(htmlRender, renderHook, method, msgAddendum) {
+    assert(!msgAddendum || !msgAddendum.endsWith('.'));
+    const errMsgBody = getErrMsgBody(htmlRender, renderHook);
+    return [`pageContext.httpResponse.${method} can't be used because the ${errMsgBody}`, msgAddendum, streamDocs]
+        .filter(Boolean)
+        .join('. ');
+}
+function getErrMsgBody(htmlRender, renderHook) {
+    assert(renderHook);
+    const { hookFilePath, hookName } = renderHook;
+    const hookReturnType = getHookReturnType(htmlRender);
+    assert(['a ', 'an ', 'the '].some((s) => hookReturnType.startsWith(s)));
+    const errMsgBody = `${hookName}()\ hook defined by ${hookFilePath} provides ${hookReturnType}`;
+    assert(!errMsgBody.endsWith(' '));
+    return errMsgBody;
+}
+function getHookReturnType(htmlRender) {
+    if (typeof htmlRender === 'string') {
+        return 'an HTML string';
+    }
+    else if (isStream(htmlRender)) {
+        return inferStreamName(htmlRender);
+    }
+    else {
+        assert(false);
+    }
+}