vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

package/dist/cjs/node/runtime/renderPage/handlePageContextRequestUrl.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePageContextRequestUrl = void 0;
+const getPageContextRequestUrl_js_1 = require("../../../shared/getPageContextRequestUrl.js");
+const utils_js_1 = require("../utils.js");
+// See shared/getPageContextRequestUrl.ts
+function handlePageContextRequestUrl(url) {
+    if (!hasSuffix(url)) {
+        return { urlWithoutPageContextRequestSuffix: url, isPageContextRequest: false };
+    }
+    return { urlWithoutPageContextRequestSuffix: removePageContextUrlSuffix(url), isPageContextRequest: true };
+}
+exports.handlePageContextRequestUrl = handlePageContextRequestUrl;
+function hasSuffix(url) {
+    const { pathnameOriginal, pathname } = (0, utils_js_1.parseUrl)(url, utils_js_1.baseServer);
+    (0, utils_js_1.assert)(pathnameOriginal.endsWith(getPageContextRequestUrl_js_1.pageContextJsonFileExtension) === pathname.endsWith(getPageContextRequestUrl_js_1.pageContextJsonFileExtension), {
+        url
+    });
+    return pathnameOriginal.endsWith(getPageContextRequestUrl_js_1.pageContextJsonFileExtension);
+}
+function removePageContextUrlSuffix(url) {
+    const urlParsed = (0, utils_js_1.parseUrl)(url, utils_js_1.baseServer);
+    // We cannot use `urlParsed.pathname` because it would break the `urlParsed.pathnameOriginal` value of subsequent `parseUrl()` calls.
+    const { origin, pathnameOriginal, searchOriginal, hashOriginal } = urlParsed;
+    (0, utils_js_1.assert)(getPageContextRequestUrl_js_1.doNotCreateExtraDirectory === false);
+    const urlSuffix = `/index${getPageContextRequestUrl_js_1.pageContextJsonFileExtension}`;
+    (0, utils_js_1.assert)(pathnameOriginal.endsWith(urlSuffix), { url });
+    let pathnameModified = (0, utils_js_1.slice)(pathnameOriginal, 0, -1 * urlSuffix.length);
+    if (pathnameModified === '')
+        pathnameModified = '/';
+    (0, utils_js_1.assert)(url === `${origin || ''}${pathnameOriginal}${searchOriginal || ''}${hashOriginal || ''}`, { url });
+    return `${origin || ''}${pathnameModified}${searchOriginal || ''}${hashOriginal || ''}`;
+}

package/dist/cjs/node/runtime/renderPage/inferMediaType.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferMediaType = void 0;
+const utils_js_1 = require("../utils.js");
+function inferMediaType(href) {
+    // Basics
+    if (utils_js_1.styleFileRE.test(href)) {
+        return { mediaType: 'text/css', assetType: 'style' };
+    }
+    if ((0, utils_js_1.isScriptFile)(href)) {
+        return { mediaType: 'text/javascript', assetType: 'script' };
+    }
+    // Images
+    if (href.endsWith('.png')) {
+        return { assetType: 'image', mediaType: 'image/png' };
+    }
+    if (href.endsWith('.webp')) {
+        return { assetType: 'image', mediaType: 'image/webp' };
+    }
+    if (href.endsWith('.jpg') || href.endsWith('.jpeg')) {
+        return { assetType: 'image', mediaType: 'image/jpeg' };
+    }
+    if (href.endsWith('.gif')) {
+        return { assetType: 'image', mediaType: 'image/gif' };
+    }
+    if (href.endsWith('.svg')) {
+        return { assetType: 'image', mediaType: 'image/svg+xml' };
+    }
+    // Fonts
+    if (href.endsWith('.ttf')) {
+        return { assetType: 'font', mediaType: 'font/ttf' };
+    }
+    if (href.endsWith('.woff')) {
+        return { assetType: 'font', mediaType: 'font/woff' };
+    }
+    if (href.endsWith('.woff2')) {
+        return { assetType: 'font', mediaType: 'font/woff2' };
+    }
+    return null;
+}
+exports.inferMediaType = inferMediaType;

package/dist/cjs/node/runtime/renderPage/isConfigInvalid.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConfigInvalid_set = exports.isConfigInvalid = void 0;
+exports.isConfigInvalid = false;
+const isConfigInvalid_set = (val) => {
+    exports.isConfigInvalid = val;
+};
+exports.isConfigInvalid_set = isConfigInvalid_set;

package/dist/cjs/node/runtime/renderPage/isNewError.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setAlreadyLogged = exports.isNewError = void 0;
+const utils_js_1 = require("../utils.js");
+const globalObject = (0, utils_js_1.getGlobalObject)('runtime/renderPage/isNewError.ts', {
+    wasAlreadyLogged: new WeakSet()
+});
+function isNewError(errErrorPage, errNominalPage) {
+    (0, utils_js_1.warnIfErrorIsNotObject)(errErrorPage);
+    return !(0, utils_js_1.isEquivalentError)(errNominalPage, errErrorPage) || !hasAlreadyLogged(errNominalPage);
+}
+exports.isNewError = isNewError;
+function hasAlreadyLogged(err) {
+    if (!(0, utils_js_1.isObject)(err))
+        return false;
+    return globalObject.wasAlreadyLogged.has(err);
+}
+function setAlreadyLogged(err) {
+    if (!(0, utils_js_1.isObject)(err))
+        return;
+    globalObject.wasAlreadyLogged.add(err);
+}
+exports.setAlreadyLogged = setAlreadyLogged;

package/dist/cjs/node/runtime/renderPage/loadPageFilesServerSide.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPageFilesServerSide = void 0;
+const getPageFiles_js_1 = require("../../../shared/getPageFiles.js");
+const analyzePageClientSide_js_1 = require("../../../shared/getPageFiles/analyzePageClientSide.js");
+const utils_js_1 = require("../utils.js");
+const getPageAssets_js_1 = require("./getPageAssets.js");
+const debugPageFiles_js_1 = require("./debugPageFiles.js");
+const findPageConfig_js_1 = require("../../../shared/page-configs/findPageConfig.js");
+const analyzePage_js_1 = require("./analyzePage.js");
+const globalContext_js_1 = require("../globalContext.js");
+const loadPageCode_js_1 = require("../../../shared/page-configs/loadPageCode.js");
+async function loadPageFilesServerSide(pageContext) {
+    const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._pageConfigs, pageContext._pageId); // Make pageConfig globally available as pageContext._pageConfig?
+    const [{ config, configEntries, exports, exportsAll, pageExports, pageFilesLoaded, pageConfigLoaded }] = await Promise.all([
+        loadPageFiles(pageContext._pageFilesAll, pageConfig, pageContext._pageId, !(0, globalContext_js_1.getGlobalContext)().isProduction),
+        (0, analyzePageClientSide_js_1.analyzePageClientSideInit)(pageContext._pageFilesAll, pageContext._pageId, { sharedPageFilesAlreadyLoaded: true })
+    ]);
+    const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = (0, analyzePage_js_1.analyzePage)(pageContext._pageFilesAll, pageConfig, pageContext._pageId);
+    const pageContextAddendum = {};
+    (0, utils_js_1.objectAssign)(pageContextAddendum, {
+        config,
+        configEntries,
+        exports,
+        exportsAll,
+        pageExports,
+        Page: exports.Page,
+        _isHtmlOnly: isHtmlOnly,
+        _passToClient: (0, getPageFiles_js_1.getExportUnion)(exportsAll, 'passToClient'),
+        _pageFilePathsLoaded: pageFilesLoaded.map((p) => p.filePath)
+    });
+    (0, utils_js_1.objectAssign)(pageContextAddendum, {
+        __getPageAssets: async () => {
+            if ('_pageAssets' in pageContext) {
+                return pageContext._pageAssets;
+            }
+            else {
+                const pageAssets = await (0, getPageAssets_js_1.getPageAssets)(pageContext, clientDependencies, clientEntries);
+                (0, utils_js_1.objectAssign)(pageContext, { _pageAssets: pageAssets });
+                return pageContext._pageAssets;
+            }
+        }
+    });
+    // TODO/v1-release: remove
+    Object.assign(pageContextAddendum, {
+        _getPageAssets: async () => {
+            (0, utils_js_1.assertWarning)(false, 'pageContext._getPageAssets() deprecated, see https://vike.dev/preload', {
+                onlyOnce: true,
+                showStackTrace: true
+            });
+            const pageAssetsOldFormat = [];
+            (await pageContextAddendum.__getPageAssets()).forEach((p) => {
+                if (p.assetType === 'script' && p.isEntry) {
+                    pageAssetsOldFormat.push({
+                        src: p.src,
+                        preloadType: null,
+                        assetType: 'script',
+                        mediaType: p.mediaType
+                    });
+                }
+                pageAssetsOldFormat.push({
+                    src: p.src,
+                    preloadType: p.assetType,
+                    assetType: p.assetType === 'style' ? 'style' : 'preload',
+                    mediaType: p.mediaType
+                });
+            });
+            return pageAssetsOldFormat;
+        }
+    });
+    {
+        (0, debugPageFiles_js_1.debugPageFiles)({
+            pageContext,
+            isHtmlOnly,
+            isClientRouting,
+            pageFilesLoaded,
+            pageFilesClientSide,
+            pageFilesServerSide,
+            clientEntries,
+            clientDependencies
+        });
+    }
+    return pageContextAddendum;
+}
+exports.loadPageFilesServerSide = loadPageFilesServerSide;
+async function loadPageFiles(pageFilesAll, pageConfig, pageId, isDev) {
+    const pageFilesServerSide = (0, getPageFiles_js_1.getPageFilesServerSide)(pageFilesAll, pageId);
+    const pageConfigLoaded = !pageConfig ? null : await (0, loadPageCode_js_1.loadPageCode)(pageConfig, isDev);
+    await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
+    const { config, configEntries, exports, exportsAll, pageExports } = (0, getPageFiles_js_1.getExports)(pageFilesServerSide, pageConfigLoaded);
+    return {
+        config,
+        configEntries,
+        exports,
+        exportsAll,
+        pageExports,
+        pageFilesLoaded: pageFilesServerSide,
+        pageConfigLoaded
+    };
+}

package/dist/cjs/node/runtime/renderPage/log404/index.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPagesAndRoutesInfo = exports.log404 = void 0;
+const globalContext_js_1 = require("../../globalContext.js");
+const utils_js_1 = require("../../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+async function log404(pageContext) {
+    const { urlPathname } = pageContext;
+    const pageRoutes = pageContext._pageRoutes;
+    (0, utils_js_1.assertUsage)(pageRoutes.length > 0, 'No page found.'
+    /* TODO/v1-release: use this
+    'No page found. Create at least one /pages/some-page/+Page.js file.'
+    */
+    );
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    if (!globalContext.isProduction && !isFileRequest(urlPathname) && !pageContext.isClientSideNavigation) {
+        (0, utils_js_1.assertInfo)(false, [
+            `URL ${picocolors_1.default.cyan(urlPathname)} doesn't match the route of any of your pages:`,
+            getPagesAndRoutesInfo(pageRoutes),
+            'See https://vike.dev/routing for more information about routing.'
+        ].join('\n'), { onlyOnce: false });
+    }
+}
+exports.log404 = log404;
+function getPagesAndRoutesInfo(pageRoutes) {
+    const entries = pageRoutes
+        .map((pageRoute) => {
+        let routeStr;
+        let routeTypeSrc;
+        let routeDefinedBy;
+        if (pageRoute.routeType === 'FILESYSTEM') {
+            (0, utils_js_1.assert)(pageRoute.routeFilesystemDefinedBy);
+            routeDefinedBy = pageRoute.routeFilesystemDefinedBy;
+        }
+        else {
+            (0, utils_js_1.assert)(pageRoute.routeDefinedAt);
+            routeDefinedBy = pageRoute.routeDefinedAt;
+        }
+        if (pageRoute.routeType === 'STRING') {
+            routeStr = pageRoute.routeString;
+            routeTypeSrc = 'Route String';
+        }
+        else if (pageRoute.routeType === 'FUNCTION') {
+            routeStr = String(pageRoute.routeFunction);
+            routeTypeSrc = 'Route Function';
+        }
+        else {
+            routeStr = pageRoute.routeString;
+            routeTypeSrc = 'Filesystem Route';
+        }
+        (0, utils_js_1.assert)(routeStr && routeTypeSrc && routeDefinedBy);
+        return { routeStr, routeTypeSrc, routeDefinedBy };
+    })
+        .sort((e1, e2) => {
+        if (e1.routeTypeSrc !== 'Route Function' && e2.routeTypeSrc === 'Route Function') {
+            return -1;
+        }
+        if (e1.routeTypeSrc === 'Route Function' && e2.routeTypeSrc !== 'Route Function') {
+            return 1;
+        }
+        return (0, utils_js_1.compareString)(e1.routeStr, e2.routeStr);
+    });
+    const linesContent = [
+        {
+            routeStr: 'ROUTE',
+            routeTypeSrc: 'TYPE',
+            routeDefinedBy: 'DEFINED BY'
+        },
+        ...entries
+    ];
+    const terminalWidth = (0, utils_js_1.getTerminalWidth)() || 134;
+    let width2 = Math.max(...linesContent.map(({ routeTypeSrc }) => routeTypeSrc.length));
+    let width3 = Math.max(...linesContent.map(({ routeDefinedBy }) => routeDefinedBy.length));
+    let width1 = terminalWidth - width3 - width2 - 10;
+    linesContent.forEach((lineContent) => {
+        let { routeStr } = lineContent;
+        if (lineContent.routeTypeSrc !== 'Route Function') {
+            routeStr = (0, utils_js_1.truncateString)(routeStr, width1, (s) => picocolors_1.default.dim(s));
+        }
+        else {
+            routeStr = truncateRouteFunction(routeStr, width1);
+        }
+        (0, utils_js_1.assert)((0, utils_js_1.stripAnsi)(routeStr).length <= width1);
+        lineContent.routeStr = routeStr;
+    });
+    width1 = Math.max(...linesContent.map(({ routeStr }) => (0, utils_js_1.stripAnsi)(routeStr).length));
+    let lines = linesContent.map(({ routeStr, routeTypeSrc, routeDefinedBy }, i) => {
+        let cell1 = routeStr.padEnd(width1 + (routeStr.length - (0, utils_js_1.stripAnsi)(routeStr).length), ' ');
+        let cell2 = routeTypeSrc.padEnd(width2, ' ');
+        let cell3 = routeDefinedBy.padEnd(width3, ' ');
+        const isHeader = i === 0;
+        if (isHeader) {
+            cell1 = picocolors_1.default.dim(cell1);
+            cell2 = picocolors_1.default.dim(cell2);
+            cell3 = picocolors_1.default.dim(cell3);
+        }
+        let line = [cell1, cell2, cell3].join(picocolors_1.default.dim(' │ '));
+        line = picocolors_1.default.dim('│ ') + line + picocolors_1.default.dim(' │');
+        return line;
+    });
+    width1 = width1 + 2;
+    width2 = width2 + 2;
+    width3 = width3 + 2;
+    // https://en.wikipedia.org/wiki/Box-drawing_character
+    lines = [
+        picocolors_1.default.dim(`┌${'─'.repeat(width1)}┬${'─'.repeat(width2)}┬${'─'.repeat(width3)}┐`),
+        lines[0],
+        picocolors_1.default.dim(`├${'─'.repeat(width1)}┼${'─'.repeat(width2)}┼${'─'.repeat(width3)}┤`),
+        ...lines.slice(1),
+        picocolors_1.default.dim(`└${'─'.repeat(width1)}┴${'─'.repeat(width2)}┴${'─'.repeat(width3)}┘`)
+    ];
+    lines.forEach((line) => {
+        (0, utils_js_1.assert)((0, utils_js_1.stripAnsi)(line).length <= terminalWidth);
+    });
+    return lines.join('\n');
+}
+exports.getPagesAndRoutesInfo = getPagesAndRoutesInfo;
+function truncateRouteFunction(routeStr, lenMax) {
+    routeStr = (0, utils_js_1.stripAnsi)(routeStr);
+    routeStr = removeNonAscii(routeStr);
+    routeStr = routeStr.split(/\s/).filter(Boolean).join(' ');
+    routeStr = (0, utils_js_1.truncateString)(routeStr, lenMax, (s) => picocolors_1.default.dim(s));
+    return routeStr;
+}
+function removeNonAscii(str) {
+    // https://stackoverflow.com/questions/20856197/remove-non-ascii-character-in-string/20856346#20856346
+    return str.replace(/[^\x00-\x7F]/g, '');
+}
+function isFileRequest(urlPathname) {
+    (0, utils_js_1.assert)(urlPathname.startsWith('/'));
+    const paths = urlPathname.split('/');
+    const lastPath = paths[paths.length - 1];
+    (0, utils_js_1.assert)(typeof lastPath === 'string');
+    const parts = lastPath.split('.');
+    if (parts.length < 2) {
+        return false;
+    }
+    const fileExtension = parts[parts.length - 1];
+    (0, utils_js_1.assert)(typeof fileExtension === 'string');
+    return /^[a-z0-9]+$/.test(fileExtension);
+}

package/dist/cjs/node/runtime/renderPage/loggerProd.js

@@ -0,0 +1,23 @@
+"use strict";
+// Logger used for the production server.
+// Any other environement (dev, preview, build, and pre-rendering) uses loggerNotProd.ts instead.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logErrorProd = void 0;
+const abort_js_1 = require("../../../shared/route/abort.js");
+const isNewError_js_1 = require("./isNewError.js");
+const utils_js_1 = require("../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function logErrorProd(err, _httpRquestId) {
+    (0, utils_js_1.warnIfErrorIsNotObject)(err);
+    (0, isNewError_js_1.setAlreadyLogged)(err);
+    if ((0, abort_js_1.isAbortError)(err)) {
+        return;
+    }
+    // We ensure we print a string; Cloudflare Workers doesn't seem to properly stringify `Error` objects.
+    const errStr = (0, utils_js_1.isObject)(err) && 'stack' in err ? String(err.stack) : String(err);
+    console.error(picocolors_1.default.red(errStr));
+}
+exports.logErrorProd = logErrorProd;

package/dist/cjs/node/runtime/renderPage/loggerRuntime.js

@@ -0,0 +1,17 @@
+"use strict";
+// Logger used by the the server runtime. (Also during pre-rendering since it uses the sever runtime.)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overwriteRuntimeProductionLogger = exports.logRuntimeInfo = exports.logRuntimeError = void 0;
+exports.logRuntimeInfo = null; // logInfo is null in production
+const loggerProd_js_1 = require("./loggerProd.js");
+// Set production logger (which is overwritten by loggerNotProd.ts in non-production environments such as development and during pre-rendering)
+exports.logRuntimeError =
+    // @ts-expect-error
+    exports.logRuntimeError ??
+        // Default
+        loggerProd_js_1.logErrorProd;
+function overwriteRuntimeProductionLogger(logError_, logInfo_) {
+    exports.logRuntimeError = logError_;
+    exports.logRuntimeInfo = logInfo_;
+}
+exports.overwriteRuntimeProductionLogger = overwriteRuntimeProductionLogger;

package/dist/cjs/node/runtime/renderPage/preparePageContextForUserConsumptionServerSide.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparePageContextForUserConsumptionServerSide = void 0;
+const utils_js_1 = require("../utils.js");
+const sortPageContext_js_1 = require("../../../shared/sortPageContext.js");
+const addUrlComputedProps_js_1 = require("../../../shared/addUrlComputedProps.js");
+const addIs404ToPageProps_js_1 = require("../../../shared/addIs404ToPageProps.js");
+function preparePageContextForUserConsumptionServerSide(pageContext) {
+    (0, addUrlComputedProps_js_1.assertPageContextUrlComputedProps)(pageContext);
+    (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(pageContext.routeParams));
+    (0, utils_js_1.assert)('Page' in pageContext);
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageContext.pageExports));
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageContext.exports));
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(pageContext.exportsAll));
+    (0, utils_js_1.assert)(typeof pageContext.isClientSideNavigation === 'boolean');
+    (0, sortPageContext_js_1.sortPageContext)(pageContext);
+    (0, addIs404ToPageProps_js_1.addIs404ToPageProps)(pageContext);
+}
+exports.preparePageContextForUserConsumptionServerSide = preparePageContextForUserConsumptionServerSide;

package/dist/cjs/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRenderContext = exports.getPageContextInitEnhanced = exports.prerender404Page = exports.prerenderPage = exports.renderPageAlreadyRouted = void 0;
+const error_page_js_1 = require("../../../shared/error-page.js");
+const renderHtml_js_1 = require("../html/renderHtml.js");
+const getPageFiles_js_1 = require("../../../shared/getPageFiles.js");
+const utils_js_1 = require("../utils.js");
+const serializePageContextClientSide_js_1 = require("../html/serializePageContextClientSide.js");
+const addUrlComputedProps_js_1 = require("../../../shared/addUrlComputedProps.js");
+const globalContext_js_1 = require("../globalContext.js");
+const createHttpResponseObject_js_1 = require("./createHttpResponseObject.js");
+const loadPageFilesServerSide_js_1 = require("./loadPageFilesServerSide.js");
+const executeOnRenderHtmlHook_js_1 = require("./executeOnRenderHtmlHook.js");
+const executeOnBeforeRenderHook_js_1 = require("./executeOnBeforeRenderHook.js");
+const loggerRuntime_js_1 = require("./loggerRuntime.js");
+const isNewError_js_1 = require("./isNewError.js");
+const preparePageContextForUserConsumptionServerSide_js_1 = require("./preparePageContextForUserConsumptionServerSide.js");
+const executeGuardHook_js_1 = require("../../../shared/route/executeGuardHook.js");
+const loadPageRoutes_js_1 = require("../../../shared/route/loadPageRoutes.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+async function renderPageAlreadyRouted(pageContext) {
+    // pageContext._pageId can either be the:
+    //  - ID of the page matching the routing, or the
+    //  - ID of the error page `_error.page.js`.
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, '_pageId', 'string'));
+    const isError = pageContext.is404 || !!pageContext.errorWhileRendering;
+    (0, utils_js_1.assert)(isError === (pageContext._pageId === (0, error_page_js_1.getErrorPageId)(pageContext._pageFilesAll, pageContext._pageConfigs)));
+    (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageFilesServerSide_js_1.loadPageFilesServerSide)(pageContext));
+    if (!isError) {
+        await (0, executeGuardHook_js_1.executeGuardHook)(pageContext, (pageContext) => (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext));
+    }
+    if (!isError) {
+        await (0, executeOnBeforeRenderHook_js_1.executeOnBeforeRenderHooks)(pageContext);
+    }
+    else {
+        try {
+            await (0, executeOnBeforeRenderHook_js_1.executeOnBeforeRenderHooks)(pageContext);
+        }
+        catch (err) {
+            if ((0, isNewError_js_1.isNewError)(err, pageContext.errorWhileRendering)) {
+                (0, loggerRuntime_js_1.logRuntimeError)(err, pageContext._httpRequestId);
+            }
+        }
+    }
+    if (pageContext.isClientSideNavigation) {
+        if (isError) {
+            (0, utils_js_1.objectAssign)(pageContext, { _isError: true });
+        }
+        const pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext);
+        const httpResponse = await (0, createHttpResponseObject_js_1.createHttpResponsePageContextJson)(pageContextSerialized);
+        (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
+        return pageContext;
+    }
+    const renderHookResult = await (0, executeOnRenderHtmlHook_js_1.executeOnRenderHtmlHook)(pageContext);
+    if (renderHookResult.htmlRender === null) {
+        (0, utils_js_1.objectAssign)(pageContext, { httpResponse: null });
+        return pageContext;
+    }
+    else {
+        const { htmlRender, renderHook } = renderHookResult;
+        const httpResponse = await (0, createHttpResponseObject_js_1.createHttpResponseObject)(htmlRender, renderHook, pageContext);
+        (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
+        return pageContext;
+    }
+}
+exports.renderPageAlreadyRouted = renderPageAlreadyRouted;
+async function prerenderPage(pageContext) {
+    (0, utils_js_1.objectAssign)(pageContext, {
+        isClientSideNavigation: false,
+        _urlHandler: null
+    });
+    /* 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 executeGuardHook(pageContext, (pageContext) => preparePageContextForUserConsumptionServerSide(pageContext))
+    */
+    await (0, executeOnBeforeRenderHook_js_1.executeOnBeforeRenderHooks)(pageContext);
+    const { htmlRender, renderHook } = await (0, executeOnRenderHtmlHook_js_1.executeOnRenderHtmlHook)(pageContext);
+    (0, utils_js_1.assertUsage)(htmlRender !== null, `Cannot pre-render ${picocolors_1.default.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
+    (0, utils_js_1.assert)(pageContext.isClientSideNavigation === false);
+    const documentHtml = await (0, renderHtml_js_1.getHtmlString)(htmlRender);
+    (0, utils_js_1.assert)(typeof documentHtml === 'string');
+    if (!pageContext._usesClientRouter) {
+        return { documentHtml, pageContextSerialized: null, pageContext };
+    }
+    else {
+        const pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext);
+        return { documentHtml, pageContextSerialized, pageContext };
+    }
+}
+exports.prerenderPage = prerenderPage;
+async function prerender404Page(renderContext, pageContextInit_) {
+    const errorPageId = (0, error_page_js_1.getErrorPageId)(renderContext.pageFilesAll, renderContext.pageConfigs);
+    if (!errorPageId) {
+        return null;
+    }
+    const pageContext = {
+        _pageId: errorPageId,
+        _httpRequestId: null,
+        _urlRewrite: null,
+        is404: true,
+        routeParams: {},
+        // `prerender404Page()` is about generating `dist/client/404.html` for static hosts; there is no Client Routing.
+        _usesClientRouter: false,
+        _routeMatches: []
+    };
+    const pageContextInit = {
+        urlOriginal: '/fake-404-url',
+        ...pageContextInit_
+    };
+    {
+        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, renderContext);
+        (0, utils_js_1.objectAssign)(pageContext, pageContextInitEnhanced);
+    }
+    (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageFilesServerSide_js_1.loadPageFilesServerSide)(pageContext));
+    return prerenderPage(pageContext);
+}
+exports.prerender404Page = prerender404Page;
+function getPageContextInitEnhanced(pageContextInit, renderContext, { urlComputedPropsNonEnumerable = false, ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
+    urlRewrite: null,
+    urlHandler: null,
+    isClientSideNavigation: false
+} } = {}) {
+    (0, utils_js_1.assert)(pageContextInit.urlOriginal);
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    const pageContextInitEnhanced = {
+        ...pageContextInit,
+        _objectCreatedByVike: true,
+        // The following is defined on `pageContext` because we can eventually make these non-global (e.g. sot that two pages can have different includeAssetsImportedByServer settings)
+        _baseServer: globalContext.baseServer,
+        _baseAssets: globalContext.baseAssets,
+        _includeAssetsImportedByServer: globalContext.includeAssetsImportedByServer,
+        // TODO: use GloablContext instead
+        _pageFilesAll: renderContext.pageFilesAll,
+        _pageConfigs: renderContext.pageConfigs,
+        _pageConfigGlobal: renderContext.pageConfigGlobal,
+        _allPageIds: renderContext.allPageIds,
+        _pageRoutes: renderContext.pageRoutes,
+        _onBeforeRouteHook: renderContext.onBeforeRouteHook,
+        _pageContextInit: pageContextInit,
+        _urlRewrite: urlRewrite,
+        _urlHandler: urlHandler,
+        isClientSideNavigation
+    };
+    (0, addUrlComputedProps_js_1.addUrlComputedProps)(pageContextInitEnhanced, !urlComputedPropsNonEnumerable);
+    return pageContextInitEnhanced;
+}
+exports.getPageContextInitEnhanced = getPageContextInitEnhanced;
+// TODO: remove getRenderContext() in favor of getGlobalObject() + reloadGlobalContext()
+// TODO: impl GlobalNodeContext + GlobalClientContext + GloablContext, and use GlobalContext instead of RenderContext
+async function getRenderContext() {
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = await (0, getPageFiles_js_1.getPageFilesAll)(false, globalContext.isProduction);
+    const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
+    assertNonMixedDesign(pageFilesAll, pageConfigs);
+    const renderContext = {
+        pageFilesAll: pageFilesAll,
+        pageConfigs,
+        pageConfigGlobal,
+        allPageIds: allPageIds,
+        pageRoutes,
+        onBeforeRouteHook
+    };
+    return renderContext;
+}
+exports.getRenderContext = getRenderContext;
+function assertNonMixedDesign(pageFilesAll, pageConfigs) {
+    if (pageFilesAll.length === 0 || pageConfigs.length === 0)
+        return;
+    const indent = '- ';
+    const v1Files = (0, utils_js_1.unique)(pageConfigs
+        .map((p) => Object.values(p.configValues)
+        .map(({ definedAtInfo }) => definedAtInfo)
+        .filter(utils_js_1.isNotNullish)
+        .map((definedAtInfo) => indent + definedAtInfo.filePath))
+        .flat(2));
+    (0, utils_js_1.assertUsage)(false, [
+        'Mixing the new V1 design with the old V0.4 design is forbidden.',
+        'V1 files:',
+        ...v1Files,
+        'V0.4 files:',
+        ...pageFilesAll.map((p) => indent + p.filePath)
+    ].join('\n'));
+}