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

package/dist/cjs/node/runtime/index-common.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPageRenderer = exports._injectAssets = exports.stampPipe = exports.pipeStream = exports.pipeNodeStream = exports.pipeWebStream = exports.dangerouslySkipEscape = exports.escapeInject = exports.renderPage = void 0;
+var renderPage_js_1 = require("./renderPage.js");
+Object.defineProperty(exports, "renderPage", { enumerable: true, get: function () { return renderPage_js_1.renderPage; } });
+var renderHtml_js_1 = require("./html/renderHtml.js");
+Object.defineProperty(exports, "escapeInject", { enumerable: true, get: function () { return renderHtml_js_1.escapeInject; } });
+Object.defineProperty(exports, "dangerouslySkipEscape", { enumerable: true, get: function () { return renderHtml_js_1.dangerouslySkipEscape; } });
+var stream_js_1 = require("./html/stream.js");
+Object.defineProperty(exports, "pipeWebStream", { enumerable: true, get: function () { return stream_js_1.pipeWebStream; } });
+Object.defineProperty(exports, "pipeNodeStream", { enumerable: true, get: function () { return stream_js_1.pipeNodeStream; } });
+Object.defineProperty(exports, "pipeStream", { enumerable: true, get: function () { return stream_js_1.pipeStream; } });
+Object.defineProperty(exports, "stampPipe", { enumerable: true, get: function () { return stream_js_1.stampPipe; } });
+// TODO/v1-release: remove
+var injectAssets__public_js_1 = require("./html/injectAssets/injectAssets__public.js");
+Object.defineProperty(exports, "_injectAssets", { enumerable: true, get: function () { return injectAssets__public_js_1.injectAssets__public; } });
+// TODO/v1-release: remove
+var createPageRenderer_js_1 = require("../createPageRenderer.js");
+Object.defineProperty(exports, "createPageRenderer", { enumerable: true, get: function () { return createPageRenderer_js_1.createPageRenderer; } });
+// Help Telefunc detect the user's stack
+globalThis._isVitePluginSsr = true;
+globalThis._isVike = true;
+require("./page-files/setup.js");

package/dist/cjs/node/runtime/index-deprecated.js

@@ -0,0 +1,61 @@
+"use strict";
+// TODO/v1-release: replace this with:
+// assertUsage(false, "`import { something } from 'vike'` doesn't exist: instead import from 'vike/server', 'vike/client', 'vike/plugin', ...")
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderErrorPage = void 0;
+__exportStar(require("./index-common.js"), exports);
+__exportStar(require("../../types/index-dreprecated.js"), exports);
+const utils_js_1 = require("./utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const abort_js_1 = require("../../shared/route/abort.js");
+/** @deprecated
+ * Replace:
+ *   ```
+ *   import { RenderErrorPage } from 'vike'
+ *   ```
+ * With:
+ *   ```
+ *   import { render } from 'vike/abort'
+ *   ```
+ *
+ * See https://vike.dev/render
+ */
+const RenderErrorPage = (...args) => {
+    (0, utils_js_1.assertWarning)(false, [
+        'Replace:',
+        picocolors_1.default.red("  import { RenderErrorPage } from 'vike'"),
+        'With:',
+        picocolors_1.default.green("  import { render } from 'vike/abort'"),
+        'See https://vike.dev/render'
+    ].join('\n'), { onlyOnce: true, showStackTrace: true });
+    return (0, abort_js_1.RenderErrorPage)(...args);
+};
+exports.RenderErrorPage = RenderErrorPage;
+(0, utils_js_1.assertWarning)(false, [
+    'You have following imports which are outdated:',
+    picocolors_1.default.red("  import { something } from 'vike'"),
+    'Replace them with:',
+    picocolors_1.default.green("  import { something } from 'vike/server'"),
+    `Or if ${picocolors_1.default.cyan('something')} is a type:`,
+    picocolors_1.default.green("  import type { something } from 'vike/types'"),
+    "Make sure to import renderPage(), escapeInject, html, dangerouslySkipEscape(), pipeWebStream(), pipeNodeStream(), pipeStream(), stampPipe() from 'vike/server'. (Or inspect the error stack below to find the import causing this warning.)"
+].join('\n'), { showStackTrace: true, onlyOnce: true });
+const utils_js_2 = require("./utils.js");
+(0, utils_js_2.assertUsage)(!(0, utils_js_2.isBrowser)(), "It's forbidden to `import { something } from 'vike'` in code loaded in the browser: the module 'vike' is a server-only module.", { showStackTrace: true });

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

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./index-common.js"), exports);
+const utils_js_1 = require("./utils.js");
+(0, utils_js_1.assertUsage)(!(0, utils_js_1.isBrowser)(), "It's forbidden to `import { something } from 'vike/server'` in code loaded on the client-side: the module 'vike/server' is a server-only module.", { showStackTrace: true });

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onLoad = void 0;
+const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
+const assertNodeVersion_js_1 = require("../../utils/assertNodeVersion.js");
+const require_shim_1 = require("@brillout/require-shim");
+function onLoad() {
+    (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+    (0, assertNodeVersion_js_1.assertNodeVersion)();
+    (0, require_shim_1.installRequireShim)();
+}
+exports.onLoad = onLoad;

package/dist/cjs/node/runtime/page-files/setup.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getPageFiles_js_1 = require("../../../shared/getPageFiles.js");
+const utils_js_1 = require("../utils.js");
+const globalContext_js_1 = require("../globalContext.js");
+const virtualFileImportUserCode_js_1 = require("../../shared/virtual-files/virtualFileImportUserCode.js");
+(0, getPageFiles_js_1.setPageFilesAsync)(getPageFilesExports);
+async function getPageFilesExports() {
+    const viteDevServer = (0, globalContext_js_1.getViteDevServer)();
+    (0, utils_js_1.assert)(viteDevServer);
+    let moduleExports;
+    try {
+        moduleExports = await viteDevServer.ssrLoadModule(virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer);
+    }
+    catch (err) {
+        (0, utils_js_1.debugGlob)(`Glob error: ${virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer} transpile error: `, err);
+        throw err;
+    }
+    moduleExports = moduleExports.default || moduleExports;
+    (0, utils_js_1.debugGlob)('Glob result: ', moduleExports);
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(moduleExports));
+    return moduleExports;
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzePage = void 0;
+const determineClientEntry_js_1 = require("../../../shared/getPageFiles/analyzePageClientSide/determineClientEntry.js");
+const analyzePageClientSide_js_1 = require("../../../shared/getPageFiles/analyzePageClientSide.js");
+const virtualFilePageConfigValuesAll_js_1 = require("../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
+const analyzeClientSide_js_1 = require("../../../shared/getPageFiles/analyzeClientSide.js");
+const globalContext_js_1 = require("../globalContext.js");
+const getClientEntryFilePath_js_1 = require("../../shared/getClientEntryFilePath.js");
+function analyzePage(pageFilesAll, pageConfig, pageId) {
+    if (pageConfig) {
+        const { isClientSideRenderable, isClientRouting } = (0, analyzeClientSide_js_1.analyzeClientSide)(pageConfig, pageFilesAll, pageId);
+        const clientFilePath = (0, getClientEntryFilePath_js_1.getClientEntryFilePath)(pageConfig);
+        const clientEntry = !isClientSideRenderable ? clientFilePath : (0, determineClientEntry_js_1.getVikeClientEntry)(isClientRouting);
+        const clientDependencies = [];
+        clientDependencies.push({
+            id: (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageConfig.pageId, true),
+            onlyAssets: false,
+            eagerlyImported: false
+        });
+        // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
+        if (!(0, globalContext_js_1.getGlobalContext)().isProduction) {
+            clientDependencies.push({
+                id: (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageConfig.pageId, false),
+                onlyAssets: true,
+                eagerlyImported: false
+            });
+        }
+        /* Remove?
+        Object.values(pageConfig.configElements).forEach((configElement) => {
+          if (configElement.importFilePath) {
+            const { env } = configElement
+            assert(env)
+            const onlyAssets = env === 'server-only'
+            const eagerlyImported = env === '_routing-eager'
+            if (onlyAssets || eagerlyImported) {
+              clientDependencies.push({
+                id: configElement.importFilePath,
+                onlyAssets,
+                eagerlyImported
+              })
+            }
+          }
+        })
+        */
+        const clientEntries = [];
+        if (clientEntry) {
+            clientDependencies.push({
+                id: clientEntry,
+                onlyAssets: false,
+                eagerlyImported: false
+            });
+            clientEntries.push(clientEntry);
+        }
+        return {
+            isHtmlOnly: !isClientSideRenderable,
+            isClientRouting,
+            clientEntries,
+            clientDependencies,
+            // pageFilesClientSide and pageFilesServerSide are only used for debugging
+            pageFilesClientSide: [],
+            pageFilesServerSide: []
+        };
+    }
+    else {
+        return (0, analyzePageClientSide_js_1.analyzePageClientSide)(pageFilesAll, pageId);
+    }
+}
+exports.analyzePage = analyzePage;

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

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertArguments = void 0;
+const utils_js_1 = require("../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function assertArguments(...args) {
+    const prefix = `[renderPage(${picocolors_1.default.cyan('pageContextInit')})]`;
+    const pageContextInit = args[0];
+    (0, utils_js_1.assertUsage)(pageContextInit !== undefined && pageContextInit !== null, prefix + ` argument ${picocolors_1.default.cyan('pageContextInit')} is missing`, { showStackTrace: true });
+    const len = args.length;
+    (0, utils_js_1.assertUsage)(len === 1, `${prefix} You passed ${len} arguments but renderPage() accepts only one argument.'`, {
+        showStackTrace: true
+    });
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(pageContextInit), `${prefix} ${picocolors_1.default.cyan('pageContextInit')} should be an object, but ${picocolors_1.default.cyan(`typeof pageContextInit === ${JSON.stringify(typeof pageContextInit)}`)}`, { showStackTrace: true });
+    // TODO/v1-release: remove
+    if ('url' in pageContextInit) {
+        (0, utils_js_1.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;
+    }
+    (0, utils_js_1.assert)(!('url' in pageContextInit));
+    (0, utils_js_1.assertUsage)((0, utils_js_1.hasProp)(pageContextInit, 'urlOriginal'), prefix + ` ${picocolors_1.default.cyan('pageContextInit')} is missing the property ${picocolors_1.default.cyan('pageContextInit.urlOriginal')}`, { showStackTrace: true });
+    const { urlOriginal } = pageContextInit;
+    (0, utils_js_1.assertUsage)(typeof urlOriginal === 'string', prefix +
+        ` ${picocolors_1.default.cyan('pageContextInit.urlOriginal')} should be a string but ${picocolors_1.default.cyan(`typeof pageContextInit.urlOriginal === ${JSON.stringify(typeof urlOriginal)}`)}`, { showStackTrace: true });
+    (0, utils_js_1.assertUsage)(urlOriginal.startsWith('/') || urlOriginal.startsWith('https://') || urlOriginal.startsWith('http://'), prefix +
+        ` ${picocolors_1.default.cyan('pageContextInit.urlOriginal')} should start with ${picocolors_1.default.cyan('/')} (e.g. ${picocolors_1.default.cyan('/product/42')}), ${picocolors_1.default.cyan('http://')}, or ${picocolors_1.default.cyan('https://')} (e.g. ${picocolors_1.default.cyan('https://example.com/product/42')}), but ${picocolors_1.default.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) {
+        (0, utils_js_1.assertUsage)(false, prefix +
+            ` ${picocolors_1.default.cyan('pageContextInit.urlOriginal')} should be a URL but ${picocolors_1.default.cyan(`pageContextInit.urlOriginal === ${JSON.stringify(urlOriginal)}`)}`, { showStackTrace: true });
+    }
+}
+exports.assertArguments = assertArguments;

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

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNoInfiniteHttpRedirect = void 0;
+const utils_js_1 = require("../../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const globalObject = (0, utils_js_1.getGlobalObject)('assertNoInfiniteHttpRedirect.ts', {
+    redirectGraph: {}
+});
+function assertNoInfiniteHttpRedirect(urlRedirectOriginal, urlRedirectPathnameLogical) {
+    if (urlRedirectOriginal.startsWith('http')) {
+        // We assume that the redirect points to an external origin, and we can therefore assume that the app doesn't define an infinite loop (in itself).
+        //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin: the user usually passes the URL without origin.
+        //    ```js
+        //    // URL origin is usually missing
+        //    renderPage({ urlOriginal: '/some/pathname' })
+        //    ```
+        return;
+    }
+    (0, utils_js_1.assert)(urlRedirectOriginal.startsWith('/'));
+    (0, utils_js_1.assert)(urlRedirectPathnameLogical.startsWith('/'));
+    const graph = copy(globalObject.redirectGraph);
+    graph[urlRedirectOriginal] ?? (graph[urlRedirectOriginal] = new Set());
+    graph[urlRedirectOriginal].add(urlRedirectPathnameLogical);
+    validate(graph);
+    globalObject.redirectGraph = graph;
+}
+exports.assertNoInfiniteHttpRedirect = assertNoInfiniteHttpRedirect;
+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 check(G, n, path) {
+    if (path.includes(n)) {
+        const cycle = path.slice(path.indexOf(n)).concat(n);
+        (0, utils_js_1.assertUsage)(false, `Infinite loop of HTTP URL redirects: ${cycle.map(picocolors_1.default.cyan).join(' -> ')}`);
+    }
+    G[n]?.forEach((node) => check(G, node, [...path, n]));
+}
+function validate(G) {
+    Object.keys(G).forEach((n) => check(G, n, []));
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpResponseObjectRedirect = exports.createHttpResponsePageContextJson = exports.createHttpResponseObject = void 0;
+const utils_js_1 = require("../utils.js");
+const error_page_js_1 = require("../../../shared/error-page.js");
+const getHttpResponseBody_js_1 = require("./getHttpResponseBody.js");
+const getEarlyHints_js_1 = require("./getEarlyHints.js");
+const assertNoInfiniteHttpRedirect_js_1 = require("./createHttpResponseObject/assertNoInfiniteHttpRedirect.js");
+async function createHttpResponseObject(htmlRender, renderHook, pageContext) {
+    if (htmlRender === null) {
+        return null;
+    }
+    let statusCode = pageContext.abortStatusCode;
+    if (!statusCode) {
+        const isError = !pageContext._pageId || (0, error_page_js_1.isErrorPage)(pageContext._pageId, pageContext._pageConfigs);
+        if (pageContext.errorWhileRendering) {
+            (0, utils_js_1.assert)(isError);
+        }
+        if (!isError) {
+            (0, utils_js_1.assert)(pageContext.is404 === null);
+            statusCode = 200;
+        }
+        else {
+            (0, utils_js_1.assert)(pageContext.is404 === true || pageContext.is404 === false);
+            statusCode = pageContext.is404 ? 404 : 500;
+        }
+    }
+    const earlyHints = (0, getEarlyHints_js_1.getEarlyHints)(await pageContext.__getPageAssets());
+    return getHttpResponse(statusCode, 'text/html;charset=utf-8', [], htmlRender, earlyHints, renderHook);
+}
+exports.createHttpResponseObject = createHttpResponseObject;
+async function createHttpResponsePageContextJson(pageContextSerialized) {
+    const httpResponse = getHttpResponse(200, 'application/json', [], pageContextSerialized, [], null);
+    return httpResponse;
+}
+exports.createHttpResponsePageContextJson = createHttpResponsePageContextJson;
+function createHttpResponseObjectRedirect({ url, statusCode }, 
+// The URL pathname we assume the redirect to be logically based on
+urlPathnameLogical) {
+    (0, assertNoInfiniteHttpRedirect_js_1.assertNoInfiniteHttpRedirect)(url, urlPathnameLogical);
+    (0, utils_js_1.assert)(url);
+    (0, utils_js_1.assert)(statusCode);
+    (0, utils_js_1.assert)(300 <= statusCode && statusCode <= 399);
+    const headers = [['Location', url]];
+    return getHttpResponse(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 ${url}</p>`);
+}
+exports.createHttpResponseObjectRedirect = createHttpResponseObjectRedirect;
+function getHttpResponse(statusCode, contentType, headers, htmlRender, earlyHints = [], renderHook = null) {
+    headers.push(['Content-Type', contentType]);
+    (0, utils_js_1.assert)(renderHook || typeof htmlRender === 'string');
+    return {
+        statusCode,
+        headers,
+        // TODO/v1-release: remove
+        get contentType() {
+            (0, utils_js_1.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 (0, getHttpResponseBody_js_1.getHttpResponseBody)(htmlRender, renderHook);
+        },
+        ...(0, getHttpResponseBody_js_1.getHttpResponseBodyStreamHandlers)(htmlRender, renderHook)
+    };
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugPageFiles = void 0;
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const utils_js_1 = require("../utils.js");
+function debugPageFiles({ pageContext, isHtmlOnly, isClientRouting, pageFilesLoaded, pageFilesServerSide, pageFilesClientSide, clientEntries, clientDependencies }) {
+    const debug = (0, utils_js_1.createDebugger)('vike:pageFiles', { serialization: { emptyArray: 'None' } });
+    const padding = '   - ';
+    debug('All page files:', printPageFiles(pageContext._pageFilesAll, true)); // TODO
+    debug(`URL:`, pageContext.urlOriginal);
+    debug.options({ serialization: { emptyArray: 'No match' } })(`Routing:`, printRouteMatches(pageContext._routeMatches));
+    debug(`pageId:`, pageContext._pageId);
+    debug('Page type:', isHtmlOnly ? 'HTML-only' : 'SSR/SPA');
+    debug(`Routing type:`, !isHtmlOnly && isClientRouting ? 'Client Routing' : 'Server Routing');
+    debug('Server-side page files:', printPageFiles(pageFilesLoaded));
+    (0, utils_js_1.assert)(samePageFiles(pageFilesLoaded, pageFilesServerSide));
+    debug('Client-side page files:', printPageFiles(pageFilesClientSide));
+    debug('Client-side entries:', clientEntries);
+    debug('Client-side dependencies:', clientDependencies);
+    return;
+    function printRouteMatches(routeMatches) {
+        if (routeMatches === 'ROUTE_ERROR') {
+            return 'Routing Failed';
+        }
+        if (routeMatches === 'CUSTOM_ROUTE') {
+            return 'Custom Routing';
+        }
+        return routeMatches;
+    }
+    function printPageFiles(pageFiles, genericPageFilesLast = false) {
+        if (pageFiles.length === 0) {
+            return 'None';
+        }
+        return ('\n' +
+            pageFiles
+                .sort((p1, p2) => p1.filePath.localeCompare(p2.filePath))
+                .sort((0, utils_js_1.makeFirst)((p) => (p.isRendererPageFile ? !genericPageFilesLast : null)))
+                .sort((0, utils_js_1.makeFirst)((p) => (p.isDefaultPageFile ? !genericPageFilesLast : null)))
+                .map((p) => p.filePath)
+                .map((s) => s.split('_default.page.').join(`${picocolors_1.default.blue('_default')}.page.`))
+                .map((s) => s.split('/renderer/').join(`/${picocolors_1.default.red('renderer')}/`))
+                .map((s) => padding + s)
+                .join('\n'));
+    }
+}
+exports.debugPageFiles = debugPageFiles;
+function samePageFiles(pageFiles1, pageFiles2) {
+    return (pageFiles1.every((p1) => pageFiles2.some((p2) => p2.filePath === p1.filePath)) &&
+        pageFiles2.every((p2) => pageFiles1.some((p1) => p1.filePath === p2.filePath)));
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeOnBeforeRenderHooks = void 0;
+const getHook_js_1 = require("../../../shared/hooks/getHook.js");
+const preparePageContextForUserConsumptionServerSide_js_1 = require("./preparePageContextForUserConsumptionServerSide.js");
+const utils_js_1 = require("../utils.js");
+const assertOnBeforeRenderHookReturn_js_1 = require("../../../shared/assertOnBeforeRenderHookReturn.js");
+async function executeOnBeforeRenderHooks(pageContext) {
+    if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
+        return;
+    }
+    const hook = (0, getHook_js_1.getHook)(pageContext, 'onBeforeRender');
+    if (!hook) {
+        return;
+    }
+    const onBeforeRender = hook.hookFn;
+    (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext);
+    const hookResult = await (0, utils_js_1.executeHook)(() => onBeforeRender(pageContext), 'onBeforeRender', hook.hookFilePath);
+    (0, assertOnBeforeRenderHookReturn_js_1.assertOnBeforeRenderHookReturn)(hookResult, hook.hookFilePath);
+    const pageContextFromHook = hookResult?.pageContext;
+    Object.assign(pageContext, pageContextFromHook);
+}
+exports.executeOnBeforeRenderHooks = executeOnBeforeRenderHooks;

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

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeOnRenderHtmlHook = void 0;
+const renderHtml_js_1 = require("../html/renderHtml.js");
+const getHook_js_1 = require("../../../shared/hooks/getHook.js");
+const utils_js_1 = require("../utils.js");
+const stream_js_1 = require("../html/stream.js");
+const assertPageContextProvidedByUser_js_1 = require("../../../shared/assertPageContextProvidedByUser.js");
+const preparePageContextForUserConsumptionServerSide_js_1 = require("./preparePageContextForUserConsumptionServerSide.js");
+const assertHookReturnedObject_js_1 = require("../../../shared/assertHookReturnedObject.js");
+const loggerRuntime_js_1 = require("./loggerRuntime.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+async function executeOnRenderHtmlHook(pageContext) {
+    const hookFound = getRenderHook(pageContext);
+    const { renderHook, hookFn } = hookFound;
+    (0, utils_js_1.objectAssign)(pageContext, { _renderHook: renderHook });
+    (0, preparePageContextForUserConsumptionServerSide_js_1.preparePageContextForUserConsumptionServerSide)(pageContext);
+    const hookReturnValue = await (0, utils_js_1.executeHook)(() => hookFn(pageContext), renderHook.hookName, renderHook.hookFilePath);
+    const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturnValue, renderHook);
+    Object.assign(pageContext, pageContextProvidedByRenderHook);
+    (0, utils_js_1.objectAssign)(pageContext, { _pageContextPromise: pageContextPromise });
+    if (documentHtml === null || documentHtml === undefined) {
+        return { htmlRender: null, renderHook };
+    }
+    const onErrorWhileStreaming = (err) => {
+        // Should the stream inject the following?
+        // ```
+        // <script>console.error("An error occurred on the server while streaming the app to HTML. Check the server logs for more information.")</script>
+        // ```
+        (0, loggerRuntime_js_1.logRuntimeError)(err, pageContext._httpRequestId);
+        if (!pageContext.errorWhileRendering) {
+            pageContext.errorWhileRendering = err;
+        }
+    };
+    const htmlRender = await (0, renderHtml_js_1.renderDocumentHtml)(documentHtml, pageContext, onErrorWhileStreaming, injectFilter);
+    (0, utils_js_1.assert)(typeof htmlRender === 'string' || (0, stream_js_1.isStream)(htmlRender));
+    return { htmlRender, renderHook };
+}
+exports.executeOnRenderHtmlHook = executeOnRenderHtmlHook;
+function getRenderHook(pageContext) {
+    let hookFound;
+    {
+        let hook;
+        let hookName = undefined;
+        hook = (0, getHook_js_1.getHook)(pageContext, 'onRenderHtml');
+        if (hook) {
+            hookName = 'onRenderHtml';
+        }
+        else {
+            hook = (0, getHook_js_1.getHook)(pageContext, 'render');
+            if (hook) {
+                hookName = 'render';
+            }
+        }
+        if (hook) {
+            (0, utils_js_1.assert)(hookName);
+            const { hookFilePath, hookFn } = hook;
+            hookFound = {
+                hookFn,
+                renderHook: { hookFilePath, hookName }
+            };
+        }
+    }
+    if (!hookFound) {
+        const hookName = pageContext._pageConfigs.length > 0 ? 'onRenderHtml' : 'render';
+        (0, utils_js_1.assertUsage)(false, [
+            `No ${hookName}() hook found, see https://vike.dev/${hookName}`
+            /*
+          'See https://vike.dev/render-modes for more information.',
+          [
+            // 'Loaded config files (none of them define the onRenderHtml() hook):',
+            'Loaded server-side page files (none of them `export { render }`):',
+            ...pageContext._pageFilePathsLoaded.map((f, i) => ` (${i + 1}): ${f}`)
+          ].join('\n')
+          */
+        ].join(' '));
+    }
+    return hookFound;
+}
+function processHookReturnValue(hookReturnValue, renderHook) {
+    let documentHtml = null;
+    let pageContextPromise = null;
+    let pageContextProvidedByRenderHook = null;
+    let injectFilter = null;
+    const ret = () => ({ documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter });
+    if (hookReturnValue === null)
+        return ret();
+    if ((0, renderHtml_js_1.isDocumentHtml)(hookReturnValue)) {
+        documentHtml = hookReturnValue;
+        return ret();
+    }
+    const errPrefix = `The ${renderHook.hookName}() hook defined at ${renderHook.hookFilePath}`;
+    const errSuffix = `a string generated with the ${picocolors_1.default.cyan('escapeInject`<html>...</html>`')} template tag or a string returned by ${picocolors_1.default.cyan('dangerouslySkipEscape()')}, see https://vike.dev/escapeInject`;
+    if (typeof hookReturnValue === 'string') {
+        (0, utils_js_1.assertWarning)(false, [errPrefix, 'returned a plain JavaScript string which is dangerous: it should instead return', errSuffix].join(' '), { onlyOnce: true });
+        hookReturnValue = (0, renderHtml_js_1.dangerouslySkipEscape)(hookReturnValue);
+    }
+    (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(hookReturnValue), [
+        errPrefix,
+        `should return ${picocolors_1.default.cyan('null')}, the value ${picocolors_1.default.cyan('documentHtml')}, or an object ${picocolors_1.default.cyan('{ documentHtml, pageContext }')} where ${picocolors_1.default.cyan('pageContext')} is ${picocolors_1.default.cyan('undefined')} or an object holding additional pageContext values, and where ${picocolors_1.default.cyan('documentHtml')} is`,
+        errSuffix
+    ].join(' '));
+    (0, assertHookReturnedObject_js_1.assertHookReturnedObject)(hookReturnValue, ['documentHtml', 'pageContext', 'injectFilter'], errPrefix);
+    if (hookReturnValue.injectFilter) {
+        (0, utils_js_1.assertUsage)((0, utils_js_1.isCallable)(hookReturnValue.injectFilter), 'injectFilter should be a function');
+        injectFilter = hookReturnValue.injectFilter;
+    }
+    if (hookReturnValue.documentHtml) {
+        let val = hookReturnValue.documentHtml;
+        const errBegin = `${errPrefix} returned ${picocolors_1.default.cyan('{ documentHtml }')}, but ${picocolors_1.default.cyan('documentHtml')}`;
+        if (typeof val === 'string') {
+            (0, utils_js_1.assertWarning)(false, [
+                errBegin,
+                `is a plain JavaScript string which is dangerous: ${picocolors_1.default.cyan('documentHtml')} should be`,
+                errSuffix
+            ].join(' '), { onlyOnce: true });
+            val = (0, renderHtml_js_1.dangerouslySkipEscape)(val);
+        }
+        (0, utils_js_1.assertUsage)((0, renderHtml_js_1.isDocumentHtml)(val), [errBegin, 'should be', errSuffix].join(' '));
+        documentHtml = val;
+    }
+    if (hookReturnValue.pageContext) {
+        const val = hookReturnValue.pageContext;
+        const errBegin = `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext }')}, but ${picocolors_1.default.cyan('pageContext')}`;
+        if ((0, utils_js_1.isPromise)(val) || (0, utils_js_1.isCallable)(val)) {
+            (0, utils_js_1.assertWarning)(!(0, utils_js_1.isPromise)(val), `${errBegin} is a promise which is deprecated in favor of async functions, see https://vike.dev/stream#initial-data-after-stream-end`, { onlyOnce: true });
+            pageContextPromise = val;
+        }
+        else {
+            (0, utils_js_1.assertUsage)((0, utils_js_1.isObject)(val), `${errBegin} should be an object or an async function, see https://vike.dev/stream#initial-data-after-stream-end`);
+            (0, assertPageContextProvidedByUser_js_1.assertPageContextProvidedByUser)(val, renderHook);
+            pageContextProvidedByRenderHook = val;
+        }
+    }
+    return ret();
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEarlyHints = void 0;
+const inferHtmlTags_js_1 = require("../html/injectAssets/inferHtmlTags.js");
+const utils_js_1 = require("../utils.js");
+function getEarlyHints(assets) {
+    const earlyHints = [];
+    {
+        assets.forEach((asset) => {
+            // Don't early hint fallback fonts, https://github.com/vikejs/vike/issues/624
+            if (isFontFallback(asset, earlyHints))
+                return;
+            earlyHints.push({
+                ...asset,
+                earlyHintLink: (0, inferHtmlTags_js_1.inferEarlyHintLink)(asset)
+            });
+        });
+    }
+    return earlyHints;
+}
+exports.getEarlyHints = getEarlyHints;
+function isFontFallback(asset, earlyHints) {
+    if (asset.assetType !== 'font') {
+        return false;
+    }
+    const fontUrlBase = removeFileExtentionAndHash(asset.src);
+    return earlyHints.some((hint) => {
+        return hint.assetType === 'font' && removeFileExtentionAndHash(hint.src) === fontUrlBase;
+    });
+}
+function removeFileExtentionAndHash(assetUrl) {
+    (0, utils_js_1.assert)(!assetUrl.includes('\\'));
+    // The logic below doesn't work for '/assets/chunk-0e184ced.js'
+    (0, utils_js_1.assert)(!assetUrl.endsWith('.js'));
+    const paths = assetUrl.split('/');
+    {
+        const filename = paths[paths.length - 1];
+        const filenameParts = filename.split('.');
+        (0, utils_js_1.assert)(filenameParts.length >= 2);
+        // User may set config.build.rollupOptions.output.assetFileNames => we can't assume the filename to be `*.${hash}.${ext}`
+        const filenameBase = filenameParts.slice(0, filenameParts.length === 2 ? -1 : -2);
+        (0, utils_js_1.assert)(filenameBase.length >= 1);
+        paths[paths.length - 1] = filenameBase.join('.');
+    }
+    return paths.join('/');
+}