vike 0.4.267-commit-b005535 → 0.4.267-commit-5676e14

package/dist/types/PageContext.d.ts

@@ -27,11 +27,19 @@ import type { PageContextPublicProxyClient } from '../client/runtime-client-rout
 type PageContextServer<Data = unknown> = PageContextBuiltInServer<Data> & {
     /** https://vike.dev/warning/internals */
     dangerouslyUseInternals: DangerouslyUseInternals<PageContextInternalServer & PageContextAfterRender & PageContextPublicServer>;
-} & Vike.PageContext & Vike.PageContextServer & (Vike.Server extends {
+} & Vike.PageContext & Vike.PageContextServer & PageContextContent & (Vike.Server extends {
     server: string;
 } ? {
     runtime: RuntimeAdapterTarget<Vike.Server['server']>;
 } & PageContextReqResAlias<Vike.Server['server']> : {});
+type PageContextContent = {
+    /**
+     * The content of a non-HTML page — the HTTP response body (SSR) or the file content (pre-rendering).
+     *
+     * https://vike.dev/pageContext#content
+     */
+    content?: string | Uint8Array | ReadableStream<Uint8Array>;
+};
 type PageContextReqResAlias<Server extends string> = ReqResAlias<'req', RuntimeAdapterTarget<Server>> & ReqResAlias<'res', RuntimeAdapterTarget<Server>>;
 type ReqResAlias<Key extends 'req' | 'res', Runtime> = Key extends keyof (Vike.PageContext & Vike.PageContextServer) ? unknown : Key extends keyof Runtime ? Record<Key, Runtime[Key]> : unknown;
 type PageContext<Data = unknown> = PageContextClient<Data> | PageContextServer<Data>;
@@ -194,6 +202,15 @@ type PageContextBuiltInServer<Data> = PageContextBuiltInCommon<Data> & PageConte
      * https://vike.dev/pageContext#pageContextsAborted
      */
     pageContextsAborted: Partial<PageContextServer<Data>>[];
+    /**
+     * @experimental
+     *
+     * https://vike.dev/meta#vike-environments
+     */
+    environments?: Record<string, {
+        config: PageContextConfig['config'];
+        pageContext: PageContextServer<Data>;
+    }>;
     isHydration?: undefined;
     isBackwardNavigation?: undefined;
     isHistoryNavigation?: undefined;

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: '0.4.267-commit-b005535';
+export declare const PROJECT_VERSION: '0.4.267-commit-5676e14';

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.267-commit-b005535';
+export const PROJECT_VERSION = '0.4.267-commit-5676e14';

package/dist/utils/assertViteVersion.d.ts

@@ -1,4 +1,2 @@
 export { assertViteVersion };
-export { viteVersionMin };
-declare const viteVersionMin = "6.3.0";
-declare function assertViteVersion(viteVersion: string): void;
+declare function assertViteVersion(viteVersion: string | undefined): void;

package/dist/utils/assertViteVersion.js

@@ -1,14 +1,11 @@
 export { assertViteVersion };
-export { viteVersionMin };
+import { assertUsage } from './assert.js';
 import { assertVersion } from './assertVersion.js';
-const viteVersionMin = '6.3.0';
-// package.json#peerDependencies isn't enough, as users often ignore it
+const viteVersionMin = '7.1.0';
+// - package.json#peerDependencies isn't enough, as users often ignore it
+// - `import { version } from 'vite'` isn't reliable: the user may still use an older Vite version — see https://github.com/vitejs/vite/pull/19355
 function assertViteVersion(viteVersion) {
-    // - This assertion isn't reliable: the user may still use a Vite version older than 6.0.0 — see https://github.com/vitejs/vite/pull/19355
-    //   - TO-DO/eventually: let's also use this.meta.viteVersion
-    //     - this.meta.viteVersion was released in vite@7.0.0 => let's use it only after Vike requires a Vite version above 7.0.0
-    //     - https://github.com/vitejs/vite/blob/main/packages/vite/CHANGELOG.md#700-2025-06-24
-    //     - https://github.com/vitejs/vite/pull/20088
-    //     - We can then remove the assertUsage() at isViteServerSide.ts — see viteVersionMin export usage
+    // `viteVersion` is `undefined` on Vite 6 and older (their `config` hook has no `this`); assertVersion() needs a string
+    assertUsage(viteVersion, `You're using an old Vite version — update Vite to ${viteVersionMin} or above.`);
     assertVersion('Vite', viteVersion, [viteVersionMin]);
 }

package/dist/utils/catchInfiniteLoop.js

@@ -1,20 +1,40 @@
 export { catchInfiniteLoop };
-import { assertUsage, assertWarning } from './assert.js';
+import { assert, assertUsage, assertWarning } from './assert.js';
 import { humanizeTime } from './humanizeTime.js';
-const trackers = {};
+const trackers = new Map();
+let lastCleanup;
+// Given these parameters, a warning is shown upon 10 calls a second on average during 5 seconds
 const maxCalls = 99;
 const time = 5 * 1000;
 function catchInfiniteLoop(functionName) {
     // Init
     const now = new Date().getTime();
-    // Clean all outdated trackers
-    Object.keys(trackers).forEach((key) => {
-        const tracker = trackers[key];
-        const elapsedTime = now - tracker.startTime;
-        if (elapsedTime > time)
-            delete trackers[key];
-    });
-    const tracker = (trackers[functionName] ?? (trackers[functionName] = { count: 0, startTime: now }));
+    // Cleanup
+    if (globalThis.__VIKE__IS_CLIENT) {
+        // No cleanup on the client-side, in order to minimize client-side JavaScript (to save client-side KBs)
+        assert(trackers.size < 5);
+    }
+    else {
+        // Clean outdated trackers
+        // - On the server-side, there is an infinite amount of outdated trackers (a new tracker is created per HTTP request) => we should clean them
+        // - We don't clean upon every call: the server creates a new tracker per HTTP request, so that would cost O(n^2) — O(number of requests within `time`) per request
+        //   - https://github.com/vikejs/vike/pull/3576
+        const cleanInterval = 10 * 1000;
+        lastCleanup ?? (lastCleanup = now);
+        if (now - lastCleanup > cleanInterval) {
+            trackers.forEach((tracker, key) => {
+                if (isOutdated(tracker, now))
+                    trackers.delete(key);
+            });
+            lastCleanup = now;
+        }
+    }
+    // Get/reset tracker
+    let tracker = trackers.get(functionName);
+    if (!tracker || isOutdated(tracker, now)) {
+        tracker = { count: 0, startTime: now };
+        trackers.set(functionName, tracker);
+    }
     // Count
     tracker.count++;
     // Error
@@ -24,8 +44,10 @@ function catchInfiniteLoop(functionName) {
     }
     // Warning, at 50% threshold
     if (!tracker.warned && tracker.count > maxCalls * 0.5) {
-        // Warning is shown upon 10 calls a second, on average during 5 seconds, given the default parameters
         assertWarning(false, msg, { onlyOnce: false, showStackTrace: true });
         tracker.warned = true;
     }
 }
+function isOutdated(tracker, now) {
+    return now - tracker.startTime > time;
+}

package/dist/utils/deepEqual.d.ts

@@ -1 +1,2 @@
-export declare function deepEqual(x: any, y: any): boolean;
+export { deepEqual };
+declare function deepEqual(x: any, y: any): boolean;

package/dist/utils/deepEqual.js

@@ -1,7 +1,22 @@
-// https://stackoverflow.com/questions/201183/how-to-determine-equality-for-two-javascript-objects/32922084#32922084
-export function deepEqual(x, y) {
-    const ok = Object.keys, tx = typeof x, ty = typeof y;
-    return x && y && tx === 'object' && tx === ty
-        ? ok(x).length === ok(y).length && ok(x).every((key) => deepEqual(x[key], y[key]))
-        : x === y;
+export { deepEqual };
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+// If client-side needs it then use a more minimal version to save client-side KBs:
+// https://github.com/vikejs/vike/blob/165d572a5994ccd0e56e43fe2993b1cef117ee7f/packages/vike/src/utils/deepEqual.ts
+assertIsNotBrowser();
+function deepEqual(x, y) {
+    return deepEqualCyclic(x, y, new Map());
+}
+// Supports cyclic objects, e.g. Vite plugins
+function deepEqualCyclic(x, y, seen) {
+    if (x === y)
+        return true;
+    if (!x || !y || typeof x !== 'object' || typeof y !== 'object')
+        return false;
+    // A pair seen before is either being compared higher up (a cycle) or already found equal
+    const seenY = seen.get(x) ?? new Set();
+    if (seenY.has(y))
+        return true;
+    seen.set(x, seenY.add(y));
+    const keys = Object.keys(x);
+    return keys.length === Object.keys(y).length && keys.every((key) => deepEqualCyclic(x[key], y[key], seen));
 }

package/dist/utils/getContentTypeFromUrl.d.ts

@@ -0,0 +1,2 @@
+export { getContentTypeFromUrl };
+declare function getContentTypeFromUrl(url: string): string | null;

package/dist/utils/getContentTypeFromUrl.js

@@ -0,0 +1,39 @@
+export { getContentTypeFromUrl };
+import { parseUrl } from './parseUrl.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
+const contentTypes = new Map(Object.entries({
+    atom: 'application/atom+xml;charset=utf-8',
+    rss: 'application/rss+xml;charset=utf-8',
+    xml: 'application/xml;charset=utf-8',
+    json: 'application/json',
+    jsonld: 'application/ld+json',
+    webmanifest: 'application/manifest+json',
+    txt: 'text/plain;charset=utf-8',
+    md: 'text/markdown;charset=utf-8',
+    csv: 'text/csv;charset=utf-8',
+    ics: 'text/calendar;charset=utf-8',
+    html: 'text/html;charset=utf-8',
+    htm: 'text/html;charset=utf-8',
+    css: 'text/css;charset=utf-8',
+    js: 'text/javascript;charset=utf-8',
+    mjs: 'text/javascript;charset=utf-8',
+    svg: 'image/svg+xml',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    avif: 'image/avif',
+    ico: 'image/x-icon',
+    pdf: 'application/pdf',
+}));
+// Content-Type of the URL's file extension, or `null` if unknown, see https://vike.dev/pageContext#content
+function getContentTypeFromUrl(url) {
+    const { pathname } = parseUrl(url, '/');
+    // Last non-empty segment, see https://vike.dev/url-normalization
+    const fileName = pathname.split('/').filter(Boolean).pop() ?? '';
+    const i = fileName.lastIndexOf('.');
+    const fileExtension = i > 0 ? fileName.slice(i + 1).toLowerCase() : null;
+    return (fileExtension && contentTypes.get(fileExtension)) || null;
+}

package/dist/utils/injectRollupInputs.d.ts

@@ -1,7 +1,7 @@
 export { injectRollupInputs };
 export { normalizeRollupInput };
-import type { ResolvedConfig, Rollup } from 'vite';
+import type { Rollup } from 'vite';
 type InputOption = Rollup.InputOption;
 type InputsMap = Record<string, string>;
-declare function injectRollupInputs(inputsNew: InputsMap, config: ResolvedConfig): InputsMap;
+declare function injectRollupInputs(inputsNew: InputsMap, inputCurrent: InputOption | undefined): InputsMap;
 declare function normalizeRollupInput(input?: InputOption): InputsMap;

package/dist/utils/injectRollupInputs.js

@@ -3,8 +3,8 @@ export { normalizeRollupInput };
 import { assert } from './assert.js';
 import { isObject } from './isObject.js';
 import { isArray } from './isArray.js';
-function injectRollupInputs(inputsNew, config) {
-    const inputsCurrent = normalizeRollupInput(config.build.rollupOptions.input);
+function injectRollupInputs(inputsNew, inputCurrent) {
+    const inputsCurrent = normalizeRollupInput(inputCurrent);
     const input = {
         ...inputsNew,
         ...inputsCurrent,

package/dist/utils/isDev.js

@@ -1,15 +1,10 @@
 export { isDevCheck };
 export { applyDev };
 export { applyPreview };
-import { assertUsage } from './assert.js';
+import { assert } from './assert.js';
 function isDevCheck(configEnv) {
     const { isPreview, command } = configEnv;
-    // Note that:
-    // - `assertVersion('Vite', version, '5.1.0')` isn't enough: https://github.com/vitejs/vite/pull/19355
-    // - We'll eventually be able to make this an assert() instead of assertUsage() once Vike requires a Vite version that supports this.meta.viteVersion
-    //   - https://github.com/vitejs/vite/pull/20088
-    //   - Released at 7.0.0: https://github.com/vitejs/vite/blob/main/packages/vite/CHANGELOG.md#700-2025-06-24
-    assertUsage(typeof isPreview === 'boolean', 'You are using an old Vite version; make sure to use Vite 5.1.0 or above.');
+    assert(typeof isPreview === 'boolean');
     return command === 'serve' && !isPreview;
 }
 function applyDev(_, env) {

package/dist/utils/parseUrl-extras.js

@@ -10,6 +10,7 @@ import { assertUrlComponents, createUrlFromComponents, isBaseServer, parseUrl }
 import { assert } from './assert.js';
 import { slice } from './slice.js';
 import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+import { getContentTypeFromUrl } from './getContentTypeFromUrl.js';
 assertIsNotBrowser();
 function prependBase(url, baseServer) {
     if (baseServer.startsWith('http')) {
@@ -61,6 +62,9 @@ function normalizeUrlPathname(urlOriginal, trailingSlash, baseServer) {
         if (urlPathnameNormalized === '/') {
             return urlPathnameNormalized;
         }
+        // A file URL such as /feed.atom doesn't get a trailing slash
+        if (getContentTypeFromUrl(urlPathnameNormalized))
+            trailingSlash = false;
         // If the Base URL has a trailing slash, then Vite (as of vite@5.0.0-beta.19) expects the root URL to also have a trailing slash, see https://github.com/vikejs/vike/issues/1258#issuecomment-1812226260
         if (baseServer.endsWith('/') && baseServer !== '/' && normalize(baseServer) === urlPathnameNormalized) {
             trailingSlash = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.267-commit-b005535",
+  "version": "0.4.267-commit-5676e14",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -125,13 +125,13 @@
     "@babel/core": "^7.28.5",
     "@babel/types": "^7.28.5",
     "@brillout/import": "^0.2.6",
-    "@brillout/json-serializer": "^0.5.25",
+    "@brillout/json-serializer": "^0.5.27",
     "@brillout/picocolors": "^1.0.31",
-    "@brillout/vite-plugin-server-entry": "^0.7.21",
+    "@brillout/vite-plugin-server-entry": "^0.7.23",
     "@universal-deploy/store": "^0.2.2",
-    "@universal-deploy/vite": "^0.1.13",
+    "@universal-deploy/vite": "^0.1.14",
     "@universal-middleware/core": "^0.4.18",
-    "@universal-middleware/node": "^0.2.2",
+    "@universal-middleware/node": "^0.2.3",
     "cac": "^6.0.0",
     "convert-route": "^1.1.1",
     "es-module-lexer": "^1.0.0",
@@ -143,12 +143,12 @@
     "sirv": "^3.0.2",
     "source-map-support": "^0.5.0",
     "tinyglobby": "^0.2.17",
-    "vite": ">=6.3.0",
+    "vite": ">=7.1.0",
     "vite-plugin-wrapper": "^0.1.1"
   },
   "peerDependencies": {
     "react-streaming": ">=0.3.42",
-    "vite": ">=6.3.0"
+    "vite": ">=7.1.0"
   },
   "peerDependenciesMeta": {
     "react-streaming": {

package/dist/shared-server-client/addIs404ToPageProps.d.ts

@@ -1,2 +0,0 @@
-export { addIs404ToPageProps };
-declare function addIs404ToPageProps(pageContext: Record<string, unknown>): void;

package/dist/shared-server-client/addIs404ToPageProps.js

@@ -1,17 +0,0 @@
-export { addIs404ToPageProps };
-import { assertWarning } from '../utils/assert.js';
-import { isObject } from '../utils/isObject.js';
-function addIs404ToPageProps(pageContext) {
-    addIs404(pageContext);
-}
-function addIs404(pageContext) {
-    if (pageContext.is404 === undefined || pageContext.is404 === null)
-        return;
-    const pageProps = pageContext.pageProps || {};
-    if (!isObject(pageProps)) {
-        assertWarning(false, 'pageContext.pageProps should be an object', { showStackTrace: true, onlyOnce: true });
-        return;
-    }
-    pageProps.is404 = pageProps.is404 || pageContext.is404;
-    pageContext.pageProps = pageProps;
-}