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

package/dist/esm/node/runtime/renderPage/getPageAssets/sortPageAssetsForEarlyHintsHeader.js

@@ -0,0 +1,30 @@
+export { sortPageAssetsForEarlyHintsHeader };
+import { getGlobalContext } from '../../globalContext.js';
+import { higherFirst } from '../../utils.js';
+function sortPageAssetsForEarlyHintsHeader(pageAssets) {
+    const globalContext = getGlobalContext();
+    pageAssets.sort(higherFirst(({ assetType }) => {
+        // In dev, we load scripts first in order to parallelize I/O and CPU
+        if (!globalContext.isProduction && assetType === 'script') {
+            return 1;
+        }
+        let priority = 0;
+        // CSS has highest priority
+        if (assetType === 'style')
+            return priority;
+        priority--;
+        // Visual assets have high priority
+        if (assetType === 'font')
+            return priority;
+        priority--;
+        if (assetType === 'image')
+            return priority;
+        priority--;
+        // Others
+        if (assetType !== 'script')
+            return priority;
+        priority--;
+        // JavaScript has lowest priority
+        return priority;
+    }));
+}

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

@@ -0,0 +1,19 @@
+export { getPageAssets };
+export type { PageAsset };
+export type { GetPageAssets };
+export type { PageContextGetPageAssets };
+import { type MediaType } from './inferMediaType.js';
+import type { ClientDependency } from '../../../shared/getPageFiles/analyzePageClientSide/ClientDependency.js';
+type PageAsset = {
+    src: string;
+    assetType: null | NonNullable<MediaType>['assetType'];
+    mediaType: null | NonNullable<MediaType>['mediaType'];
+    isEntry: boolean;
+};
+type GetPageAssets = () => Promise<PageAsset[]>;
+type PageContextGetPageAssets = {
+    _baseServer: string;
+    _baseAssets: string | null;
+    _includeAssetsImportedByServer: boolean;
+};
+declare function getPageAssets(pageContext: PageContextGetPageAssets, clientDependencies: ClientDependency[], clientEntries: string[]): Promise<PageAsset[]>;

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

@@ -0,0 +1,130 @@
+export { getPageAssets };
+import { assert, prependBase, assertPosixPath, toPosixPath, isNpmPackageImport, unique, isNotNullish, pathJoin } from '../utils.js';
+import { retrieveAssetsDev } from './getPageAssets/retrieveAssetsDev.js';
+import { retrieveAssetsProd } from './getPageAssets/retrieveAssetsProd.js';
+import { inferMediaType } from './inferMediaType.js';
+import { getManifestEntry } from './getPageAssets/getManifestEntry.js';
+import { sortPageAssetsForEarlyHintsHeader } from './getPageAssets/sortPageAssetsForEarlyHintsHeader.js';
+import { getGlobalContext } from '../globalContext.js';
+import { assertClientEntryId } from './getPageAssets/assertClientEntryId.js';
+import { import_ } from '@brillout/import';
+async function getPageAssets(pageContext, clientDependencies, clientEntries) {
+    const globalContext = getGlobalContext();
+    const isDev = !globalContext.isProduction;
+    let assetUrls;
+    let clientEntriesSrc;
+    if (isDev) {
+        const { viteDevServer, configVike } = globalContext;
+        clientEntriesSrc = await Promise.all(clientEntries.map((clientEntry) => resolveClientEntriesDev(clientEntry, viteDevServer, configVike)));
+        assetUrls = await retrieveAssetsDev(clientDependencies, viteDevServer);
+    }
+    else {
+        const { pluginManifest, clientManifest } = globalContext;
+        const manifestKeyMap = pluginManifest.manifestKeyMap;
+        clientEntriesSrc = clientEntries.map((clientEntry) => resolveClientEntriesProd(clientEntry, clientManifest, manifestKeyMap));
+        assetUrls = retrieveAssetsProd(clientDependencies, clientManifest, pageContext._includeAssetsImportedByServer, manifestKeyMap);
+    }
+    let pageAssets = [];
+    unique([...clientEntriesSrc, ...assetUrls]).forEach((src) => {
+        const { mediaType = null, assetType = null } = inferMediaType(src) || {};
+        if (isDev && assetType === 'style') {
+            // https://github.com/vikejs/vike/issues/449
+            if (src.endsWith('?inline')) {
+                return;
+            }
+            // https://github.com/vikejs/vike/issues/401
+            src = src + '?direct';
+        }
+        const isEntry = clientEntriesSrc.includes(src) ||
+            // Vite automatically injects CSS, not only in development, but also in production (albeit with a FOUC). Therefore, strictly speaking, CSS aren't entries. We still, however, set `isEntry: true` for CSS, in order to denote page assets that should absolutely be injected in the HTML, regardless of preload strategy (not injecting CSS leads to FOUC).
+            assetType === 'style';
+        pageAssets.push({
+            src,
+            assetType,
+            mediaType,
+            isEntry
+        });
+    });
+    pageAssets.forEach(({ src }) => {
+        assert(1 === pageAssets.filter((p) => p.src === src).length);
+    });
+    pageAssets = pageAssets.map((pageAsset) => {
+        const baseServerAssets = pageContext._baseAssets || pageContext._baseServer;
+        pageAsset.src = prependBase(toPosixPath(pageAsset.src), baseServerAssets);
+        return pageAsset;
+    });
+    sortPageAssetsForEarlyHintsHeader(pageAssets);
+    return pageAssets;
+}
+async function resolveClientEntriesDev(clientEntry, viteDevServer, configVike) {
+    assertClientEntryId(clientEntry);
+    let root = viteDevServer.config.root;
+    assert(root);
+    root = toPosixPath(root);
+    // The `?import` suffix is needed for MDX to be transpiled:
+    //   - Not transpiled: `/pages/markdown.page.mdx`
+    //   - Transpiled: `/pages/markdown.page.mdx?import`
+    // But `?import` doesn't work with `/@fs/`:
+    //   - Not transpiled: /@fs/home/runner/work/vike/vike/examples/react-full/pages/markdown.page.mdx
+    //   - Not transpiled: /@fs/home/runner/work/vike/vike/examples/react-full/pages/markdown.page.mdx?import
+    if (clientEntry.endsWith('?import')) {
+        assert(clientEntry.startsWith('/'));
+        return clientEntry;
+    }
+    assertPosixPath(clientEntry);
+    let filePath;
+    if (clientEntry.startsWith('/')) {
+        // User files
+        filePath = pathJoin(root, clientEntry);
+    }
+    else if (clientEntry.startsWith('@@vike/')) {
+        // Vike client entry
+        const { createRequire } = (await import_('module')).default;
+        const { dirname } = (await import_('path')).default;
+        const { fileURLToPath } = (await import_('url')).default;
+        // @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+        const importMetaUrl = import.meta.url;
+        const require_ = createRequire(importMetaUrl);
+        const __dirname_ = dirname(fileURLToPath(importMetaUrl));
+        // @ts-expect-error
+        // Bun workaround https://github.com/vikejs/vike/pull/1048
+        const res = typeof Bun !== 'undefined' ? (toPath) => Bun.resolveSync(toPath, __dirname_) : require_.resolve;
+        assert(clientEntry.endsWith('.js'));
+        try {
+            // For Vitest (which doesn't resolve vike to its dist but to its source files)
+            // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/node/runtime/renderPage/getPageAssets.js
+            filePath = toPosixPath(res(clientEntry.replace('@@vike/dist/esm/client/', '../../../client/').replace('.js', '.ts')));
+        }
+        catch {
+            // For users
+            // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/runtime/renderPage/getPageAssets.js
+            filePath = toPosixPath(res(clientEntry.replace('@@vike/dist/esm/client/', '../../../../../dist/esm/client/')));
+        }
+    }
+    else if (isNpmPackageImport(clientEntry)) {
+        const extensionPageFile = configVike.extensions
+            .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
+            .flat()
+            .filter(isNotNullish)
+            .find((e) => e.importPath === clientEntry);
+        assert(extensionPageFile, clientEntry);
+        filePath = extensionPageFile.filePath;
+    }
+    else {
+        assert(false);
+    }
+    if (!filePath.startsWith('/')) {
+        assert(process.platform === 'win32');
+        filePath = '/' + filePath;
+    }
+    filePath = '/@fs' + filePath;
+    assertPosixPath(filePath);
+    return filePath;
+}
+function resolveClientEntriesProd(clientEntry, clientManifest, manifestKeyMap) {
+    const { manifestEntry } = getManifestEntry(clientEntry, clientManifest, manifestKeyMap);
+    assert(manifestEntry.isEntry || manifestEntry.isDynamicEntry || clientEntry.endsWith('.css'), { clientEntry });
+    let { file } = manifestEntry;
+    assert(!file.startsWith('/'));
+    return '/' + file;
+}

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

@@ -0,0 +1,11 @@
+export { handleErrorWithoutErrorPage };
+import type { PageContextAfterRender } from './renderPageAlreadyRouted.js';
+import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+declare function handleErrorWithoutErrorPage<PageContext extends {
+    isClientSideNavigation: boolean;
+    errorWhileRendering: null | Error;
+    is404: null | boolean;
+    _pageId: null;
+    _pageConfigs: PageConfig[];
+    urlOriginal: string;
+}>(pageContext: PageContext): Promise<PageContext & PageContextAfterRender>;

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

@@ -0,0 +1,37 @@
+export { handleErrorWithoutErrorPage };
+import { stringify } from '@brillout/json-serializer/stringify';
+import { getGlobalContext } from '../globalContext.js';
+import { assert, assertWarning, objectAssign } from '../utils.js';
+import { createHttpResponseObject } from './createHttpResponseObject.js';
+import pc from '@brillout/picocolors';
+// When the user hasn't defined _error.page.js
+async function handleErrorWithoutErrorPage(pageContext) {
+    assert(pageContext._pageId === null);
+    assert(pageContext.errorWhileRendering || pageContext.is404);
+    {
+        const isV1 = pageContext._pageConfigs.length > 0;
+        warnMissingErrorPage(isV1);
+    }
+    if (!pageContext.isClientSideNavigation) {
+        objectAssign(pageContext, { httpResponse: null });
+        return pageContext;
+    }
+    else {
+        const __getPageAssets = async () => [];
+        objectAssign(pageContext, { __getPageAssets });
+        const httpResponse = await createHttpResponseObject(stringify({ serverSideError: true }), null, pageContext);
+        objectAssign(pageContext, { httpResponse });
+        return pageContext;
+    }
+}
+function warnMissingErrorPage(isV1) {
+    const globalContext = getGlobalContext();
+    if (!globalContext.isProduction) {
+        const msg = [
+            `No ${isV1 ? 'error page' : pc.cyan('_error.page.js')} found,`,
+            'we recommend defining an error page,',
+            'see https://vike.dev/error-page'
+        ].join(' ');
+        assertWarning(false, msg, { onlyOnce: true });
+    }
+}

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

@@ -0,0 +1,5 @@
+export { handlePageContextRequestUrl };
+declare function handlePageContextRequestUrl(url: string): {
+    urlWithoutPageContextRequestSuffix: string;
+    isPageContextRequest: boolean;
+};

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

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

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

@@ -0,0 +1,7 @@
+export { inferMediaType };
+export type { MediaType };
+type MediaType = null | {
+    assetType: 'image' | 'script' | 'font' | 'style';
+    mediaType: 'text/javascript' | 'text/css' | 'image/jpeg' | 'image/png' | 'image/webp' | 'image/gif' | 'image/svg+xml' | 'font/ttf' | 'font/woff' | 'font/woff2';
+};
+declare function inferMediaType(href: string): MediaType;

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

@@ -0,0 +1,38 @@
+export { inferMediaType };
+import { styleFileRE, isScriptFile } from '../utils.js';
+function inferMediaType(href) {
+    // Basics
+    if (styleFileRE.test(href)) {
+        return { mediaType: 'text/css', assetType: 'style' };
+    }
+    if (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;
+}

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

@@ -0,0 +1,2 @@
+export declare let isConfigInvalid: boolean;
+export declare const isConfigInvalid_set: (val: boolean) => void;

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

@@ -0,0 +1,4 @@
+export let isConfigInvalid = false;
+export const isConfigInvalid_set = (val) => {
+    isConfigInvalid = val;
+};

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

@@ -0,0 +1,4 @@
+export { isNewError };
+export { setAlreadyLogged };
+declare function isNewError(errErrorPage: unknown, errNominalPage: unknown): boolean;
+declare function setAlreadyLogged(err: unknown): void;

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

@@ -0,0 +1,20 @@
+export { isNewError };
+export { setAlreadyLogged };
+import { getGlobalObject, isObject, isEquivalentError, warnIfErrorIsNotObject } from '../utils.js';
+const globalObject = getGlobalObject('runtime/renderPage/isNewError.ts', {
+    wasAlreadyLogged: new WeakSet()
+});
+function isNewError(errErrorPage, errNominalPage) {
+    warnIfErrorIsNotObject(errErrorPage);
+    return !isEquivalentError(errNominalPage, errErrorPage) || !hasAlreadyLogged(errNominalPage);
+}
+function hasAlreadyLogged(err) {
+    if (!isObject(err))
+        return false;
+    return globalObject.wasAlreadyLogged.has(err);
+}
+function setAlreadyLogged(err) {
+    if (!isObject(err))
+        return;
+    globalObject.wasAlreadyLogged.add(err);
+}

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

@@ -0,0 +1,29 @@
+export { loadPageFilesServerSide };
+export type { PageFiles };
+export type { PageContext_loadPageFilesServerSide };
+import { type PageFile } from '../../../shared/getPageFiles.js';
+import { PromiseType } from '../utils.js';
+import { PageContextGetPageAssets, type PageAsset } from './getPageAssets.js';
+import { type PageContextDebug } from './debugPageFiles.js';
+import type { PageConfig } from '../../../shared/page-configs/PageConfig.js';
+type PageContext_loadPageFilesServerSide = PageContextGetPageAssets & PageContextDebug & {
+    urlOriginal: string;
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfig[];
+};
+type PageFiles = PromiseType<ReturnType<typeof loadPageFilesServerSide>>;
+declare function loadPageFilesServerSide(pageContext: {
+    _pageId: string;
+} & PageContext_loadPageFilesServerSide): Promise<{
+    config: Record<string, unknown>;
+    configEntries: import("../../../shared/getPageFiles/getExports.js").ConfigEntries;
+    exports: Record<string, unknown>;
+    exportsAll: import("../../../shared/getPageFiles/getExports.js").ExportsAll;
+    pageExports: Record<string, unknown>;
+    Page: unknown;
+    _isHtmlOnly: boolean;
+    _passToClient: string[];
+    _pageFilePathsLoaded: string[];
+} & {
+    __getPageAssets: () => Promise<PageAsset[]>;
+}>;

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

@@ -0,0 +1,97 @@
+export { loadPageFilesServerSide };
+import { getExportUnion, getPageFilesServerSide, getExports } from '../../../shared/getPageFiles.js';
+import { analyzePageClientSideInit } from '../../../shared/getPageFiles/analyzePageClientSide.js';
+import { assertWarning, objectAssign } from '../utils.js';
+import { getPageAssets } from './getPageAssets.js';
+import { debugPageFiles } from './debugPageFiles.js';
+import { findPageConfig } from '../../../shared/page-configs/findPageConfig.js';
+import { analyzePage } from './analyzePage.js';
+import { getGlobalContext } from '../globalContext.js';
+import { loadPageCode } from '../../../shared/page-configs/loadPageCode.js';
+async function loadPageFilesServerSide(pageContext) {
+    const pageConfig = 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, !getGlobalContext().isProduction),
+        analyzePageClientSideInit(pageContext._pageFilesAll, pageContext._pageId, { sharedPageFilesAlreadyLoaded: true })
+    ]);
+    const { isHtmlOnly, isClientRouting, clientEntries, clientDependencies, pageFilesClientSide, pageFilesServerSide } = analyzePage(pageContext._pageFilesAll, pageConfig, pageContext._pageId);
+    const pageContextAddendum = {};
+    objectAssign(pageContextAddendum, {
+        config,
+        configEntries,
+        exports,
+        exportsAll,
+        pageExports,
+        Page: exports.Page,
+        _isHtmlOnly: isHtmlOnly,
+        _passToClient: getExportUnion(exportsAll, 'passToClient'),
+        _pageFilePathsLoaded: pageFilesLoaded.map((p) => p.filePath)
+    });
+    objectAssign(pageContextAddendum, {
+        __getPageAssets: async () => {
+            if ('_pageAssets' in pageContext) {
+                return pageContext._pageAssets;
+            }
+            else {
+                const pageAssets = await getPageAssets(pageContext, clientDependencies, clientEntries);
+                objectAssign(pageContext, { _pageAssets: pageAssets });
+                return pageContext._pageAssets;
+            }
+        }
+    });
+    // TODO/v1-release: remove
+    Object.assign(pageContextAddendum, {
+        _getPageAssets: async () => {
+            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;
+        }
+    });
+    {
+        debugPageFiles({
+            pageContext,
+            isHtmlOnly,
+            isClientRouting,
+            pageFilesLoaded,
+            pageFilesClientSide,
+            pageFilesServerSide,
+            clientEntries,
+            clientDependencies
+        });
+    }
+    return pageContextAddendum;
+}
+async function loadPageFiles(pageFilesAll, pageConfig, pageId, isDev) {
+    const pageFilesServerSide = getPageFilesServerSide(pageFilesAll, pageId);
+    const pageConfigLoaded = !pageConfig ? null : await loadPageCode(pageConfig, isDev);
+    await Promise.all(pageFilesServerSide.map((p) => p.loadFile?.()));
+    const { config, configEntries, exports, exportsAll, pageExports } = getExports(pageFilesServerSide, pageConfigLoaded);
+    return {
+        config,
+        configEntries,
+        exports,
+        exportsAll,
+        pageExports,
+        pageFilesLoaded: pageFilesServerSide,
+        pageConfigLoaded
+    };
+}

package/dist/esm/node/runtime/renderPage/log404/index.d.ts

@@ -0,0 +1,10 @@
+export { log404 };
+export { getPagesAndRoutesInfo };
+import type { PageRoutes } from '../../../../shared/route/index.js';
+declare function log404(pageContext: {
+    urlPathname: string;
+    errorWhileRendering: null | Error;
+    isClientSideNavigation: boolean;
+    _pageRoutes: PageRoutes;
+}): Promise<void>;
+declare function getPagesAndRoutesInfo(pageRoutes: PageRoutes): string;

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

@@ -0,0 +1,138 @@
+export { log404 };
+export { getPagesAndRoutesInfo };
+import { getGlobalContext } from '../../globalContext.js';
+import { assert, assertUsage, assertInfo, compareString, stripAnsi, getTerminalWidth, truncateString } from '../../utils.js';
+import pc from '@brillout/picocolors';
+async function log404(pageContext) {
+    const { urlPathname } = pageContext;
+    const pageRoutes = pageContext._pageRoutes;
+    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 = getGlobalContext();
+    if (!globalContext.isProduction && !isFileRequest(urlPathname) && !pageContext.isClientSideNavigation) {
+        assertInfo(false, [
+            `URL ${pc.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 });
+    }
+}
+function getPagesAndRoutesInfo(pageRoutes) {
+    const entries = pageRoutes
+        .map((pageRoute) => {
+        let routeStr;
+        let routeTypeSrc;
+        let routeDefinedBy;
+        if (pageRoute.routeType === 'FILESYSTEM') {
+            assert(pageRoute.routeFilesystemDefinedBy);
+            routeDefinedBy = pageRoute.routeFilesystemDefinedBy;
+        }
+        else {
+            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';
+        }
+        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 compareString(e1.routeStr, e2.routeStr);
+    });
+    const linesContent = [
+        {
+            routeStr: 'ROUTE',
+            routeTypeSrc: 'TYPE',
+            routeDefinedBy: 'DEFINED BY'
+        },
+        ...entries
+    ];
+    const terminalWidth = 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 = truncateString(routeStr, width1, (s) => pc.dim(s));
+        }
+        else {
+            routeStr = truncateRouteFunction(routeStr, width1);
+        }
+        assert(stripAnsi(routeStr).length <= width1);
+        lineContent.routeStr = routeStr;
+    });
+    width1 = Math.max(...linesContent.map(({ routeStr }) => stripAnsi(routeStr).length));
+    let lines = linesContent.map(({ routeStr, routeTypeSrc, routeDefinedBy }, i) => {
+        let cell1 = routeStr.padEnd(width1 + (routeStr.length - stripAnsi(routeStr).length), ' ');
+        let cell2 = routeTypeSrc.padEnd(width2, ' ');
+        let cell3 = routeDefinedBy.padEnd(width3, ' ');
+        const isHeader = i === 0;
+        if (isHeader) {
+            cell1 = pc.dim(cell1);
+            cell2 = pc.dim(cell2);
+            cell3 = pc.dim(cell3);
+        }
+        let line = [cell1, cell2, cell3].join(pc.dim(' │ '));
+        line = pc.dim('│ ') + line + pc.dim(' │');
+        return line;
+    });
+    width1 = width1 + 2;
+    width2 = width2 + 2;
+    width3 = width3 + 2;
+    // https://en.wikipedia.org/wiki/Box-drawing_character
+    lines = [
+        pc.dim(`┌${'─'.repeat(width1)}┬${'─'.repeat(width2)}┬${'─'.repeat(width3)}┐`),
+        lines[0],
+        pc.dim(`├${'─'.repeat(width1)}┼${'─'.repeat(width2)}┼${'─'.repeat(width3)}┤`),
+        ...lines.slice(1),
+        pc.dim(`└${'─'.repeat(width1)}┴${'─'.repeat(width2)}┴${'─'.repeat(width3)}┘`)
+    ];
+    lines.forEach((line) => {
+        assert(stripAnsi(line).length <= terminalWidth);
+    });
+    return lines.join('\n');
+}
+function truncateRouteFunction(routeStr, lenMax) {
+    routeStr = stripAnsi(routeStr);
+    routeStr = removeNonAscii(routeStr);
+    routeStr = routeStr.split(/\s/).filter(Boolean).join(' ');
+    routeStr = truncateString(routeStr, lenMax, (s) => pc.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) {
+    assert(urlPathname.startsWith('/'));
+    const paths = urlPathname.split('/');
+    const lastPath = paths[paths.length - 1];
+    assert(typeof lastPath === 'string');
+    const parts = lastPath.split('.');
+    if (parts.length < 2) {
+        return false;
+    }
+    const fileExtension = parts[parts.length - 1];
+    assert(typeof fileExtension === 'string');
+    return /^[a-z0-9]+$/.test(fileExtension);
+}

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

@@ -0,0 +1,2 @@
+export { logErrorProd };
+declare function logErrorProd(err: unknown, _httpRquestId: null | number): void;

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

@@ -0,0 +1,17 @@
+// Logger used for the production server.
+// Any other environement (dev, preview, build, and pre-rendering) uses loggerNotProd.ts instead.
+export { logErrorProd };
+import { isAbortError } from '../../../shared/route/abort.js';
+import { setAlreadyLogged } from './isNewError.js';
+import { isObject, warnIfErrorIsNotObject } from '../utils.js';
+import pc from '@brillout/picocolors';
+function logErrorProd(err, _httpRquestId) {
+    warnIfErrorIsNotObject(err);
+    setAlreadyLogged(err);
+    if (isAbortError(err)) {
+        return;
+    }
+    // We ensure we print a string; Cloudflare Workers doesn't seem to properly stringify `Error` objects.
+    const errStr = isObject(err) && 'stack' in err ? String(err.stack) : String(err);
+    console.error(pc.red(errStr));
+}

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

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