vike 0.4.163 → 0.4.165

package/dist/esm/node/plugin/shared/loggerNotProd.d.ts

@@ -1,5 +1,5 @@
 export { logViteAny };
-export { logViteErrorContainingCodeSnippet };
+export { logViteError };
 export { logConfigInfo };
 export { logConfigError };
 export { logConfigErrorRecover };
@@ -11,7 +11,6 @@ export type { LogError };
 export type { LogErrorArgs };
 export type { LogType };
 export type { LogCategory };
-import { type ErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
 type LogType = 'info' | 'warn' | 'error' | 'error-recover';
 type LogCategory = 'config' | `request(${number})`;
 type LogInfo = (...args: LogInfoArgs) => void;
@@ -22,10 +21,8 @@ declare function logRuntimeInfo(msg: string, httpRequestId: number, logType: Log
 declare function logViteAny(msg: string, logType: LogType, httpRequestId: number | null, prependViteTag: boolean): void;
 declare function logConfigInfo(msg: string, logType: LogType): void;
 declare function logConfigErrorRecover(): void;
-declare function logRuntimeError(err: unknown, 
-/** `httpRequestId` is `null` when pre-rendering */
-httpRequestId: number | null): void;
-declare function logViteErrorContainingCodeSnippet(err: ErrorWithCodeSnippet): void;
+declare function logRuntimeError(err: unknown, httpRequestId: number | null): void;
+declare function logViteError(err: unknown, httpRequestId: number | undefined): void;
 declare function logConfigError(err: unknown): void;
 declare function clearLogs(conditions?: {
     clearErrors?: boolean;

package/dist/esm/node/plugin/shared/loggerNotProd.js

@@ -5,7 +5,7 @@
 //  - Pre-rendering
 // In other words: everywhere except in production
 export { logViteAny };
-export { logViteErrorContainingCodeSnippet };
+export { logViteError };
 export { logConfigInfo };
 export { logConfigError };
 export { logConfigErrorRecover };
@@ -54,14 +54,16 @@ function logConfigErrorRecover() {
     logWithVikeTag(msg, 'error-recover', category);
 }
 function logRuntimeError(err, 
-/** `httpRequestId` is `null` when pre-rendering */
+// httpRequestId is `null` when pre-rendering
 httpRequestId) {
-    logErr(err, httpRequestId);
+    logErr(err, httpRequestId, false);
 }
-function logViteErrorContainingCodeSnippet(err) {
-    logErr(err);
+function logViteError(err, 
+// httpRequestId is `undefined` if development environment doesn't support async stores
+httpRequestId) {
+    logErr(err, httpRequestId, true);
 }
-function logErr(err, httpRequestId = null) {
+function logErr(err, httpRequestId = null, errorComesFromVite) {
     warnIfErrorIsNotObject(err);
     if (isAbortError(err) && !isErrorDebug()) {
         return;
@@ -100,9 +102,10 @@ function logErr(err, httpRequestId = null) {
         logWithVikeTag(pc.red(`Following error was thrown by the ${hookName}() hook defined at ${hookFilePath}`), 'error', category);
     }
     else if (category) {
-        logFallbackErrIntro(category);
+        logFallbackErrIntro(category, errorComesFromVite);
     }
     logDirectly(err, 'error');
+    // Needs to be called after logging the error.
     onRuntimeError(err);
 }
 function logConfigError(err) {
@@ -137,11 +140,12 @@ function logConfigError(err) {
             return;
     }
     if (category)
-        logFallbackErrIntro(category);
+        logFallbackErrIntro(category, false);
     logDirectly(err, 'error');
 }
-function logFallbackErrIntro(category) {
-    logWithVikeTag(pc.bold(pc.red('[Error] An error was thrown:')), 'error', category);
+function logFallbackErrIntro(category, errorComesFromVite) {
+    const msg = errorComesFromVite ? 'Transpilation error' : 'An error was thrown';
+    logWithVikeTag(pc.bold(pc.red(`[Error] ${msg}:`)), 'error', category);
 }
 function getConfigCategory() {
     const category = getCategory() ?? 'config';

package/dist/esm/node/plugin/shared/loggerVite.js

@@ -1,11 +1,9 @@
 export { improveViteLogs };
 import { assert, removeEmptyLines, trimWithAnsi, trimWithAnsiTrailOnly } from '../utils.js';
-import { logViteErrorContainingCodeSnippet, logViteAny, clearLogs } from './loggerNotProd.js';
-import { isErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
+import { logViteError, logViteAny, clearLogs } from './loggerNotProd.js';
 import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
 import { removeSuperfluousViteLog } from './loggerVite/removeSuperfluousViteLog.js';
 import { isErrorDebug } from './isErrorDebug.js';
-import { onRuntimeError } from '../../runtime/renderPage/loggerProd.js';
 function improveViteLogs(config) {
     intercept('info', config);
     intercept('warn', config);
@@ -25,29 +23,25 @@ function intercept(logType, config) {
         }
         msg = cleanFirstViteLog(msg);
         const store = getHttpRequestAsyncStore();
-        // Dedupe Vite error messages
-        if (options.error && store?.shouldErrorBeSwallowed(options.error)) {
+        if (options.error) {
+            // Vite does a poor job of handling errors.
+            //  - It doesn't format error code snippets.
+            //  - It only shows error.message which means that crucial information such as error.id isn't shown to the user.
+            logViteError(options.error, store?.httpRequestId);
+            // We swallow Vite's message: we didn't see it add any value so far.
+            //  - It can even be confusing, such as the following:
+            //    ```
+            //    Error when evaluating SSR module virtual:vike:pageConfigValuesAll:server:/pages/abort: failed to import "/pages/abort/+Page.mdx"
+            //    ```
+            assert(!isErrorDebug());
             return;
         }
-        // Remove this once https://github.com/vitejs/vite/pull/13495 is released and widely used
-        if (msg.startsWith('Transform failed with ') && store && logType === 'error') {
-            store.markErrorMessageAsLogged(msg);
-            return;
-        }
-        if (options.error && isErrorWithCodeSnippet(options.error)) {
-            logViteErrorContainingCodeSnippet(options.error);
-            return;
-        }
-        // Only allow Vite to clear its first log. All other clearing is controlled by vike.
+        // Only allow Vite to clear for its first log. All other clearing is controlled by vike.
         if (options.clear)
             clearLogs({ clearIfFirstLog: true });
-        if (options.error)
-            store?.markErrorAsLogged(options.error);
         // Vite's default logger preprends the "[vite]" tag if and only if options.timestamp is true
         const prependViteTag = options.timestamp || !!store?.httpRequestId;
         logViteAny(msg, logType, store?.httpRequestId ?? null, prependViteTag);
-        if (options.error)
-            onRuntimeError(options.error);
     };
 }
 function cleanFirstViteLog(msg) {

package/dist/esm/node/plugin/utils.d.ts

@@ -19,4 +19,4 @@ export * from '../../utils/assertKeys.js';
 export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
-export * from '../../utils/isVersionOrAbove.js';
+export * from '../../utils/assertVersion.js';

package/dist/esm/node/plugin/utils.js

@@ -25,4 +25,4 @@ export * from '../../utils/assertKeys.js';
 export * from '../../utils/injectRollupInputs.js';
 export * from '../../utils/humanizeTime.js';
 export * from '../../utils/pLimit.js';
-export * from '../../utils/isVersionOrAbove.js';
+export * from '../../utils/assertVersion.js';

package/dist/esm/node/prerender/runPrerender.js

@@ -5,7 +5,7 @@ export { runPrerender_forceExit };
 import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
-import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, setNodeEnvToProduction, isUserHookError, assertNodeEnvIsNotDev, getNodeEnv } from './utils.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, executeHook, isPlainObject, isUserHookError, handleNodeEnv_prerender } from './utils.js';
 import { pLimit } from '../../utils/pLimit.js';
 import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
@@ -59,7 +59,7 @@ async function runPrerender(options, manuallyTriggered) {
     if (logLevel === 'info') {
         console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
     }
-    handleNodeEnv();
+    handleNodeEnv_prerender();
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
     setGlobalContext_prerender(viteConfig);
@@ -714,10 +714,3 @@ function assertIsNotAbort(err, urlOr404) {
     assert(abortCall);
     assertUsage(false, `${pc.cyan(abortCall)} thrown${thrownBy} while pre-rendering ${urlOr404} but ${pc.cyan(abortCaller)} isn't supported for pre-rendered pages`);
 }
-function handleNodeEnv() {
-    const assertNodeEnv = () => assertNodeEnvIsNotDev('pre-rendering');
-    if (getNodeEnv())
-        assertNodeEnv();
-    setNodeEnvToProduction();
-    assertNodeEnv();
-}

package/dist/esm/node/runtime/globalContext.js

@@ -9,7 +9,7 @@ export { getViteConfig };
 export { setGlobalContext_viteDevServer };
 export { setGlobalContext_prerender };
 export { getRuntimeManifest };
-import { assert, assertUsage, assertWarning, getGlobalObject, getNodeEnv, getNodeEnvDesc, isNodeEnvDev, isPlainObject, objectAssign, objectKeys } from './utils.js';
+import { assert, assertNodeEnv_runtime, assertUsage, assertWarning, getGlobalObject, isPlainObject, objectAssign, objectKeys } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
 import { setPageFiles } from '../../shared/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
@@ -83,7 +83,7 @@ async function initGlobalContext(isPrerendering = false, outDir) {
     if (globalObject.globalContext)
         return;
     const { viteDevServer, viteConfig } = globalObject;
-    assertNodeEnv(!!viteDevServer);
+    assertNodeEnv_runtime(!!viteDevServer);
     const isProduction = !viteDevServer;
     if (!isProduction) {
         assert(viteConfig);
@@ -179,15 +179,3 @@ function assertViteManifest(manifest) {
       })
     */
 }
-function assertNodeEnv(hasViteDevServer) {
-    const nodeEnv = getNodeEnv();
-    if (nodeEnv === null || nodeEnv === 'test')
-        return;
-    const isDev = isNodeEnvDev();
-    // Calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
-    if (hasViteDevServer === isDev)
-        return;
-    const nodeEnvDesc = getNodeEnvDesc();
-    // We should change this to be a warning if it blocks users (e.g. if a bad-citizen tool sets a wrong process.env.NODE_ENV value)
-    assertUsage(false, `Vite's development server was${hasViteDevServer ? '' : "n't"} instantiated while the ${nodeEnvDesc} which is contradictory, see https://vike.dev/NODE_ENV`);
-}

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

@@ -3,8 +3,7 @@ export { logErrorHint };
 export { isCjsEsmError };
 export { isKnownError };
 export { getHint };
-import pc from '@brillout/picocolors';
-import { assert, formatHintLog, isNotNullish, isObject, unique, joinEnglish } from '../utils.js';
+import { assert, formatHintLog, isNotNullish, isObject, unique } from '../utils.js';
 const knownErrors = [
     {
         errMsg: 'jsxDEV is not a function',
@@ -38,15 +37,7 @@ function getHint(error) {
     }
     const res = isCjsEsmError(error);
     if (res) {
-        const packageNames = res === true ? null : res;
-        const hint = [
-            'Error could be a CJS/ESM issue, consider ',
-            !packageNames || packageNames.length === 0
-                ? 'using'
-                : `adding ${joinEnglish(packageNames.map((p) => pc.cyan(p)), 'or')} to`,
-            ` ${pc.cyan('ssr.noExternal')}`,
-            ', see https://vike.dev/broken-npm-package'
-        ].join('');
+        const hint = 'The error seems to be a CJS/ESM issue, see https://vike.dev/broken-npm-package';
         return hint;
     }
     return null;
@@ -77,6 +68,7 @@ function isCjsEsmError(error) {
     packageNames.forEach((packageName) => {
         assert(!['vite', 'vike'].includes(packageName));
     });
+    // We don't use this anymore: we could return `true` instead. Shall we remove returning a list of npm packages?
     return packageNames;
 }
 function normalizeRes(res) {

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

@@ -16,9 +16,13 @@ function logErrorProd(err, _httpRquestId) {
     // 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));
+    // Needs to be called after logging the error.
     onRuntimeError(err);
 }
-// Every server-side runtime error is expected to go through onRuntimeError(). (In principle, any runtime error is (or at least should) be catched by Vike, otherwise Vike couldn't render the error page.)
+// Every server-side runtime error is expected to go through `onRuntimeError()`.
+//  - onRuntimeError(err) should always be called after `console.error(err)`.
+//    - Because the error hint of logErrorHint(err) should be shown *after* the error.
+//  - In principle, any runtime error is (or at least should) be catched by Vike, otherwise Vike couldn't render the error page.
 function onRuntimeError(err) {
     // The more runtime errors we pass to logErrorHint() the better.
     logErrorHint(err);

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

@@ -4,7 +4,6 @@ import { HttpResponse } from './renderPage/createHttpResponseObject.js';
 import type { PageContextBuiltInServer } from '../../types/index.js';
 declare let renderPage_wrapper: <PageContext>(_httpRequestId: number, ret: () => Promise<PageContext>) => Promise<{
     pageContextReturn: Awaited<PageContext>;
-    onRequestDone: () => void;
 }>;
 declare const renderPage_addWrapper: (wrapper: typeof renderPage_wrapper) => void;
 declare function renderPage<PageContextUserAdded extends {}, PageContextInit extends {

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

@@ -23,8 +23,7 @@ const globalObject = getGlobalObject('runtime/renderPage.ts', {
     pendingRequestsCount: 0
 });
 let renderPage_wrapper = async (_httpRequestId, ret) => ({
-    pageContextReturn: await ret(),
-    onRequestDone: () => { }
+    pageContextReturn: await ret()
 });
 const renderPage_addWrapper = (wrapper) => {
     renderPage_wrapper = wrapper;
@@ -43,10 +42,9 @@ async function renderPage(pageContextInit) {
     const { urlOriginal } = pageContextInit;
     logHttpRequest(urlOriginal, httpRequestId);
     globalObject.pendingRequestsCount++;
-    const { pageContextReturn, onRequestDone } = await renderPage_wrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
+    const { pageContextReturn } = await renderPage_wrapper(httpRequestId, () => renderPageAndPrepare(pageContextInit, httpRequestId));
     logHttpResponse(urlOriginal, httpRequestId, pageContextReturn);
     globalObject.pendingRequestsCount--;
-    onRequestDone();
     checkType(pageContextReturn);
     return pageContextReturn;
 }

package/dist/esm/shared/route/resolveRouteString.js

@@ -108,7 +108,6 @@ function parseRouteString(routeString) {
     return segments;
 }
 function getUrlFromRouteString(routeString) {
-    assert(routeString.startsWith('/'));
     if (isStaticRouteString(routeString)) {
         const url = routeString;
         return url;

package/dist/esm/utils/assertNodeEnv.d.ts

@@ -1,10 +1,10 @@
-export { getNodeEnv };
-export { setNodeEnvToProduction };
-export { isNodeEnvDev };
-export { getNodeEnvDesc };
-export { assertNodeEnvIsNotDev };
-declare function getNodeEnv(): null | undefined | string;
-declare function setNodeEnvToProduction(): void | undefined;
-declare function isNodeEnvDev(): boolean;
-declare function getNodeEnvDesc(): `environment is set to be a ${string} environment by process.env.NODE_ENV === ${string}`;
-declare function assertNodeEnvIsNotDev(operation: 'building' | 'pre-rendering'): void;
+export { assertNodeEnv_build };
+export { assertNodeEnv_runtime };
+export { assertNodeEnv_onVikePluginLoad };
+export { handleNodeEnv_prerender };
+export { handleNodeEnv_vitePluginVercel };
+declare function assertNodeEnv_build(): void;
+declare function assertNodeEnv_runtime(viteDevServerExists: boolean): void;
+declare function assertNodeEnv_onVikePluginLoad(): void;
+declare function handleNodeEnv_prerender(): void;
+declare function handleNodeEnv_vitePluginVercel(): void;

package/dist/esm/utils/assertNodeEnv.js

@@ -1,15 +1,69 @@
-// Utils to manage process.env.NODE_ENV and, most notably, to assert correct usage, which is crucial:
-//  - https://github.com/vikejs/vike/issues/1469#issuecomment-1919518096
-//  - https://github.com/vitejs/vite/blob/76f30ae23b92f9af910ec02d98e2baaefa12141f/packages/vite/src/node/config.ts#L567
-export { getNodeEnv };
-export { setNodeEnvToProduction };
-export { isNodeEnvDev };
-export { getNodeEnvDesc };
-export { assertNodeEnvIsNotDev };
+// This file serves the following three purposes:
+//   1. Upon building the app, we ensure the right NODE_ENV value is set.
+//      - Both Vue and React use NODE_ENV for enabling production-specific features:
+//        - Vue: https://github.com/vuejs/core/blob/f66a75ea75c8aece065b61e2126b4c5b2338aa6e/packages/vue/index.js
+//        - React: https://github.com/facebook/react/blob/01ab35a9a731dec69995fbd28f3ac7eaad11e183/packages/react/npm/index.js
+//      - Setting NODE_ENV to 'production' doesn't seem to make any sense in development.
+//      - With React upon building the app, setting NODE_ENV to a value other than 'production' triggers an error: https://github.com/vikejs/vike/issues/1469#issuecomment-1969301797
+//      - With Vue upon building the app, NODE_ENV can be set to a value other than 'production', e.g. 'development'.
+//   2. Ensure Vite isn't loaded in production.
+//      - We currently only check whether Vite's development middleware is instantiated (i.e. whether Vite's `createServer()` was called). Is there a way to detect whether Vite's code is loaded?
+//   3. Ensure NODE_ENV isn't mistakenly set to a wrong value.
+// TODO: to fully implement the aforementioned points we need to implement a [new setting `allowNodeEnv`](https://github.com/vikejs/vike/issues/1528)
+export { assertNodeEnv_build };
+export { assertNodeEnv_runtime };
+export { assertNodeEnv_onVikePluginLoad };
+// Vite already handles build
+export { handleNodeEnv_prerender };
+export { handleNodeEnv_vitePluginVercel };
 import pc from '@brillout/picocolors';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
-import { assertUsage } from './assert.js';
+import { assertWarning } from './assert.js';
+import { vikeVitePluginLoadedInProductionError } from './assertIsNotProductionRuntime.js';
 assertIsNotBrowser();
+function assertNodeEnv_build() {
+    assertNodeEnvIsNotDev('building');
+}
+function assertNodeEnv_runtime(viteDevServerExists) {
+    const nodeEnv = getNodeEnv();
+    if (nodeEnv === null || nodeEnv === 'test')
+        return;
+    const isDev = isNodeEnvDev();
+    // Calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
+    if (viteDevServerExists === isDev)
+        return;
+    const nodeEnvDesc = getNodeEnvDesc();
+    // TODO: make it assertUsage() again once #1528 is implemented.
+    assertWarning(false, `Vite's development server was${viteDevServerExists ? '' : "n't"} instantiated while the ${nodeEnvDesc} which is contradictory, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+}
+function assertNodeEnv_onVikePluginLoad() {
+    const nodeEnv = getNodeEnv();
+    if (nodeEnv === 'test')
+        return;
+    // TODO: make it assertUsage() again once #1528 is implemented.
+    assertWarning(
+    /* We can enable this assertion after Vike's CLI is implemented and using Vite's CLI is deprecated (we can then check whether the context is a `$ vike build`).
+    isNodeEnvDev() || isVikeCliBuild(),
+    /*/
+    isNodeEnvDev() || true, 
+    ///*/
+    [
+        pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`),
+        '(which Vike interprets as a non-development environment https://vike.dev/NODE_ENV)',
+        'while the vike/plugin module is loaded.',
+        vikeVitePluginLoadedInProductionError
+    ].join(' '), { onlyOnce: true });
+}
+function handleNodeEnv_prerender() {
+    const assertNodeEnv = () => assertNodeEnvIsNotDev('pre-rendering');
+    if (getNodeEnv())
+        assertNodeEnv();
+    setNodeEnvToProduction();
+    assertNodeEnv();
+}
+function handleNodeEnv_vitePluginVercel() {
+    setNodeEnvToProduction();
+}
 function getNodeEnv() {
     if (typeof process === 'undefined')
         return null;
@@ -41,5 +95,8 @@ function assertNodeEnvIsNotDev(operation) {
     if (!isDev)
         return;
     const nodeEnvDesc = getNodeEnvDesc();
-    assertUsage(false, `The ${nodeEnvDesc} which is forbidden upon ${operation}, see https://vike.dev/NODE_ENV`);
+    // TODO: make it assertUsage() again once #1528 is implemented.
+    assertWarning(false, `The ${nodeEnvDesc} which is forbidden upon ${operation}, see https://vike.dev/NODE_ENV`, {
+        onlyOnce: true
+    });
 }

package/dist/esm/utils/assertNodeVersion.js

@@ -1,11 +1,10 @@
 export { assertNodeVersion };
-import { assertUsage } from './assert.js';
 import { isNodeJS } from './isNodeJS.js';
-import { isVersionOrAbove } from './isVersionOrAbove.js';
-// package.json#engines.node isn't enough as users can ignore it
+import { assertVersion } from './assertVersion.js';
+// node_modules/vike/package.json#engines.node isn't enough as users can ignore it
 function assertNodeVersion() {
     if (!isNodeJS())
         return;
     const version = process.versions.node;
-    assertUsage(isVersionOrAbove(version, '16.0.0'), `Node.js ${version} isn't supported, use Node.js >=16.0.0 instead.`);
+    assertVersion('Node.js', version, '16.0.0');
 }

package/dist/esm/utils/assertVersion.d.ts

@@ -0,0 +1,4 @@
+export { assertVersion };
+export { isVersionOrAbove };
+declare function assertVersion(dependencyName: 'Vite' | 'Node.js', versionActual: string, versionExpected: `${number}.${number}.${number}`): void;
+declare function isVersionOrAbove(versionActual: string, versionExpected: `${number}.${number}.${number}`): boolean;

package/dist/esm/utils/{isVersionOrAbove.js → assertVersion.js}

@@ -1,5 +1,9 @@
+export { assertVersion };
 export { isVersionOrAbove };
-import { assert } from './assert.js';
+import { assert, assertUsage } from './assert.js';
+function assertVersion(dependencyName, versionActual, versionExpected) {
+    assertUsage(isVersionOrAbove(versionActual, versionExpected), `${dependencyName} ${versionActual} isn't supported, use ${dependencyName} >= ${versionExpected} instead.`);
+}
 function isVersionOrAbove(versionActual, versionExpected) {
     const p1 = parseVersion(versionActual);
     const p2 = parseVersion(versionExpected);

package/dist/esm/utils/projectInfo.d.ts

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
-declare const PROJECT_VERSION: "0.4.163";
+declare const PROJECT_VERSION: "0.4.165";
 declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.163";
+    projectVersion: "0.4.165";
 };

package/dist/esm/utils/projectInfo.js

@@ -1,7 +1,7 @@
 export { projectInfo };
 export { PROJECT_VERSION };
 import { onProjectInfo } from './assertSingleInstance.js';
-const PROJECT_VERSION = '0.4.163';
+const PROJECT_VERSION = '0.4.165';
 const projectInfo = {
     projectName: 'Vike',
     projectVersion: PROJECT_VERSION

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.163",
+  "version": "0.4.165",
   "scripts": {
     "dev": "tsc --watch",
     "build": "rimraf dist/ && pnpm run build:esm && pnpm run build:cjs",
@@ -116,7 +116,7 @@
   },
   "peerDependencies": {
     "react-streaming": ">=0.3.5",
-    "vite": ">=3.1.0"
+    "vite": ">=4.4.0"
   },
   "peerDependenciesMeta": {
     "react-streaming": {
@@ -169,6 +169,7 @@
     "vike": "./node/cli/bin-entry.js"
   },
   "devDependencies": {
+    "@biomejs/biome": "^1.5.3",
     "@brillout/import": "^0.2.3",
     "@brillout/json-serializer": "^0.5.8",
     "@brillout/picocolors": "^1.0.10",

package/dist/esm/utils/isVersionOrAbove.d.ts

@@ -1,2 +0,0 @@
-export { isVersionOrAbove };
-declare function isVersionOrAbove(versionActual: string, versionExpected: `${number}.${number}.${number}`): boolean;