vike 0.4.247-commit-903de25 → 0.4.247-commit-c3d567b

package/dist/server/runtime/logErrorServer.js

@@ -0,0 +1,62 @@
+export { logErrorServer };
+export { hasAlreadyLogged };
+import pc from '@brillout/picocolors';
+import { assertIsNotBrowser, assertWarning, getGlobalObject, hasRed, isDebugError, isObject } from '../utils.js';
+import { execHookOnError } from './renderPageServer/execHookOnError.js';
+import { assertPageContext_logRuntime } from './loggerRuntime.js';
+import { addErrorHint } from './renderPageServer/addErrorHint.js';
+import { isAbortError } from '../../shared-server-client/route/abort.js';
+assertIsNotBrowser();
+const globalObject = getGlobalObject('server/runtime/logErrorServer.ts', {
+    wasAlreadyLogged: new WeakSet(),
+});
+function logErrorServer(err, pageContext) {
+    assertPageContext_logRuntime(pageContext);
+    if (isAbortError(err) && !isDebugError())
+        return;
+    // I don't think there is a use case for printing the same error object twice? Reloading page throwing error => the same error is printed a second time but it's a different error object.
+    if (hasAlreadyLogged(err))
+        return;
+    warnIfErrorIsNotObject(err);
+    const errBetter = addErrorHint(err);
+    execHookOnError(errBetter, pageContext);
+    const errPrinted = getStackOrMessage(isDebugError() ? getOriginalError(errBetter) : errBetter);
+    console.error(hasRed(errPrinted) ? errPrinted : pc.red(errPrinted));
+    setAlreadyLogged(err);
+}
+function getOriginalError(err) {
+    // getOriginalError() is set by getBetterError()
+    // https://github.com/vikejs/vike/blob/c0dc090e64ca9daa516ebf884fef66f5531cae69/packages/vike/utils/getBetterError.ts#L32
+    return err?.getOriginalError?.() ?? err;
+}
+// We ensure we print a string; Cloudflare Workers doesn't seem to properly stringify `Error` objects.
+// - TO-DO/eventually: is that still true? Let's eventually remove it and see if it crashes Cloudflare.
+function getStackOrMessage(err) {
+    if (!isObject(err) || !err.stack)
+        return String(err);
+    if (err.hideStack)
+        return err.message;
+    return err.stack;
+}
+// It would be cleaner to:
+//  - Call assertUsageErrorIsObject() right after calling the user's hook
+//    - Attach the original error: assertUsageError.originalErrorValue = err
+//      - Show the original error in Vike's error handling
+//  - Use assertErrorIsObject() throughout Vike's source code
+function warnIfErrorIsNotObject(err) {
+    if (!isObject(err)) {
+        console.warn('[vike] The thrown value is:');
+        console.warn(err);
+        assertWarning(false, `One of your hooks threw an error ${pc.cyan('throw someValue')} but ${pc.cyan('someValue')} isn't an object (it's ${pc.cyan(`typeof someValue === ${typeof err}`)} instead). Make sure thrown values are always wrapped with ${pc.cyan('new Error()')}, in other words: ${pc.cyan('throw someValue')} should be replaced with ${pc.cyan('throw new Error(someValue)')}. The thrown value is printed above.`, { onlyOnce: false });
+    }
+}
+function hasAlreadyLogged(err) {
+    if (!isObject(err))
+        return false;
+    return globalObject.wasAlreadyLogged.has(err);
+}
+function setAlreadyLogged(err) {
+    if (!isObject(err))
+        return;
+    globalObject.wasAlreadyLogged.add(err);
+}

package/dist/server/runtime/loggerRuntime.d.ts

@@ -0,0 +1,13 @@
+export declare let logRuntimeError: LogRuntimeError;
+export declare let logRuntimeInfo: LogRuntimeInfo | null | LogRuntimeInfo;
+export { setLogRuntimeDev };
+export { assertPageContext_logRuntime };
+export type { PageContext_logRuntime };
+import type { LogType } from '../../node/vite/shared/loggerDev.js';
+type LogRuntimeInfo = (msg: string, pageContext: PageContext_logRuntime, logType: LogType) => void;
+type LogRuntimeError = (err: unknown, pageContext: PageContext_logRuntime) => void;
+type PageContext_logRuntime = null | {
+    _requestId: number;
+};
+declare function setLogRuntimeDev(logRuntimeErrorDev: LogRuntimeError, logRuntimeInfoDev: LogRuntimeInfo): void;
+declare function assertPageContext_logRuntime(pageContext: PageContext_logRuntime): void;

package/dist/server/runtime/loggerRuntime.js

@@ -0,0 +1,20 @@
+// Logger used by the the server runtime. (Also during pre-rendering since it uses the sever runtime.)
+export let logRuntimeError;
+export let logRuntimeInfo = null; // is `null` in production
+export { setLogRuntimeDev };
+export { assertPageContext_logRuntime };
+import { loggRuntimeErrorProd } from './renderPageServer/loggerProd.js';
+import { assert } from '../utils.js';
+// Set production logger (which is overwritten by loggerDev.ts in non-production environments such as development and during pre-rendering)
+logRuntimeError =
+    // @ts-expect-error
+    logRuntimeError ??
+        // Default
+        loggRuntimeErrorProd;
+function setLogRuntimeDev(logRuntimeErrorDev, logRuntimeInfoDev) {
+    logRuntimeError = logRuntimeErrorDev;
+    logRuntimeInfo = logRuntimeInfoDev;
+}
+function assertPageContext_logRuntime(pageContext) {
+    assert(pageContext === null || typeof pageContext._requestId === 'number');
+}

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

@@ -0,0 +1,4 @@
+export { addErrorHint };
+export { getErrorHint };
+declare function addErrorHint(error: unknown): unknown;
+declare function getErrorHint(error: unknown): "The error could be a CJS/ESM issue, see https://vike.dev/broken-npm-package" | `To fix this error, see ${string}` | null;

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

@@ -0,0 +1,197 @@
+export { addErrorHint };
+// For ./addErrorHint/getErrorHint.spec.ts
+export { getErrorHint };
+import { assert, formatHintLog, getBetterError, isObject } from '../../utils.js';
+import pc from '@brillout/picocolors';
+const hintDefault = 'The error could be a CJS/ESM issue, see https://vike.dev/broken-npm-package';
+const hintLinkPrefix = 'To fix this error, see ';
+const errorsMisc = [
+    {
+        errMsg: 'window is not defined',
+        link: 'https://vike.dev/hints#window-is-not-defined',
+        mustMentionNodeModules: false,
+    },
+    {
+        errMsg: 'jsxDEV is not a function',
+        link: 'https://github.com/vikejs/vike/issues/1469#issuecomment-1919518096',
+        mustMentionNodeModules: false,
+    },
+    {
+        // ```
+        // Error [RollupError]: Could not resolve "../dist/client/assets.json" from "renderer/+onRenderHtml.tsx"
+        // ```
+        errMsg: 'assets.json',
+        link: 'https://vike.dev/getGlobalContext',
+        mustMentionNodeModules: false,
+    },
+    {
+        errMsg: 'ERR_UNKNOWN_FILE_EXTENSION',
+        link: 'https://vike.dev/broken-npm-package#err-unknown-file-extension',
+    },
+];
+const reactInvalidEelement = 'https://vike.dev/broken-npm-package#react-invalid-component';
+const errorsReact = [
+    {
+        errMsg: 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components)',
+        link: reactInvalidEelement,
+        // The stack trace can be user-land while the import is coming from node_modules
+        mustMentionNodeModules: false,
+    },
+    {
+        errMsg: 'Objects are not valid as a React child',
+        link: reactInvalidEelement,
+        mustMentionNodeModules: false,
+    },
+    {
+        // React's "Invalid hook call.", see https://github.com/vikejs/vike/discussions/1637#discussioncomment-9424712
+        errMsg: "Cannot read properties of null (reading 'useContext')",
+    },
+];
+const errorsCjsEsm_withPreciseLink = [
+    {
+        // `SyntaxError: Named export '${exportName}' not found. The requested module '${packageName}' is a CommonJS module, which may not support all module.exports as named exports.`
+        errMsg: /Named export.*not found/i,
+        link: 'https://vike.dev/broken-npm-package#named-export-not-found',
+        // It seems that this always points to an npm package import.
+        mustMentionNodeModules: false,
+    },
+];
+const errorsCjsEsm = [
+    { errMsg: 'ERR_UNSUPPORTED_DIR_IMPORT' },
+    { errMsg: 'ERR_REQUIRE_ESM' },
+    { errMsg: 'Must use import' },
+    { errMsg: /Cannot find \S+ '(\S+)' imported from (\S+)/ },
+    { errMsg: 'ERR_UNKNOWN_FILE_EXTENSION' },
+    { errMsg: /Unknown file extension "\S+" for (\S+)/ },
+    // `SyntaxError: Cannot use import statement outside a module`.
+    {
+        errMsg: 'Cannot use import statement',
+        // Since user code is always ESM, this error must always originate from an npm package.
+        mustMentionNodeModules: false,
+    },
+    { errMsg: 'is not exported' },
+    { errMsg: 'Cannot read properties of undefined' },
+    { errMsg: '.default is not' },
+    // Using CJS inside ESM modules.
+    { errMsg: 'require is not a function' },
+    { errMsg: 'exports is not defined' },
+    { errMsg: 'module is not defined' },
+    { errMsg: 'not defined in ES' },
+    { errMsg: "Unexpected token 'export'" },
+    { errMsg: 'Failed to resolve entry for package' },
+];
+function addErrorHint(error) {
+    /* Collect errors for ./addErrorHint.spec.ts
+    collectError(error)
+    //*/
+    const hint = getErrorHint(error);
+    if (!hint)
+        return error;
+    const append = `\n${pc.bold(formatHintLog(hint))}`;
+    return getBetterError(error, { message: { append } });
+}
+function getErrorHint(error) {
+    {
+        const knownErr = isKnownError(error);
+        if (knownErr) {
+            if (knownErr.link) {
+                return `${hintLinkPrefix}${knownErr.link}`;
+            }
+            else {
+                return hintDefault;
+            }
+        }
+    }
+    return null;
+}
+function isKnownError(error) {
+    const anywhere = getAnywhere(error);
+    const knownErr = [
+        //
+        ...errorsMisc,
+        ...errorsReact,
+        ...errorsCjsEsm_withPreciseLink,
+        ...errorsCjsEsm,
+    ].find((knownError) => {
+        if (!includesLowercase(anywhere, knownError.errMsg))
+            return false;
+        if (knownError.mustMentionNodeModules !== false && !includesLowercase(anywhere, 'node_modules'))
+            return false;
+        return true;
+    });
+    if (!knownErr)
+        return false;
+    return knownErr;
+}
+function includesLowercase(str, substr) {
+    if (substr instanceof RegExp) {
+        let { flags } = substr;
+        if (!flags.includes('i'))
+            flags += 'i';
+        const regex = new RegExp(substr.source, flags);
+        return regex.test(str);
+    }
+    if (typeof substr === 'string') {
+        return str.toLowerCase().includes(substr.toLowerCase());
+    }
+    assert(false);
+}
+function getAnywhere(error) {
+    const code = getErrCode(error);
+    const message = getErrMessage(error);
+    const stack = getErrStack(error);
+    const anywhere = [code, message, stack].filter(Boolean).join('\n');
+    return anywhere;
+}
+function getErrMessage(err) {
+    if (!isObject(err))
+        return null;
+    if (!err.message)
+        return null;
+    if (typeof err.message !== 'string')
+        return null;
+    return err.message;
+}
+function getErrCode(err) {
+    if (!isObject(err))
+        return null;
+    if (!err.code)
+        return null;
+    if (typeof err.code !== 'string')
+        return null;
+    return err.code;
+}
+function getErrStack(err) {
+    if (!isObject(err))
+        return null;
+    if (!err.stack)
+        return null;
+    if (typeof err.stack !== 'string')
+        return null;
+    return err.stack;
+}
+/*
+function collectError(err: any) {
+  console.log(
+    [
+      '{',
+      `  message: ${JSON.stringify(err.message)},`,
+      `  code: ${JSON.stringify(err.code)},`,
+      '  stack: `\n' + err.stack + '\n`',
+      '}',
+    ].join('\n'),
+  )
+  // For reproductions using older vite-plugin-ssr versions, do one of the following.
+  //  - If upon pre-rendering:https: //github.com/brillout/repro_node-syntax-error#error-catched-by-vite-plugin-ssr
+  //  - Inject the logger inside `catch` in node_modules/vite-plugin-ssr/dist/server/runtime/renderPageServer.js
+  //  - Inject the following inside `configResolved(config_)` at node_modules/vite-plugin-ssr/dist/cjs/node/vite/plugins/pluginDev/index.js
+  //    ```js
+  //    config_.logger.error = (msg, options) => {
+  //      const { error } = options;
+  //      if (error) return;
+  //      console.log(...);
+  //    };
+  //    ```
+  //
+}
+//*/

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

@@ -0,0 +1,7 @@
+export { analyzePage };
+import type { PageConfigRuntime } from '../../../types/PageConfig.js';
+import { type AnalysisResult } from '../../../shared-server-client/getPageFiles/analyzePageClientSide.js';
+import type { PageContext_loadPageConfigsLazyServerSide } from './loadPageConfigsLazyServerSide.js';
+declare function analyzePage(pageContext: PageContext_loadPageConfigsLazyServerSide & {
+    _pageConfig: null | PageConfigRuntime;
+}): AnalysisResult;

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

@@ -0,0 +1,69 @@
+export { analyzePage };
+import { getVikeClientEntry } from '../../../shared-server-client/getPageFiles/analyzePageClientSide/determineClientEntry.js';
+import { analyzePageClientSide, } from '../../../shared-server-client/getPageFiles/analyzePageClientSide.js';
+import { generateVirtualFileId } from '../../../shared-server-node/virtualFileId.js';
+import { analyzeClientSide } from '../../../shared-server-client/getPageFiles/analyzeClientSide.js';
+import { getConfigValueRuntime } from '../../../shared-server-client/page-configs/getConfigValueRuntime.js';
+function analyzePage(pageContext) {
+    const { pageId, _pageConfig: pageConfig, _globalContext: globalContext } = pageContext;
+    const { _pageFilesAll: pageFilesAll } = globalContext;
+    if (pageConfig) {
+        const { isClientRuntimeLoaded, isClientRouting } = analyzeClientSide(pageConfig, pageFilesAll, pageId);
+        const clientEntries = [];
+        const clientFilePath = getConfigValueRuntime(pageConfig, 'client', 'string')?.value ?? null;
+        if (clientFilePath)
+            clientEntries.push(clientFilePath);
+        if (isClientRuntimeLoaded)
+            clientEntries.push(getVikeClientEntry(isClientRouting));
+        const clientDependencies = [];
+        clientDependencies.push({
+            id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, isForClientSide: true }),
+            onlyAssets: isClientRuntimeLoaded ? false : true,
+            eagerlyImported: false,
+        });
+        // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
+        if (!globalContext._isProduction) {
+            clientDependencies.push({
+                id: generateVirtualFileId({ type: 'page-entry', pageId: pageConfig.pageId, isForClientSide: false }),
+                onlyAssets: true,
+                eagerlyImported: false,
+            });
+        }
+        /* Remove?
+        Object.values(pageConfig.configElements).forEach((configElement) => {
+          if (configElement.importPath) {
+            const { env } = configElement
+            assert(env)
+            const onlyAssets = env === { server: true }
+            const eagerlyImported = env === { server: true, client: 'if-client-routing', eager: true }
+            if (onlyAssets || eagerlyImported) {
+              clientDependencies.push({
+                id: configElement.importPath,
+                onlyAssets,
+                eagerlyImported
+              })
+            }
+          }
+        })
+        */
+        clientEntries.forEach((clientEntry) => {
+            clientDependencies.push({
+                id: clientEntry,
+                onlyAssets: false,
+                eagerlyImported: false,
+            });
+        });
+        return {
+            isHtmlOnly: !isClientRuntimeLoaded,
+            isClientRouting,
+            clientEntries,
+            clientDependencies,
+            // pageFilesClientSide and pageFilesServerSide are only used for debugging
+            pageFilesClientSide: [],
+            pageFilesServerSide: [],
+        };
+    }
+    else {
+        return analyzePageClientSide(pageFilesAll, pageId);
+    }
+}

package/dist/server/runtime/renderPageServer/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 = `${pc.code('renderPage(pageContextInit)')} (https://vike.dev/renderPage)`;
+    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} called with ${len} arguments but renderPage() accepts only one argument.'`, {
+        showStackTrace: true,
+    });
+    assertUsage(isObject(pageContextInit), `${prefix} called with ${pc.code(`typeof pageContextInit === ${JSON.stringify(typeof pageContextInit)}`)} but ${pc.code('pageContextInit')} should be an object.`, { showStackTrace: true });
+    // TO-DO/next-major-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/server/runtime/renderPageServer/createHttpResponse/assertNoInfiniteHttpRedirect.js

@@ -0,0 +1,46 @@
+export { assertNoInfiniteHttpRedirect };
+import { assert, assertUsage, getGlobalObject, removeUrlOrigin } from '../../../utils.js';
+import pc from '@brillout/picocolors';
+const globalObject = getGlobalObject('createHttpResponse/assertNoInfiniteHttpRedirect.ts', {
+    redirectGraph: {},
+});
+function assertNoInfiniteHttpRedirect(
+// The exact URL that the user will be redirected to.
+// - It includes the Base URL as well as the locale (i18n) base.
+urlRedirectTarget, 
+// Rationale for checking against `pageContextInit.urlOriginal`: https://github.com/vikejs/vike/pull/2264#issuecomment-2713890263
+pageContextInit) {
+    // TO-DO/eventually: use cookie as described at https://github.com/vikejs/vike/pull/2273
+    if (true)
+        return 'DISABLED'; // Disabled until we make it reliable.
+    if (!urlRedirectTarget.startsWith('/')) {
+        // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (at least not in itself).
+        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin; we hope/assume the user sets the URL without origin.
+        //    ```js
+        //    // For same-origin, the user usually/hopefully passes a URL without origin
+        //    renderPage({ urlOriginal: '/some/pathname' })
+        //    ```
+        return;
+    }
+    const urlOriginalNormalized = removeUrlOrigin(pageContextInit.urlOriginal).urlModified;
+    assert(urlOriginalNormalized.startsWith('/'));
+    const graph = copy(globalObject.redirectGraph);
+    graph[urlRedirectTarget] ?? (graph[urlRedirectTarget] = new Set());
+    graph[urlRedirectTarget].add(urlOriginalNormalized);
+    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 validate(G) {
+    Object.keys(G).forEach((n) => check(G, n, []));
+}
+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]));
+}

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

@@ -0,0 +1,40 @@
+export { createHttpResponsePage };
+export { createHttpResponsePageContextJson };
+export { createHttpResponseErrorFallback };
+export { createHttpResponseErrorFallback_noGlobalContext };
+export { createHttpResponseRedirect };
+export { createHttpResponse404 };
+export { createHttpResponseBaseIsMissing };
+export type { HttpResponse };
+import type { GetPageAssets } from './getPageAssets.js';
+import type { HtmlRender } from './html/renderHtml.js';
+import type { RenderHook } from './execHookOnRenderHtml.js';
+import type { RedirectStatusCode, AbortStatusCode, UrlRedirect } from '../../../shared-server-client/route/abort.js';
+import { HttpResponseBody } from './getHttpResponseBody.js';
+import { type EarlyHint } from './getEarlyHints.js';
+import type { PageContextBegin } from '../renderPageServer.js';
+import type { GlobalContextServerInternal } from '../globalContext.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 createHttpResponsePage(htmlRender: HtmlRender, renderHook: null | RenderHook, pageContext: {
+    pageId: null | string;
+    is404: null | boolean;
+    errorWhileRendering: null | Error;
+    __getPageAssets: GetPageAssets;
+    _globalContext: GlobalContextServerInternal;
+    abortStatusCode?: AbortStatusCode;
+    headersResponse?: Headers;
+}): Promise<HttpResponse>;
+declare function createHttpResponse404(errMsg404: string): HttpResponse;
+declare function createHttpResponseBaseIsMissing(urlOriginal: string, baseServer: string): HttpResponse;
+declare function createHttpResponseErrorFallback(pageContext: {
+    _globalContext: GlobalContextServerInternal;
+}): HttpResponse;
+declare function createHttpResponseErrorFallback_noGlobalContext(): HttpResponse;
+declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
+declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, pageContextInit: PageContextBegin): HttpResponse;

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

@@ -0,0 +1,112 @@
+export { createHttpResponsePage };
+export { createHttpResponsePageContextJson };
+export { createHttpResponseErrorFallback };
+export { createHttpResponseErrorFallback_noGlobalContext };
+export { createHttpResponseRedirect };
+export { createHttpResponse404 };
+export { createHttpResponseBaseIsMissing };
+import { assert, assertWarning, escapeHtml } from '../../utils.js';
+import { getErrorPageId, isErrorPage } from '../../../shared-server-client/error-page.js';
+import { getHttpResponseBody, getHttpResponseBodyStreamHandlers } from './getHttpResponseBody.js';
+import { getEarlyHints } from './getEarlyHints.js';
+import { assertNoInfiniteHttpRedirect } from './createHttpResponse/assertNoInfiniteHttpRedirect.js';
+import { resolveHeadersResponseFinal } from './headersResponse.js';
+async function createHttpResponsePage(htmlRender, renderHook, pageContext) {
+    let statusCode = pageContext.abortStatusCode;
+    if (!statusCode) {
+        const isError = !pageContext.pageId || isErrorPage(pageContext.pageId, pageContext._globalContext._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());
+    const headers = resolveHeadersResponseFinal(pageContext, statusCode);
+    return createHttpResponse(statusCode, 'text/html;charset=utf-8', headers, htmlRender, earlyHints, renderHook);
+}
+function createHttpResponse404(errMsg404) {
+    const httpResponse = createHttpResponse(404, 'text/html;charset=utf-8', [], `<p>${errMsg404}.</p><script>console.log('This HTML was generated by Vike.')</script>`);
+    return httpResponse;
+}
+function createHttpResponseBaseIsMissing(urlOriginal, baseServer) {
+    const httpResponse = createHttpResponse(
+    // We use the error code `500` to signal a failing state because this HTTP response should never be used, see https://vike.dev/base-url#setup
+    // In other words: this HTTP response is expected to be generated but isn't expected to be actually used.
+    500, 'text/html;charset=utf-8', [], `
+<h1>Error: Base URL is missing</h1>
+<p>
+  <a href="https://vike.dev/renderPage"><code>renderPage(pageContextInit)</code></a> called with <code>pageContextInit.urlOriginal===${JSON.stringify(urlOriginal)}</code> which doesn't start with the Base URL <code>${baseServer}</code>.
+</p>
+<p>
+  See <a href="https://vike.dev/base-url#setup">vike.dev/base-url#setup</a> for how to properly setup your server while using a Base URL.
+</p>
+<style>
+  code {
+    font-family: monospace;
+    background-color: #eaeaea;
+    padding: 3px 5px;
+    border-radius: 4px;
+  }
+</style>
+`);
+    return httpResponse;
+}
+function createHttpResponseErrorFallback(pageContext) {
+    const reason = (() => {
+        const errorPageId = getErrorPageId(pageContext._globalContext._pageFilesAll, pageContext._globalContext._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)";
+        }
+        else {
+            return 'no error page (https://vike.dev/error-page) is defined, make sure to create one';
+        }
+    })();
+    return createHttpResponseError_(reason);
+}
+function createHttpResponseErrorFallback_noGlobalContext() {
+    return createHttpResponseError_('no error page (https://vike.dev/error-page) could be rendered');
+}
+function createHttpResponseError_(reason) {
+    const httpResponse = createHttpResponse(500, 'text/html;charset=utf-8', [], `<p>An error occurred.</p><script>console.log(${JSON.stringify(`This HTML was generated by Vike. Vike returned this HTML because ${reason}.`)})</script>`);
+    return httpResponse;
+}
+async function createHttpResponsePageContextJson(pageContextSerialized) {
+    const httpResponse = createHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
+    return httpResponse;
+}
+function createHttpResponseRedirect({ url, statusCode }, pageContextInit) {
+    assertNoInfiniteHttpRedirect(url, pageContextInit);
+    assert(url);
+    assert(statusCode);
+    assert(300 <= statusCode && statusCode <= 399);
+    const headers = [['Location', url]];
+    return createHttpResponse(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 ${escapeHtml(url)}</p><script>console.log('This HTML was generated by Vike.')</script>`);
+}
+function createHttpResponse(statusCode, contentType, headers, htmlRender, earlyHints = [], renderHook = null) {
+    headers.push(['Content-Type', contentType]);
+    assert(renderHook || typeof htmlRender === 'string');
+    return {
+        statusCode,
+        headers,
+        // TO-DO/next-major-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),
+    };
+}