vike 0.4.247 → 0.4.248

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

@@ -0,0 +1,94 @@
+export { renderPageServerAfterRoute };
+export { prerenderPage };
+export { prerenderPageEntry };
+import { getErrorPageId } from '../../../shared-server-client/error-page.js';
+import { getHtmlString } from './html/renderHtml.js';
+import { assert, assertUsage, updateType, hasProp, objectAssign, isSameErrorMessage } from '../../utils.js';
+import { getPageContextClientSerialized } from './html/serializeContext.js';
+import { createHttpResponsePage, createHttpResponsePageContextJson } from './createHttpResponse.js';
+import { loadPageConfigsLazyServerSide, } from './loadPageConfigsLazyServerSide.js';
+import { execHookOnRenderHtml } from './execHookOnRenderHtml.js';
+import { execHookDataAndOnBeforeRender } from './execHookDataAndOnBeforeRender.js';
+import { logRuntimeError } from '../loggerRuntime.js';
+import { preparePageContextForPublicUsageServer } from './preparePageContextForPublicUsageServer.js';
+import { execHookGuard } from '../../../shared-server-client/route/execHookGuard.js';
+import pc from '@brillout/picocolors';
+import { isServerSideError } from '../../../shared-server-client/misc/isServerSideError.js';
+import { getAsyncLocalStorage } from '../asyncHook.js';
+async function renderPageServerAfterRoute(pageContext) {
+    // pageContext.pageId can either be the:
+    //  - ID of the page matching the routing, or the
+    //  - ID of the error page `_error.page.js`.
+    assert(hasProp(pageContext, 'pageId', 'string'));
+    const isError = pageContext.is404 || !!pageContext.errorWhileRendering;
+    assert(isError ===
+        (pageContext.pageId ===
+            getErrorPageId(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs)));
+    updateType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+    if (!isError) {
+        await execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext));
+    }
+    if (!isError) {
+        await execHookDataAndOnBeforeRender(pageContext);
+    }
+    else {
+        try {
+            await execHookDataAndOnBeforeRender(pageContext);
+        }
+        catch (err) {
+            if (isSameErrorMessage(err, pageContext.errorWhileRendering)) {
+                logRuntimeError(err, pageContext);
+            }
+        }
+    }
+    if (pageContext.isClientSideNavigation) {
+        if (isError) {
+            objectAssign(pageContext, { [isServerSideError]: true });
+        }
+        const pageContextSerialized = getPageContextClientSerialized(pageContext, false);
+        const httpResponse = await createHttpResponsePageContextJson(pageContextSerialized);
+        objectAssign(pageContext, { httpResponse });
+        return pageContext;
+    }
+    const renderHookResult = await execHookOnRenderHtml(pageContext);
+    const { htmlRender, renderHook } = renderHookResult;
+    const httpResponse = await createHttpResponsePage(htmlRender, renderHook, pageContext);
+    objectAssign(pageContext, { httpResponse });
+    return pageContext;
+}
+async function prerenderPage(pageContext) {
+    const asyncLocalStorage = await getAsyncLocalStorage();
+    const requestId = pageContext._requestId;
+    assert(requestId);
+    const asyncStore = !asyncLocalStorage ? null : { requestId, pageContext };
+    objectAssign(pageContext, { _asyncStore: asyncStore, _requestId: requestId });
+    const render = async () => await prerenderPageEntry(pageContext);
+    if (asyncLocalStorage) {
+        return await asyncLocalStorage.run(asyncStore, render);
+    }
+    else {
+        return await render();
+    }
+}
+async function prerenderPageEntry(pageContext) {
+    objectAssign(pageContext, {
+        _isPageContextJsonRequest: null,
+        pageContextsAborted: [],
+    });
+    /* Should we execute the guard() hook upon pre-rendering? Is there a use case for this?
+     *  - It isn't trivial to implement, as it requires to duplicate / factor out the isAbortError() handling
+    await execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext))
+    */
+    await execHookDataAndOnBeforeRender(pageContext);
+    const { htmlRender, renderHook } = await execHookOnRenderHtml(pageContext);
+    assertUsage(htmlRender !== null, `Cannot pre-render ${pc.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
+    const documentHtml = await getHtmlString(htmlRender);
+    assert(typeof documentHtml === 'string');
+    if (!pageContext._usesClientRouter) {
+        return { documentHtml, pageContextSerialized: null, pageContext };
+    }
+    else {
+        const pageContextSerialized = getPageContextClientSerialized(pageContext, false);
+        return { documentHtml, pageContextSerialized, pageContext };
+    }
+}

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

@@ -0,0 +1,67 @@
+export { resolveRedirects };
+export { getStaticRedirectsForPrerender };
+// For ./resolveRedirects.spec.ts
+export { resolveRouteStringRedirect };
+import { assertIsNotBrowser } from '../../../utils/assertIsNotBrowser.js';
+import { assert, assertUsage, assertUsageUrlRedirectTarget, assertWarning, isUrlRedirectTarget, } from '../../../shared-server-client/utils.js';
+import { resolveUrlPathname } from '../../../shared-server-client/route/resolveUrlPathname.js';
+import { assertRouteString, isStaticRouteString, resolveRouteString, } from '../../../shared-server-client/route/resolveRouteString.js';
+import pc from '@brillout/picocolors';
+assertIsNotBrowser(); // Don't bloat the client
+const redirectsErrPrefix = '[+redirects]';
+function resolveRedirects(redirectsAll, urlPathname) {
+    const redirects = merge(redirectsAll);
+    for (const [urlSource, urlTarget] of Object.entries(redirects)) {
+        const urlResolved = resolveRouteStringRedirect(urlSource, urlTarget, urlPathname);
+        if (urlResolved)
+            return urlResolved;
+    }
+    return null;
+}
+function getStaticRedirectsForPrerender(redirectsAll, showWarningUponDynamicRedirects) {
+    const redirects = merge(redirectsAll);
+    const redirectsStatic = {};
+    for (const [urlSource, urlTarget] of Object.entries(redirects)) {
+        assertRedirect(urlSource, urlTarget);
+        if (isStaticRouteString(urlSource)) {
+            redirectsStatic[urlSource] = urlTarget;
+        }
+        else if (showWarningUponDynamicRedirects) {
+            assertWarning(false, `Dynamic redirect ${pc.cyan(urlSource)} -> ${pc.cyan(urlTarget)} cannot be pre-rendered. You can remove this warning by setting +prerender.partial to true (https://vike.dev/prerender#partial).`, { onlyOnce: true });
+        }
+    }
+    return redirectsStatic;
+}
+function resolveRouteStringRedirect(urlSource, urlTarget, urlPathname) {
+    assertRedirect(urlSource, urlTarget);
+    const match = resolveRouteString(urlSource, urlPathname);
+    if (!match)
+        return null;
+    const urlResolved = resolveUrlPathname(urlTarget, match.routeParams);
+    if (urlResolved === urlPathname)
+        return null;
+    assert(isUrlRedirectTarget(urlResolved));
+    return urlResolved;
+}
+function assertRedirect(urlSource, urlTarget) {
+    assertRouteString(urlSource, `${redirectsErrPrefix} Invalid`);
+    // Is allowing any protocol a safety issue? https://github.com/vikejs/vike/pull/1292#issuecomment-1828043917
+    assertUsageUrlRedirectTarget(urlTarget, `${redirectsErrPrefix} The URL redirection target`, true);
+    assertParams(urlSource, urlTarget);
+}
+function assertParams(urlSource, urlTarget) {
+    const routeSegments = urlTarget.split('/');
+    routeSegments.forEach((routeSegment) => {
+        if (routeSegment.startsWith('@') || routeSegment.startsWith('*')) {
+            const segments = urlSource.split('/');
+            assertUsage(segments.includes(routeSegment), `${redirectsErrPrefix} The redirection source URL ${pc.string(urlSource)} is missing the URL parameter ${pc.string(routeSegment)} used by the redirection target URL ${pc.string(urlTarget)}`);
+        }
+    });
+}
+function merge(objs) {
+    const obj = {};
+    objs.forEach((e) => {
+        Object.assign(obj, e);
+    });
+    return obj;
+}

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

@@ -0,0 +1,156 @@
+export { renderPageServer };
+export type { PageContextInit };
+export type { PageContextBegin };
+import { type PageContextAborted } from '../../shared-server-client/route/abort.js';
+import { type GlobalContextServerInternal } from './globalContext.js';
+import { type HttpResponse } from './renderPageServer/createHttpResponse.js';
+import type { PageContextServer } from '../../types/index.js';
+import type { PageContextInternalServer } from '../../types/PageContext.js';
+import { type AsyncStore } from './asyncHook.js';
+type PageContextInit = Pick<PageContextInternalServer, 'urlOriginal' | 'headersOriginal'> & {
+    /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
+    /** @deprecated Set pageContextInit.headersOriginal instead */ headers?: Record<string, string>;
+};
+type PageContextBegin = ReturnType<typeof getPageContextBegin>;
+declare function renderPageServer<PageContextUserAdded extends {}, PageContextInitUser extends PageContextInit>(pageContextInit: PageContextInitUser): Promise<PageContextInitUser & {
+    httpResponse: HttpResponse;
+} & Partial<PageContextServer & PageContextUserAdded>>;
+declare function getPageContextBegin(pageContextInit: PageContextInit, globalContext: GlobalContextServerInternal, requestId: number, asyncStore: AsyncStore): {
+    _isOriginalObject: true;
+    isPageContext: true;
+} & {
+    isClientSide: false;
+    isPrerendering: boolean;
+    _requestId: number;
+} & Pick<PageContextInternalServer, "urlOriginal" | "headersOriginal"> & {
+    /** @deprecated Set `pageContextInit.urlOriginal` instead  */ url?: string;
+    /** @deprecated Set pageContextInit.headersOriginal instead */ 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("../../shared-server-client/route/loadPageRoutes.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("../../shared-server-client/route/loadPageRoutes.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("../../shared-server-client/route/loadPageRoutes.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;
+} & {
+    _requestId: number;
+    _asyncStore: AsyncStore;
+    _isPageContextJsonRequest: boolean;
+    pageContextsAborted: PageContextAborted[];
+};