vike 0.0.0-alpha.0 → 0.4.142-commit-6eb0dd3

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

@@ -0,0 +1,405 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPage_addWrapper = exports.renderPage = void 0;
+const renderPageAlreadyRouted_js_1 = require("./renderPage/renderPageAlreadyRouted.js");
+const index_js_1 = require("../../shared/route/index.js");
+const utils_js_1 = require("./utils.js");
+const abort_js_1 = require("../../shared/route/abort.js");
+const globalContext_js_1 = require("./globalContext.js");
+const handlePageContextRequestUrl_js_1 = require("./renderPage/handlePageContextRequestUrl.js");
+const createHttpResponseObject_js_1 = require("./renderPage/createHttpResponseObject.js");
+const loggerRuntime_js_1 = require("./renderPage/loggerRuntime.js");
+const isNewError_js_1 = require("./renderPage/isNewError.js");
+const assertArguments_js_1 = require("./renderPage/assertArguments.js");
+const index_js_2 = require("./renderPage/log404/index.js");
+const isConfigInvalid_js_1 = require("./renderPage/isConfigInvalid.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const serializePageContextClientSide_js_1 = require("./html/serializePageContextClientSide.js");
+const error_page_js_1 = require("../../shared/error-page.js");
+const handleErrorWithoutErrorPage_js_1 = require("./renderPage/handleErrorWithoutErrorPage.js");
+const loadPageFilesServerSide_js_1 = require("./renderPage/loadPageFilesServerSide.js");
+const resolveRedirects_js_1 = require("../../shared/route/resolveRedirects.js");
+const globalObject = (0, utils_js_1.getGlobalObject)('runtime/renderPage.ts', {
+    httpRequestsCount: 0,
+    pendingRequestsCount: 0
+});
+let renderPage_wrapper = async (_httpRequestId, ret) => ({
+    pageContextReturn: await ret(),
+    onRequestDone: () => { }
+});
+const renderPage_addWrapper = (wrapper) => {
+    renderPage_wrapper = wrapper;
+};
+exports.renderPage_addWrapper = renderPage_addWrapper;
+// `renderPage()` calls `renderPageNominal()` while ensuring that errors are `console.error(err)` instead of `throw err`, so that Vike never triggers a server shut down. (Throwing an error in an Express.js middleware shuts down the whole Express.js server.)
+async function renderPage(pageContextInit) {
+    (0, assertArguments_js_1.assertArguments)(...arguments);
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextInit, 'urlOriginal', 'string'));
+    (0, utils_js_1.assertEnv)();
+    if (skipRequest(pageContextInit.urlOriginal)) {
+        const pageContextHttpReponseNull = getPageContextHttpResponseNull(pageContextInit);
+        (0, utils_js_1.checkType)(pageContextHttpReponseNull);
+        return pageContextHttpReponseNull;
+    }
+    const httpRequestId = getRequestId();
+    const urlToShowToUser = pageContextInit.urlOriginal;
+    logHttpRequest(urlToShowToUser, httpRequestId);
+    globalObject.pendingRequestsCount++;
+    const { pageContextReturn, onRequestDone } = await renderPage_wrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
+    logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn);
+    globalObject.pendingRequestsCount--;
+    onRequestDone();
+    (0, utils_js_1.checkType)(pageContextReturn);
+    return pageContextReturn;
+}
+exports.renderPage = renderPage;
+async function renderPageAndPrepare(pageContextInit, httpRequestId) {
+    // Invalid config
+    const handleInvalidConfig = () => {
+        (0, loggerRuntime_js_1.logRuntimeInfo)?.(picocolors_1.default.bold(picocolors_1.default.red("Couldn't load configuration: see error above.")), httpRequestId, 'error');
+        const pageContextHttpReponseNull = getPageContextHttpResponseNull(pageContextInit);
+        return pageContextHttpReponseNull;
+    };
+    if (isConfigInvalid_js_1.isConfigInvalid) {
+        return handleInvalidConfig();
+    }
+    // Prepare context
+    let renderContext;
+    try {
+        await (0, globalContext_js_1.initGlobalContext)();
+        renderContext = await (0, renderPageAlreadyRouted_js_1.getRenderContext)();
+    }
+    catch (err) {
+        // Errors are expected since assertUsage() is used in both initGlobalContext() and getRenderContext().
+        // initGlobalContext() and getRenderContext() don't call any user hooks => err isn't thrown from user code
+        (0, utils_js_1.assert)(!(0, abort_js_1.isAbortError)(err));
+        (0, loggerRuntime_js_1.logRuntimeError)(err, httpRequestId);
+        const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(err, pageContextInit);
+        return pageContextHttpReponseNull;
+    }
+    if (isConfigInvalid_js_1.isConfigInvalid) {
+        return handleInvalidConfig();
+    }
+    else {
+        // From now on, renderContext.pageConfigs contains all the configuration data; getVikeConfig() isn't called anymore for this request
+    }
+    {
+        const pageContextHttpReponse = normalizeUrl(pageContextInit, httpRequestId);
+        if (pageContextHttpReponse)
+            return pageContextHttpReponse;
+    }
+    {
+        const pageContextHttpReponse = getPermanentRedirect(pageContextInit, httpRequestId);
+        if (pageContextHttpReponse)
+            return pageContextHttpReponse;
+    }
+    return await renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderContext, []);
+}
+async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderContext, pageContextsFromRewrite) {
+    (0, abort_js_1.assertNoInfiniteAbortLoop)(pageContextsFromRewrite.length, 
+    // There doesn't seem to be a way to count the number of HTTP redirects (vike don't have access to the HTTP request headers/cookies)
+    // https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
+    0);
+    let pageContextNominalPageSuccess;
+    let pageContextNominalPageInit = {};
+    {
+        const pageContextFromAllRewrites = (0, abort_js_1.getPageContextFromAllRewrites)(pageContextsFromRewrite);
+        (0, utils_js_1.objectAssign)(pageContextNominalPageInit, pageContextFromAllRewrites);
+    }
+    {
+        const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, renderContext, pageContextNominalPageInit._urlRewrite, httpRequestId);
+        (0, utils_js_1.objectAssign)(pageContextNominalPageInit, pageContextInitEnhanced);
+    }
+    let errNominalPage;
+    {
+        try {
+            pageContextNominalPageSuccess = await renderPageNominal(pageContextNominalPageInit);
+        }
+        catch (err) {
+            errNominalPage = err;
+            (0, utils_js_1.assert)(errNominalPage);
+            (0, loggerRuntime_js_1.logRuntimeError)(errNominalPage, httpRequestId);
+        }
+        if (!errNominalPage) {
+            (0, utils_js_1.assert)(pageContextNominalPageSuccess === pageContextNominalPageInit);
+        }
+    }
+    // Log upon 404
+    if (pageContextNominalPageSuccess &&
+        'is404' in pageContextNominalPageSuccess &&
+        pageContextNominalPageSuccess.is404 === true) {
+        await (0, index_js_2.log404)(pageContextNominalPageSuccess);
+    }
+    if (errNominalPage === undefined) {
+        (0, utils_js_1.assert)(pageContextNominalPageSuccess);
+        return pageContextNominalPageSuccess;
+    }
+    else {
+        (0, utils_js_1.assert)(errNominalPage);
+        (0, utils_js_1.assert)(pageContextNominalPageSuccess === undefined);
+        (0, utils_js_1.assert)(pageContextNominalPageInit);
+        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextNominalPageInit, 'urlOriginal', 'string'));
+        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPageInit, renderContext, httpRequestId);
+        if ((0, abort_js_1.isAbortError)(errNominalPage)) {
+            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageInit);
+            if (handled.pageContextReturn) {
+                // - throw redirect()
+                // - throw render(url)
+                // - throw render(abortStatusCode) if .pageContext.json request
+                return handled.pageContextReturn;
+            }
+            else {
+                // - throw render(abortStatusCode) if not .pageContext.json request
+            }
+            Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
+        }
+        {
+            const errorPageId = (0, error_page_js_1.getErrorPageId)(renderContext.pageFilesAll, renderContext.pageConfigs);
+            if (!errorPageId) {
+                (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { _pageId: null });
+                return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContextErrorPageInit);
+            }
+            else {
+                (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { _pageId: errorPageId });
+            }
+        }
+        let pageContextErrorPage;
+        try {
+            pageContextErrorPage = await (0, renderPageAlreadyRouted_js_1.renderPageAlreadyRouted)(pageContextErrorPageInit);
+        }
+        catch (errErrorPage) {
+            if ((0, abort_js_1.isAbortError)(errErrorPage)) {
+                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageInit);
+                // throw render(abortStatusCode)
+                if (!handled.pageContextReturn) {
+                    const pageContextAbort = errErrorPage._pageContextAbort;
+                    (0, utils_js_1.assertWarning)(false, `Failed to render error page because ${picocolors_1.default.cyan(pageContextAbort._abortCall)} was called: make sure ${picocolors_1.default.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
+                    const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
+                    return pageContextHttpReponseNull;
+                }
+                // `throw redirect()` / `throw render(url)`
+                return handled.pageContextReturn;
+            }
+            if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
+                (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
+            }
+            const pageContextHttpReponseNull = getPageContextHttpResponseNullWithError(errNominalPage, pageContextInit);
+            return pageContextHttpReponseNull;
+        }
+        return pageContextErrorPage;
+    }
+}
+function logHttpRequest(urlToShowToUser, httpRequestId) {
+    const clearErrors = globalObject.pendingRequestsCount === 0;
+    (0, loggerRuntime_js_1.logRuntimeInfo)?.(`HTTP request: ${picocolors_1.default.bold(urlToShowToUser)}`, httpRequestId, 'info', clearErrors);
+}
+function logHttpResponse(urlToShowToUser, httpRequestId, pageContextReturn) {
+    const statusCode = pageContextReturn.httpResponse?.statusCode ?? null;
+    const isSuccess = statusCode !== null && statusCode >= 200 && statusCode <= 399;
+    const isNominal = isSuccess || statusCode === 404;
+    const color = (s) => picocolors_1.default.bold(isSuccess ? picocolors_1.default.green(String(s)) : picocolors_1.default.red(String(s)));
+    const isRedirect = statusCode && 300 <= statusCode && statusCode <= 399;
+    const type = isRedirect ? 'redirect' : 'response';
+    if (isRedirect) {
+        (0, utils_js_1.assert)(pageContextReturn.httpResponse);
+        const headerRedirect = pageContextReturn.httpResponse.headers
+            .slice()
+            .reverse()
+            .find((header) => header[0] === 'Location');
+        (0, utils_js_1.assert)(headerRedirect);
+        const urlRedirect = headerRedirect[1];
+        urlToShowToUser = urlRedirect;
+    }
+    (0, loggerRuntime_js_1.logRuntimeInfo)?.(`HTTP ${type} ${picocolors_1.default.bold(urlToShowToUser)} ${color(statusCode ?? 'ERR')}`, httpRequestId, isNominal ? 'info' : 'error');
+}
+function getPageContextHttpResponseNullWithError(err, pageContextInit) {
+    const pageContextHttpReponseNull = {};
+    (0, utils_js_1.objectAssign)(pageContextHttpReponseNull, pageContextInit);
+    (0, utils_js_1.objectAssign)(pageContextHttpReponseNull, {
+        httpResponse: null,
+        errorWhileRendering: err
+    });
+    return pageContextHttpReponseNull;
+}
+function getPageContextHttpResponseNull(pageContextInit) {
+    const pageContextHttpReponseNull = {};
+    (0, utils_js_1.objectAssign)(pageContextHttpReponseNull, pageContextInit);
+    (0, utils_js_1.objectAssign)(pageContextHttpReponseNull, {
+        httpResponse: null,
+        errorWhileRendering: null
+    });
+    return pageContextHttpReponseNull;
+}
+async function renderPageNominal(pageContext) {
+    (0, utils_js_1.objectAssign)(pageContext, { errorWhileRendering: null });
+    // Check Base URL
+    {
+        const { urlWithoutPageContextRequestSuffix } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(pageContext.urlOriginal);
+        const hasBaseServer = (0, utils_js_1.parseUrl)(urlWithoutPageContextRequestSuffix, pageContext._baseServer).hasBaseServer || !!pageContext._urlRewrite;
+        if (!hasBaseServer) {
+            (0, utils_js_1.objectAssign)(pageContext, { httpResponse: null });
+            return pageContext;
+        }
+    }
+    // Route
+    {
+        const routeResult = await (0, index_js_1.route)(pageContext);
+        (0, utils_js_1.objectAssign)(pageContext, routeResult.pageContextAddendum);
+        (0, utils_js_1.objectAssign)(pageContext, { is404: pageContext._pageId ? null : true });
+        if (pageContext._pageId === null) {
+            const errorPageId = (0, error_page_js_1.getErrorPageId)(pageContext._pageFilesAll, pageContext._pageConfigs);
+            if (!errorPageId) {
+                (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, '_pageId', 'null'));
+                return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContext);
+            }
+            (0, utils_js_1.objectAssign)(pageContext, { _pageId: errorPageId });
+        }
+    }
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContext, '_pageId', 'string'));
+    // Render
+    const pageContextAfterRender = await (0, renderPageAlreadyRouted_js_1.renderPageAlreadyRouted)(pageContext);
+    (0, utils_js_1.assert)(pageContext === pageContextAfterRender);
+    return pageContextAfterRender;
+}
+async function getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPagePartial, renderContext, httpRequestId) {
+    const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, renderContext, null, httpRequestId);
+    (0, utils_js_1.assert)(errNominalPage);
+    const pageContext = {
+        ...pageContextInitEnhanced,
+        is404: false,
+        errorWhileRendering: errNominalPage,
+        routeParams: {}
+    };
+    (0, utils_js_1.objectAssign)(pageContext, {
+        _routeMatches: pageContextNominalPagePartial._routeMatches || 'ROUTE_ERROR'
+    });
+    (0, utils_js_1.assert)(pageContext.errorWhileRendering);
+    return pageContext;
+}
+function getPageContextInitEnhancedSSR(pageContextInit, renderContext, urlRewrite, httpRequestId) {
+    const { isClientSideNavigation, _urlHandler } = handleUrl(pageContextInit.urlOriginal, urlRewrite);
+    const pageContextInitEnhanced = (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, renderContext, {
+        ssr: {
+            urlRewrite,
+            urlHandler: _urlHandler,
+            isClientSideNavigation
+        }
+    });
+    (0, utils_js_1.objectAssign)(pageContextInitEnhanced, { _httpRequestId: httpRequestId });
+    return pageContextInitEnhanced;
+}
+function handleUrl(urlOriginal, urlRewrite) {
+    (0, utils_js_1.assert)(isUrlValid(urlOriginal));
+    (0, utils_js_1.assert)(urlRewrite === null || isUrlValid(urlRewrite));
+    const { isPageContextRequest } = (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(urlOriginal);
+    const pageContextAddendum = {
+        isClientSideNavigation: isPageContextRequest,
+        _urlHandler: (url) => (0, handlePageContextRequestUrl_js_1.handlePageContextRequestUrl)(url).urlWithoutPageContextRequestSuffix
+    };
+    return pageContextAddendum;
+}
+function isUrlValid(url) {
+    return url.startsWith('/') || url.startsWith('http');
+}
+function getRequestId() {
+    const httpRequestId = ++globalObject.httpRequestsCount;
+    (0, utils_js_1.assert)(httpRequestId >= 1);
+    return httpRequestId;
+}
+function skipRequest(urlOriginal) {
+    const isViteClientRequest = urlOriginal.endsWith('/@vite/client') || urlOriginal.startsWith('/@fs/');
+    (0, utils_js_1.assertWarning)(!isViteClientRequest, `The vike middleware renderPage() was called with the URL ${urlOriginal} which is unexpected because the HTTP request should have already been handled by Vite's development middleware. Make sure to 1. install Vite's development middleware and 2. add Vite's middleware *before* vike's middleware, see https://vike.dev/renderPage`, { onlyOnce: true });
+    return (urlOriginal.endsWith('/__vite_ping') ||
+        urlOriginal.endsWith('/favicon.ico') ||
+        !(0, utils_js_1.isParsable)(urlOriginal) ||
+        isViteClientRequest);
+}
+function normalizeUrl(pageContextInit, httpRequestId) {
+    const { trailingSlash, disableUrlNormalization } = (0, globalContext_js_1.getGlobalContext)();
+    if (disableUrlNormalization)
+        return null;
+    const { urlOriginal } = pageContextInit;
+    const urlNormalized = (0, utils_js_1.normalizeUrlPathname)(urlOriginal, trailingSlash);
+    if (!urlNormalized)
+        return null;
+    (0, loggerRuntime_js_1.logRuntimeInfo)?.(`URL normalized from ${picocolors_1.default.cyan(urlOriginal)} to ${picocolors_1.default.cyan(urlNormalized)} (https://vike.dev/url-normalization)`, httpRequestId, 'info');
+    const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)({ url: urlNormalized, statusCode: 301 }, pageContextInit.urlOriginal);
+    const pageContextHttpResponse = { ...pageContextInit, httpResponse };
+    return pageContextHttpResponse;
+}
+function getPermanentRedirect(pageContextInit, httpRequestId) {
+    const { redirects, baseServer } = (0, globalContext_js_1.getGlobalContext)();
+    const urlWithoutBase = (0, utils_js_1.removeBaseServer)(pageContextInit.urlOriginal, baseServer);
+    let urlOriginalPathnameWithouBase;
+    let origin = null;
+    let urlTarget = (0, utils_js_1.modifyUrlPathname)(urlWithoutBase, (urlPathname) => {
+        urlOriginalPathnameWithouBase = urlPathname;
+        const urlTargetWithOrigin = (0, resolveRedirects_js_1.resolveRedirects)(redirects, urlPathname);
+        if (urlTargetWithOrigin === null)
+            return null;
+        const { urlModified, origin: origin_ } = (0, utils_js_1.removeUrlOrigin)(urlTargetWithOrigin);
+        origin = origin_;
+        return urlModified;
+    });
+    if (origin)
+        urlTarget = (0, utils_js_1.addUrlOrigin)(urlTarget, origin);
+    (0, utils_js_1.assert)(urlOriginalPathnameWithouBase);
+    if (urlTarget === urlWithoutBase)
+        return null;
+    (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirect defined by your config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
+    urlTarget = (0, utils_js_1.prependBase)(urlTarget, baseServer);
+    (0, utils_js_1.assert)(urlTarget !== pageContextInit.urlOriginal);
+    const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)({ url: urlTarget, statusCode: 301 }, urlOriginalPathnameWithouBase);
+    const pageContextHttpResponse = { ...pageContextInit, httpResponse };
+    return pageContextHttpResponse;
+}
+async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageInit) {
+    (0, abort_js_1.logAbortErrorHandled)(errAbort, (0, globalContext_js_1.getGlobalContext)().isProduction, pageContextNominalPageInit);
+    const pageContextAbort = errAbort._pageContextAbort;
+    let pageContextSerialized;
+    if (pageContextNominalPageInit.isClientSideNavigation) {
+        if (pageContextAbort.abortStatusCode) {
+            const errorPageId = (0, error_page_js_1.getErrorPageId)(renderContext.pageFilesAll, renderContext.pageConfigs);
+            const abortCall = pageContextAbort._abortCall;
+            (0, utils_js_1.assert)(abortCall);
+            (0, utils_js_1.assertUsage)(errorPageId, `You called ${picocolors_1.default.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
+            const pageContext = {
+                _pageId: errorPageId,
+                ...pageContextAbort,
+                ...pageContextErrorPageInit,
+                ...renderContext
+            };
+            (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageFilesServerSide_js_1.loadPageFilesServerSide)(pageContext));
+            // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
+            pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext);
+        }
+        else {
+            pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextAbort)(pageContextAbort);
+        }
+        const httpResponse = await (0, createHttpResponseObject_js_1.createHttpResponsePageContextJson)(pageContextSerialized);
+        const pageContextReturn = { httpResponse };
+        return { pageContextReturn };
+    }
+    if (pageContextAbort._urlRewrite) {
+        const pageContextReturn = await renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderContext, [
+            ...pageContextsFromRewrite,
+            pageContextAbort
+        ]);
+        Object.assign(pageContextReturn, pageContextAbort);
+        return { pageContextReturn };
+    }
+    if (pageContextAbort._urlRedirect) {
+        const pageContextReturn = {
+            ...pageContextInit,
+            ...pageContextAbort
+        };
+        const httpResponse = (0, createHttpResponseObject_js_1.createHttpResponseObjectRedirect)(pageContextAbort._urlRedirect, pageContextNominalPageInit.urlPathname);
+        (0, utils_js_1.objectAssign)(pageContextReturn, { httpResponse });
+        return { pageContextReturn };
+    }
+    (0, utils_js_1.assert)(pageContextAbort.abortStatusCode);
+    return { pageContextAbort };
+}

package/dist/cjs/node/runtime/utils.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../../utils/trackLogs.js");
+// We assume all runtime entries will load this utils.ts file
+const onLoad_js_1 = require("./onLoad.js");
+(0, onLoad_js_1.onLoad)();
+__exportStar(require("../../utils/assert.js"), exports);
+__exportStar(require("../../utils/cast.js"), exports);
+__exportStar(require("../../utils/checkType.js"), exports);
+__exportStar(require("../../utils/isCallable.js"), exports);
+__exportStar(require("../../utils/isBrowser.js"), exports);
+__exportStar(require("../../utils/isPlainObject.js"), exports);
+__exportStar(require("../../utils/isPromise.js"), exports);
+__exportStar(require("../../utils/hasProp.js"), exports);
+__exportStar(require("../../utils/parseUrl.js"), exports);
+__exportStar(require("../../utils/parseUrl-extras.js"), exports);
+__exportStar(require("../../utils/slice.js"), exports);
+__exportStar(require("../../utils/sorter.js"), exports);
+__exportStar(require("../../utils/projectInfo.js"), exports);
+__exportStar(require("../../utils/isObject.js"), exports);
+__exportStar(require("../../utils/objectAssign.js"), exports);
+__exportStar(require("../../utils/PromiseType.js"), exports);
+__exportStar(require("../../utils/compareString.js"), exports);
+__exportStar(require("../../utils/isObjectWithKeys.js"), exports);
+__exportStar(require("../../utils/stringifyStringArray.js"), exports);
+__exportStar(require("../../utils/unique.js"), exports);
+__exportStar(require("../../utils/filesystemPathHandling.js"), exports);
+__exportStar(require("../../utils/getOutDirs.js"), exports);
+__exportStar(require("../../utils/capitalizeFirstLetter.js"), exports);
+__exportStar(require("../../utils/debugGlob.js"), exports);
+__exportStar(require("../../utils/isEquivalentError.js"), exports);
+__exportStar(require("../../utils/styleFileRE.js"), exports);
+__exportStar(require("../../utils/hasPropertyGetter.js"), exports);
+__exportStar(require("../../utils/debug.js"), exports);
+__exportStar(require("../../utils/urlToFile.js"), exports);
+__exportStar(require("../../utils/getGlobalObject.js"), exports);
+__exportStar(require("../../shared/hooks/executeHook.js"), exports);
+__exportStar(require("../../utils/isStemPackageName.js"), exports);
+__exportStar(require("../../utils/freezePartial.js"), exports);
+__exportStar(require("../../utils/isNpmPackage.js"), exports);
+__exportStar(require("../../utils/isNotNullish.js"), exports);
+__exportStar(require("../../utils/isScriptFile.js"), exports);
+__exportStar(require("../../utils/removeFileExtention.js"), exports);
+__exportStar(require("../../utils/objectEntries.js"), exports);
+__exportStar(require("../../utils/isStringRecord.js"), exports);
+__exportStar(require("../../utils/getFileExtension.js"), exports);
+__exportStar(require("../../utils/assertIsNotProductionRuntime.js"), exports);
+__exportStar(require("../../utils/virtual-files.js"), exports);
+__exportStar(require("../../utils/path-shim.js"), exports);
+__exportStar(require("../../utils/nodeEnv.js"), exports);
+__exportStar(require("../../utils/isHtml.js"), exports);
+__exportStar(require("../../utils/warnIfErrorIsNotObject.js"), exports);
+__exportStar(require("../../utils/dynamicImport.js"), exports);
+__exportStar(require("../../utils/stripAnsi.js"), exports);
+__exportStar(require("../../utils/getTerminWidth.js"), exports);
+__exportStar(require("../../utils/truncateString.js"), exports);
+__exportStar(require("../../utils/autoRetry.js"), exports);

package/dist/cjs/node/shared/ViteManifest.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/node/shared/assertPluginManifest.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPluginManifest = void 0;
+const assertRuntimeManifest_js_1 = require("./assertRuntimeManifest.js");
+const utils_js_1 = require("./utils.js");
+function assertPluginManifest(pluginManifest) {
+    (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(pluginManifest));
+    (0, utils_js_1.assertUsage)(pluginManifest.version === utils_js_1.projectInfo.projectVersion, `Re-build your app (you're using vike@${utils_js_1.projectInfo.projectVersion} but your app was built with vike@${pluginManifest.version})`);
+    (0, assertRuntimeManifest_js_1.assertRuntimeManifest)(pluginManifest);
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pluginManifest, 'usesClientRouter', 'boolean'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pluginManifest, 'version', 'string'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pluginManifest, 'manifestKeyMap', 'object'));
+    const { manifestKeyMap } = pluginManifest;
+    (0, utils_js_1.assert)((0, utils_js_1.isStringRecord)(manifestKeyMap));
+    // Avoid:
+    // ```
+    // Uncaught (in promise) TypeError: Cannot set property manifestKeyMap of #<Object> which has only a getter
+    // ```
+    // See https://github.com/vikejs/vike/issues/596
+    const pluginManifestClone = { ...pluginManifest };
+    (0, utils_js_1.objectAssign)(pluginManifestClone, { manifestKeyMap });
+    (0, utils_js_1.checkType)(pluginManifestClone);
+}
+exports.assertPluginManifest = assertPluginManifest;

package/dist/cjs/node/shared/assertRuntimeManifest.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertRuntimeManifest = void 0;
+const utils_js_1 = require("./utils.js");
+function assertRuntimeManifest(obj) {
+    (0, utils_js_1.assert)(obj);
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(obj));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(obj, 'baseServer', 'string'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(obj, 'baseAssets', 'string'));
+    (0, utils_js_1.assert)((0, utils_js_1.isBaseServer)(obj.baseServer));
+    (0, utils_js_1.assert)((0, utils_js_1.isBaseAssets)(obj.baseAssets));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(obj, 'includeAssetsImportedByServer', 'boolean'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(obj, 'redirects', 'object'));
+    (0, utils_js_1.castType)(obj);
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(obj, 'trailingSlash', 'boolean'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(obj, 'disableUrlNormalization', 'boolean'));
+    (0, utils_js_1.checkType)(obj);
+}
+exports.assertRuntimeManifest = assertRuntimeManifest;

package/dist/cjs/node/shared/extractAssetsQuery.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractAssetsRemoveQuery = exports.extractAssetsAddQuery = void 0;
+// We import from node/utils.ts insead of node/plugin/utils.ts because this file is loaded by the server runtime
+const utils_js_1 = require("./utils.js");
+const query = 'extractAssets';
+function extractAssetsAddQuery(id) {
+    const fileExtension = (0, utils_js_1.getFileExtension)(id);
+    (0, utils_js_1.assert)(fileExtension || id.includes('virtual:vike:'));
+    if (!fileExtension)
+        return `${id}?${query}`;
+    if (id.includes('?')) {
+        id = id.replace('?', `?${query}&`);
+    }
+    else {
+        id = `${id}?${query}&lang.${fileExtension}`;
+    }
+    return id;
+}
+exports.extractAssetsAddQuery = extractAssetsAddQuery;
+function extractAssetsRemoveQuery(id) {
+    if (!id.includes('?'))
+        return id;
+    const suffix = `?${query}`;
+    // Only supports 'virtual:vike:' IDs
+    (0, utils_js_1.assert)(id.endsWith(query));
+    return id.slice(0, -1 * suffix.length);
+}
+exports.extractAssetsRemoveQuery = extractAssetsRemoveQuery;

package/dist/cjs/node/shared/getClientEntryFilePath.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClientEntryFilePath = void 0;
+const utils_js_1 = require("../../shared/page-configs/utils.js");
+const utils_js_2 = require("./utils.js");
+function getClientEntryFilePath(pageConfig) {
+    const configName = 'client';
+    const configValue = (0, utils_js_1.getConfigValue)(pageConfig, configName, 'string');
+    if (!configValue)
+        return null;
+    const definedAtInfo = (0, utils_js_1.getConfigDefinedAtInfo)(pageConfig, configName);
+    const { value } = configValue;
+    // Users should be able to suppress client entry by setting its value to null
+    (0, utils_js_2.assert)(value !== null);
+    const clientEntryFilePath = definedAtInfo.filePath;
+    return clientEntryFilePath;
+}
+exports.getClientEntryFilePath = getClientEntryFilePath;

package/dist/cjs/node/shared/getConfigVike.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfigVike = void 0;
+async function getConfigVike(config) {
+    const configVike = (await config.configVikePromise);
+    return configVike;
+}
+exports.getConfigVike = getConfigVike;

package/dist/cjs/node/shared/utils.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+__exportStar(require("../../utils/assert.js"), exports);
+__exportStar(require("../../utils/getFileExtension.js"), exports);
+__exportStar(require("../../utils/isPlainObject.js"), exports);
+__exportStar(require("../../utils/projectInfo.js"), exports);
+__exportStar(require("../../utils/checkType.js"), exports);
+__exportStar(require("../../utils/hasProp.js"), exports);
+__exportStar(require("../../utils/isStringRecord.js"), exports);
+__exportStar(require("../../utils/objectAssign.js"), exports);
+__exportStar(require("../../utils/checkType.js"), exports);
+__exportStar(require("../../utils/hasProp.js"), exports);
+__exportStar(require("../../utils/parseUrl.js"), exports);
+__exportStar(require("../../utils/parseUrl-extras.js"), exports);
+__exportStar(require("../../utils/isObject.js"), exports);
+__exportStar(require("../../utils/virtual-files.js"), exports);
+__exportStar(require("../../utils/assertIsNotBrowser.js"), exports);

package/dist/cjs/node/shared/virtual-files/virtualFileImportUserCode.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVirtualFileIdImportUserCode = exports.virtualFileIdImportUserCodeClientCR = exports.virtualFileIdImportUserCodeClientSR = exports.virtualFileIdImportUserCodeServer = void 0;
+const utils_js_1 = require("../utils.js");
+const idBase = 'virtual:vike:importUserCode';
+const virtualFileIdImportUserCodeServer = `${idBase}:server`;
+exports.virtualFileIdImportUserCodeServer = virtualFileIdImportUserCodeServer;
+const virtualFileIdImportUserCodeClientSR = `${idBase}:client:server-routing`;
+exports.virtualFileIdImportUserCodeClientSR = virtualFileIdImportUserCodeClientSR;
+const virtualFileIdImportUserCodeClientCR = `${idBase}:client:client-routing`;
+exports.virtualFileIdImportUserCodeClientCR = virtualFileIdImportUserCodeClientCR;
+function isVirtualFileIdImportUserCode(id) {
+    id = (0, utils_js_1.getVirtualFileId)(id);
+    if (!id.startsWith(idBase))
+        return false;
+    (0, utils_js_1.assert)(
+    // prettier-ignore
+    [
+        virtualFileIdImportUserCodeServer,
+        virtualFileIdImportUserCodeClientCR,
+        virtualFileIdImportUserCodeClientSR
+    ].includes(id));
+    const isForClientSide = id !== virtualFileIdImportUserCodeServer;
+    const isClientRouting = id === virtualFileIdImportUserCodeClientCR;
+    return { isForClientSide, isClientRouting };
+}
+exports.isVirtualFileIdImportUserCode = isVirtualFileIdImportUserCode;