vike 0.4.247-commit-903de25 → 0.4.247-commit-14351e3

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

@@ -1,18 +0,0 @@
-export { logErrorServer };
-import pc from '@brillout/picocolors';
-import { isCallable, isObject } from './utils.js';
-import { execHookOnError } from './renderPage/execHookOnError.js';
-function logErrorServer(err) {
-    execHookOnError(err);
-    // Set by react-streaming
-    // - https://github.com/brillout/react-streaming/blob/0fb5510d0a5a614f577668a519bccd62de40aed8/src/server/renderToStream/common.ts#L59-L62
-    // - https://gist.github.com/brillout/066293a687ab7cf695e62ad867bc6a9c
-    // - It doesn't seem to be needed? (The error Vike receives is already enhanced.) Should we remove this?
-    if (isObject(err) && isCallable(err.getEnhancedError)) {
-        err = err.getEnhancedError(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.
-    const errStr = isObject(err) && 'stack' in err ? String(err.stack) : String(err);
-    console.error(pc.red(errStr));
-}

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

@@ -1,5 +0,0 @@
-export declare let logRuntimeError: LogError;
-export declare let logRuntimeInfo: null | LogInfo;
-export { overwriteRuntimeProductionLogger };
-import type { LogError, LogInfo } from '../vite/shared/loggerNotProd.js';
-declare function overwriteRuntimeProductionLogger(logError_: LogError, logInfo_: LogInfo | null): void;

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

@@ -1,15 +0,0 @@
-// Logger used by the the server runtime. (Also during pre-rendering since it uses the sever runtime.)
-export let logRuntimeError;
-export let logRuntimeInfo = null; // logInfo is null in production
-export { overwriteRuntimeProductionLogger };
-import { logErrorProd } from './renderPage/loggerProd.js';
-// Set production logger (which is overwritten by loggerNotProd.ts in non-production environments such as development and during pre-rendering)
-logRuntimeError =
-    // @ts-expect-error
-    logRuntimeError ??
-        // Default
-        logErrorProd;
-function overwriteRuntimeProductionLogger(logError_, logInfo_) {
-    logRuntimeError = logError_;
-    logRuntimeInfo = logInfo_;
-}

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

@@ -1,27 +0,0 @@
-export { onLoad };
-import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
-import { assertNodeVersion } from '../../utils/assertNodeVersion.js';
-import { setAlwaysShowStackTrace } from '../../utils/assert.js';
-import { installRequireShim } from '@brillout/require-shim';
-import { isErrorDebug } from '../shared/isErrorDebug.js';
-function onLoad() {
-    assertIsNotBrowser();
-    assertNodeVersion();
-    if (isErrorDebug())
-        setAlwaysShowStackTrace();
-    addEcosystemStamp();
-    installRequireShim();
-}
-// Used by:
-// - Telefunc (to detect the user's stack https://github.com/brillout/telefunc/blob/8288310e88e06a42b710d39c39fb502364ca6d30/telefunc/utils/isVikeApp.ts#L4)
-function addEcosystemStamp() {
-    const g = globalThis;
-    g._isVikeApp =
-        /* Don't set to true so that consumers do `!!globalThis._isVikeApp` instead of `globalThis._isVikeApp === true`.
-        true
-        */
-        // We use an object so that we can eventually, in the future, add helpful information as needed. (E.g. the Vike version, or global settings.)
-        {};
-    // We keep the old stamp for older Telefunc versions
-    g._isVitePluginSsr = true;
-}

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

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

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

@@ -1,69 +0,0 @@
-export { analyzePage };
-import { getVikeClientEntry } from '../../../shared/getPageFiles/analyzePageClientSide/determineClientEntry.js';
-import { analyzePageClientSide } from '../../../shared/getPageFiles/analyzePageClientSide.js';
-import { generateVirtualFileId } from '../../shared/virtualFileId.js';
-import { analyzeClientSide } from '../../../shared/getPageFiles/analyzeClientSide.js';
-import { getConfigValueRuntime } from '../../../shared/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/esm/node/runtime/renderPage/assertArguments.js

@@ -1,37 +0,0 @@
-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/esm/node/runtime/renderPage/createHttpResponse/assertNoInfiniteHttpRedirect.js

@@ -1,46 +0,0 @@
-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/esm/node/runtime/renderPage/createHttpResponse.d.ts

@@ -1,40 +0,0 @@
-export { createHttpResponsePage };
-export { createHttpResponsePageContextJson };
-export { createHttpResponseError };
-export { createHttpResponseErrorWithoutGlobalContext };
-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/route/abort.js';
-import { HttpResponseBody } from './getHttpResponseBody.js';
-import { type EarlyHint } from './getEarlyHints.js';
-import type { PageContextBegin } from '../renderPage.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 createHttpResponseError(pageContext: {
-    _globalContext: GlobalContextServerInternal;
-}): HttpResponse;
-declare function createHttpResponseErrorWithoutGlobalContext(): HttpResponse;
-declare function createHttpResponsePageContextJson(pageContextSerialized: string): Promise<HttpResponse>;
-declare function createHttpResponseRedirect({ url, statusCode }: UrlRedirect, pageContextInit: PageContextBegin): HttpResponse;

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

@@ -1,112 +0,0 @@
-export { createHttpResponsePage };
-export { createHttpResponsePageContextJson };
-export { createHttpResponseError };
-export { createHttpResponseErrorWithoutGlobalContext };
-export { createHttpResponseRedirect };
-export { createHttpResponse404 };
-export { createHttpResponseBaseIsMissing };
-import { assert, assertWarning, escapeHtml } from '../utils.js';
-import { getErrorPageId, isErrorPage } from '../../../shared/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 createHttpResponseError(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 createHttpResponseErrorWithoutGlobalContext() {
-    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),
-    };
-}

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

@@ -1,159 +0,0 @@
-export { createPageContextServerSide };
-export { createPageContextServerSideWithoutGlobalContext };
-export type { PageContextCreated };
-import type { GlobalContextServerInternal } from '../globalContext.js';
-import type { PageContextInit } from '../renderPage.js';
-type PageContextCreated = Awaited<ReturnType<typeof createPageContextServerSide>>;
-declare function createPageContextServerSide(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, args: {
-    isPrerendering: false;
-    ssr: {
-        urlHandler: null | ((url: string) => string);
-        isClientSideNavigation: boolean;
-    };
-} | {
-    isPrerendering: true;
-    ssr?: undefined;
-}): {
-    _isOriginalObject: true;
-    isPageContext: true;
-} & {
-    isClientSide: false;
-    isPrerendering: boolean;
-} & 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/page-configs/resolveVikeConfigPublic.js").Source;
-                    _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
-                    _from: import("../../../shared/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/page-configs/resolveVikeConfigPublic.js").Source;
-            _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
-            _from: import("../../../shared/page-configs/resolveVikeConfigPublic.js").From;
-        };
-        pages: {
-            [k: string]: {
-                config: import("../../../types/index.js").ConfigResolved;
-                _source: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Source;
-                _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
-                _from: import("../../../shared/page-configs/resolveVikeConfigPublic.js").From;
-            } & ({
-                route: import("../../../types/Config.js").Route;
-                isErrorPage?: undefined;
-            } | {
-                route?: undefined;
-                isErrorPage: true;
-            });
-        };
-        config: import("../../../types/index.js").ConfigResolved;
-        _source: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Source;
-        _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
-        _from: import("../../../shared/page-configs/resolveVikeConfigPublic.js").From;
-        isGlobalContext: true;
-        _isOriginalObject: true;
-        _virtualFileExportsGlobalEntry: unknown;
-        _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
-        _pageConfigs: import("../../../types/PageConfig.js").PageConfigRuntime[];
-        _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/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/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/hooks/getHook.js").Hook | null;
-    }) & {
-        baseServer: string;
-        baseAssets: string;
-        viteConfigRuntime: {
-            root: string;
-            build: {
-                outDir: string;
-            };
-            _baseViteOriginal: string;
-            vitePluginServerEntry: {
-                inject: boolean | undefined;
-            };
-        };
-    })) & {
-        prerenderContext: import("../../prerender/runPrerender.js").PrerenderContextPublic | undefined;
-    };
-    _pageFilesAll: import("../../../shared/getPageFiles.js").PageFile[];
-    _baseServer: string;
-    _baseAssets: string;
-    _pageContextInit: PageContextInit;
-    _urlRewrite: null;
-    _urlHandler: ((url: string) => string) | null;
-    isClientSideNavigation: boolean;
-} & {
-    pages: {
-        [k: string]: {
-            config: import("../../../types/index.js").ConfigResolved;
-            _source: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Source;
-            _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
-            _from: import("../../../shared/page-configs/resolveVikeConfigPublic.js").From;
-        } & ({
-            route: import("../../../types/Config.js").Route;
-            isErrorPage?: undefined;
-        } | {
-            route?: undefined;
-            isErrorPage: true;
-        });
-    };
-    config: import("../../../types/index.js").ConfigResolved;
-    _source: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Source;
-    _sources: import("../../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
-    _from: import("../../../shared/page-configs/resolveVikeConfigPublic.js").From;
-} & {
-    urlParsed: import("../utils.js").UrlPublic;
-    urlPathname: string;
-    url: string;
-} & {
-    headers: Record<string, string> | null;
-};
-declare function createPageContextServerSideWithoutGlobalContext(pageContextInit: PageContextInit): {
-    _isOriginalObject: true;
-    isPageContext: true;
-} & {
-    isClientSide: false;
-    isPrerendering: boolean;
-} & Pick<import("../../../types/PageContext.js").PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
-    url?: string;
-    headers?: Record<string, string>;
-};

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

@@ -1,57 +0,0 @@
-export { createPageContextServerSide };
-export { createPageContextServerSideWithoutGlobalContext };
-import { assert, assertUsage, assertWarning, updateType, normalizeHeaders, objectAssign } from '../utils.js';
-import { getPageContextUrlComputed } from '../../../shared/getPageContextUrlComputed.js';
-import { createPageContextObject, createPageContextShared } from '../../../shared/createPageContextShared.js';
-function createPageContextServerSide(pageContextInit, globalContext, args) {
-    assert(pageContextInit.urlOriginal);
-    const pageContextCreated = createPageContext(pageContextInit, args.isPrerendering);
-    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,
-        _urlRewrite: null,
-        _urlHandler: args.ssr?.urlHandler ?? null,
-        isClientSideNavigation: args.ssr?.isClientSideNavigation ?? false,
-    });
-    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) {
-    const pageContext = createPageContext(pageContextInit, false);
-    return pageContext;
-}
-function createPageContext(pageContextInit, isPrerendering) {
-    const pageContext = createPageContextObject();
-    objectAssign(pageContext, {
-        isClientSide: false,
-        isPrerendering,
-    });
-    objectAssign(pageContext, pageContextInit);
-    return pageContext;
-}

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

@@ -1,12 +0,0 @@
-export { resolvePageContextCspNone };
-export { inferNonceAttr };
-export { addCspResponseHeader };
-export type { PageContextCspNonce };
-import type { PageContextConfig } from '../../../shared/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;