vike 0.4.227 → 0.4.228-commit-1553dee

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

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobalContext = getGlobalContext;
 exports.getGlobalContextSync = getGlobalContextSync;
 exports.getGlobalContextAsync = getGlobalContextAsync;
 exports.getGlobalContextInternal = getGlobalContextInternal;
@@ -18,7 +19,6 @@ exports.setGlobalContext_isProduction = setGlobalContext_isProduction;
 exports.setGlobalContext_buildEntry = setGlobalContext_buildEntry;
 exports.clearGlobalContext = clearGlobalContext;
 exports.assertBuildInfo = assertBuildInfo;
-exports.getViteConfigRuntime = getViteConfigRuntime;
 exports.updateUserFiles = updateUserFiles;
 // The core logic revolves around:
 // - globalObject.userFiles which is the main requirement for resolveGlobalContext()
@@ -59,13 +59,24 @@ function assertGlobalContextIsDefined() {
     assertIsDefined(globalObject.globalContext);
     (0, utils_js_1.assert)(globalObject.globalContext_public);
 }
-/** @experimental https://vike.dev/getGlobalContext */
-function getGlobalContextSync() {
-    const { globalContext_public } = globalObject;
-    (0, utils_js_1.assertUsage)(globalContext_public, "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContextAsync() instead.");
-    return globalContext_public;
-}
-/** @experimental https://vike.dev/getGlobalContext */
+/**
+ * Get runtime information about your app.
+ *
+ * https://vike.dev/getGlobalContext
+ */
+async function getGlobalContext() {
+    debug('getGlobalContext()');
+    const { isProduction } = globalObject;
+    // This assertion cannot fail for vike-server users (because when using vike-server it's guaranteed that globalObject.isProduction is set before executing any user-land code and any Vike extension code).
+    (0, utils_js_1.assertUsage)(isProduction !== undefined, "The global context isn't set yet, use getGlobalContextAsync() instead.");
+    (0, utils_js_1.assert)(typeof globalObject.isProduction === 'boolean');
+    return await getGlobalContextAsync(isProduction);
+}
+/**
+ * Get runtime information about your app.
+ *
+ * https://vike.dev/getGlobalContext
+ */
 async function getGlobalContextAsync(isProduction) {
     debug('getGlobalContextAsync()');
     (0, utils_js_1.assertUsage)(typeof isProduction === 'boolean', `[getGlobalContextAsync(isProduction)] Argument ${picocolors_1.default.cyan('isProduction')} ${isProduction === undefined ? 'is missing' : `should be ${picocolors_1.default.cyan('true')} or ${picocolors_1.default.cyan('false')}`}`);
@@ -79,11 +90,29 @@ async function getGlobalContextAsync(isProduction) {
     (0, utils_js_1.assert)(globalContext_public);
     return globalContext_public;
 }
+/**
+ * Get runtime information about your app.
+ *
+ * https://vike.dev/getGlobalContext
+ *
+ * @deprecated
+ */
+function getGlobalContextSync() {
+    debug('getGlobalContextSync()');
+    const { globalContext_public } = globalObject;
+    (0, utils_js_1.assertUsage)(globalContext_public, "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.");
+    (0, utils_js_1.assertWarning)(false, 
+    // We discourage users from using it because using `pageContext.globalContext` is better: it doesn't have the race condition issue that `getGlobalContextSync()` would have when called inside React/Vue components.
+    // We're lying about "is going to be deprecated in the next major release": let's keep it and see if users need it (so far I can't see a use case for it).
+    'getGlobalContextSync() is going to be deprecated in the next major release, see https://vike.dev/getGlobalContext', { onlyOnce: true });
+    return globalContext_public;
+}
 function makePublic(globalContext) {
     const globalContextPublic = (0, utils_js_1.makePublicCopy)(globalContext, 'globalContext', [
         'assetsManifest',
         'config',
         'viteConfig',
+        'viteConfigRuntime',
         'pages',
         'baseServer',
         'baseAssets'
@@ -103,12 +132,12 @@ async function setGlobalContext_viteDevServer(viteDevServer) {
     assertGlobalContextIsDefined();
     globalObject.viteDevServerPromiseResolve(viteDevServer);
 }
-function setGlobalContext_viteConfig(viteConfig, outDirRoot) {
+function setGlobalContext_viteConfig(viteConfig, viteConfigRuntime) {
     if (globalObject.viteConfig)
         return;
     assertIsNotInitilizedYet();
     globalObject.viteConfig = viteConfig;
-    globalObject.outDirRoot = outDirRoot;
+    globalObject.viteConfigRuntime = viteConfigRuntime;
 }
 function assertIsNotInitilizedYet() {
     // In development, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
@@ -118,8 +147,13 @@ function setGlobalContext_isPrerendering() {
     globalObject.isPrerendering = true;
     setIsProduction(true);
 }
-function setGlobalContext_isProduction(isProduction) {
-    setIsProduction(isProduction);
+function setGlobalContext_isProduction(isProduction, tolerateContraditction) {
+    if (globalObject.isProduction === undefined) {
+        setIsProduction(isProduction);
+    }
+    else {
+        (0, utils_js_1.assert)(globalObject.isProduction === isProduction || tolerateContraditction);
+    }
 }
 function getViteDevServer() {
     return globalObject.viteDevServer ?? null;
@@ -143,7 +177,6 @@ async function initGlobalContext_runPrerender() {
     globalObject.initGlobalContext_runPrerender_alreadyCalled = true;
     (0, utils_js_1.assert)(globalObject.isPrerendering);
     (0, utils_js_1.assert)(globalObject.viteConfig);
-    (0, utils_js_1.assert)(globalObject.outDirRoot);
     // We assume initGlobalContext_runPrerender() to be called before:
     // - initGlobalContext_renderPage()
     // - initGlobalContext_getGlobalContextAsync()
@@ -179,7 +212,7 @@ async function initGlobalContext() {
         await waitForViteDevServer();
     }
     else {
-        await loadBuildEntry(globalObject.outDirRoot);
+        await loadBuildEntry(globalObject.viteConfigRuntime?.build.outDir);
     }
     assertGlobalContextIsDefined();
     globalObject.isInitialized = true;
@@ -202,7 +235,7 @@ function defineGlobalContext() {
     (0, utils_js_1.onSetupRuntime)();
 }
 function resolveGlobalContext() {
-    const { viteDevServer, viteConfig, isPrerendering, isProduction, userFiles } = globalObject;
+    const { viteDevServer, viteConfig, viteConfigRuntime, isPrerendering, isProduction, userFiles } = globalObject;
     (0, utils_js_1.assert)(typeof isProduction === 'boolean');
     let globalContext;
     if (!isProduction) {
@@ -211,8 +244,8 @@ function resolveGlobalContext() {
             return null;
         (0, utils_js_1.assert)(userFiles); // main common requiement
         (0, utils_js_1.assert)(viteConfig);
+        (0, utils_js_1.assert)(viteConfigRuntime);
         (0, utils_js_1.assert)(!isPrerendering);
-        const viteConfigRuntime = getViteConfigRuntime(viteConfig);
         globalContext = {
             isProduction: false,
             isPrerendering: false,
@@ -312,14 +345,12 @@ async function loadBuildEntry(outDir) {
             globalObject.buildEntry = globalObject.buildEntryPrevious;
         }
         (0, utils_js_1.assert)(globalObject.buildEntry);
+        // If using `inject` then dist/server/index.js imports dist/server/entry.js and loadBuildEntry() isn't needed.
+        // If dist/server/entry.js isn't imported then this means the user is running the original server entry `$ ts-node server/index.ts`.
         (0, utils_js_1.assertWarning)(
-        // vike-server => `vitePluginServerEntry.inject === true`
-        // vike-node => `vitePluginServerEntry.inject === [ 'index' ]`
-        globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject !== true, 
-        /* TO-DO/eventually:
-        !!globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject,
-        */
-        `Run the built server entry (e.g. ${picocolors_1.default.cyan('$ node dist/server/index.mjs')}) instead of the original server entry (e.g. ${picocolors_1.default.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
+        // vike-server => `inject === true`
+        // vike-node => `inject === [ 'index' ]` => we don't show the warning to vike-node users (I don't remember why).
+        globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject !== true || globalObject.isPrerendering, `Run the built server entry (e.g. ${picocolors_1.default.cyan('$ node dist/server/index.mjs')}) instead of the original server entry (e.g. ${picocolors_1.default.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
     }
     const { buildEntry } = globalObject;
     assertBuildEntry(buildEntry);
@@ -355,25 +386,17 @@ function assertBuildInfo(buildInfo) {
     assertVersionAtBuildTime(buildInfo.versionAtBuildTime);
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo, 'viteConfigRuntime', 'object'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo.viteConfigRuntime, '_baseViteOriginal', 'string'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo.viteConfigRuntime, 'root', 'string'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo.viteConfigRuntime, 'build', 'object'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo.viteConfigRuntime.build, 'outDir', 'string'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo.viteConfigRuntime, 'vitePluginServerEntry', 'object'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo, 'usesClientRouter', 'boolean'));
-    (0, utils_js_1.checkType)({ ...buildInfo, viteConfigRuntime: buildInfo.viteConfigRuntime });
 }
 function assertVersionAtBuildTime(versionAtBuildTime) {
     const versionAtRuntime = utils_js_1.PROJECT_VERSION;
     const pretty = (version) => picocolors_1.default.bold(`vike@${version}`);
     (0, utils_js_1.assertUsage)(versionAtBuildTime === versionAtRuntime, `Re-build your app (you're using ${pretty(versionAtRuntime)} but your app was built with ${pretty(versionAtBuildTime)})`);
 }
-function getViteConfigRuntime(viteConfig) {
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(viteConfig, '_baseViteOriginal', 'string'));
-    const viteConfigRuntime = {
-        _baseViteOriginal: viteConfig._baseViteOriginal,
-        vitePluginServerEntry: {
-            inject: viteConfig.vitePluginServerEntry?.inject
-        }
-    };
-    return viteConfigRuntime;
-}
 async function updateUserFiles() {
     const { promise, resolve } = (0, utils_js_1.genPromise)();
     (0, utils_js_1.assert)(!globalObject.isProduction);

package/dist/cjs/node/runtime/html/stream.js

@@ -522,7 +522,6 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
     if (isStreamReadableWeb(streamOriginal)) {
         debug('onRenderHtml() hook returned Web Readable');
         const readableOriginal = streamOriginal;
-        let controllerProxyIsClosed = false;
         let isClosed = false;
         let isCancel = false;
         const closeStream = async () => {
@@ -531,7 +530,6 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
             isClosed = true;
             await onEnd(isCancel);
             controllerProxy.close();
-            controllerProxyIsClosed = true;
         };
         let controllerProxy;
         assertReadableStreamConstructor();
@@ -559,8 +557,8 @@ async function createStreamWrapper({ streamOriginal, onError, onData, onEnd, onF
         });
         const writeChunk = (chunk) => {
             if (
-            // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether we closed `controllerProxy`.
-            !controllerProxyIsClosed) {
+            // If readableOriginal doesn't implement readableOriginal.cancel() then it may still emit data after we close the stream. We therefore need to check whether the steam is closed.
+            !isClosed) {
                 controllerProxy.enqueue(encodeForWebStream(chunk));
                 debugWithChunk('data written (Web Readable)', chunk);
             }

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPageRenderer = exports._injectAssets = exports.createDevMiddleware = exports.getGlobalContextAsync = exports.getGlobalContextSync = exports.version = exports.stampPipe = exports.pipeStream = exports.pipeNodeStream = exports.pipeWebStream = exports.dangerouslySkipEscape = exports.escapeInject = exports.renderPage = void 0;
+exports.createPageRenderer = exports._injectAssets = exports.createDevMiddleware = exports.getGlobalContextAsync = exports.getGlobalContextSync = exports.getGlobalContext = exports.version = 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");
@@ -14,6 +14,7 @@ Object.defineProperty(exports, "stampPipe", { enumerable: true, get: function ()
 var utils_js_1 = require("./utils.js");
 Object.defineProperty(exports, "version", { enumerable: true, get: function () { return utils_js_1.PROJECT_VERSION; } });
 var globalContext_js_1 = require("./globalContext.js");
+Object.defineProperty(exports, "getGlobalContext", { enumerable: true, get: function () { return globalContext_js_1.getGlobalContext; } });
 Object.defineProperty(exports, "getGlobalContextSync", { enumerable: true, get: function () { return globalContext_js_1.getGlobalContextSync; } });
 Object.defineProperty(exports, "getGlobalContextAsync", { enumerable: true, get: function () { return globalContext_js_1.getGlobalContextAsync; } });
 var index_js_1 = require("../runtime-dev/index.js");

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

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderPageAlreadyRouted = renderPageAlreadyRouted;
 exports.prerenderPage = prerenderPage;
-exports.prerender404Page = prerender404Page;
 exports.getPageContextInitEnhanced = getPageContextInitEnhanced;
 exports.createPageContext = createPageContext;
 const error_page_js_1 = require("../../../shared/error-page.js");
@@ -85,28 +84,6 @@ async function prerenderPage(pageContext) {
         return { documentHtml, pageContextSerialized, pageContext };
     }
 }
-async function prerender404Page(pageContextInit_, globalContext) {
-    const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext.pageFilesAll, globalContext.pageConfigs);
-    if (!errorPageId) {
-        return null;
-    }
-    // A URL is required for `viteDevServer.transformIndexHtml(url,html)`
-    const pageContextInit = { urlOriginal: '/fake-404-url' };
-    (0, utils_js_1.objectAssign)(pageContextInit, pageContextInit_);
-    const pageContext = await getPageContextInitEnhanced(pageContextInit, globalContext, true);
-    (0, utils_js_1.objectAssign)(pageContext, {
-        pageId: errorPageId,
-        _httpRequestId: null,
-        _urlRewrite: null,
-        is404: true,
-        routeParams: {},
-        // `prerender404Page()` is about generating `dist/client/404.html` for static hosts; there is no Client Routing.
-        _usesClientRouter: false,
-        _debugRouteMatches: []
-    });
-    (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
-    return prerenderPage(pageContext);
-}
 async function getPageContextInitEnhanced(pageContextInit, globalContext, isPrerendering, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
     urlRewrite: null,
     urlHandler: null,

package/dist/cjs/node/runtime-dev/createDevMiddleware.js

@@ -10,7 +10,7 @@ const globalContext_js_1 = require("../runtime/globalContext.js");
  * https://vike.dev/createDevMiddleware
  */
 async function createDevMiddleware(options = {}) {
-    (0, globalContext_js_1.setGlobalContext_isProduction)(false);
+    (0, globalContext_js_1.setGlobalContext_isProduction)(false, true);
     const optionsMod = {
         ...options,
         viteConfig: {

package/dist/cjs/shared/route/executeOnBeforeRouteHook.js

@@ -72,7 +72,7 @@ async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
     if ((0, utils_js_1.hasProp)(hookReturn.pageContext, 'urlLogical')) {
         (0, utils_js_1.assertUsageUrlPathnameAbsolute)(
         // We skip validation and type-cast instead of assertUsage() in order to save client-side KBs
-        hookReturn.pageContext.urlLogical, `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { urlLogical } }')} but ${picocolors_1.default.cyan('urlLogical')}`);
+        hookReturn.pageContext.urlLogical, `${errPrefix} returned ${picocolors_1.default.cyan('{ pageContext: { urlLogical } }')} and ${picocolors_1.default.cyan('urlLogical')}`);
     }
     (0, assertPageContextProvidedByUser_js_1.assertPageContextProvidedByUser)(hookReturn.pageContext, {
         hookFilePath: onBeforeRouteHook.hookFilePath,

package/dist/cjs/shared/route/index.js

@@ -18,23 +18,25 @@ const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const executeOnBeforeRouteHook_js_1 = require("./executeOnBeforeRouteHook.js");
 const debug_js_1 = require("./debug.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-async function route(pageContext) {
+async function route(pageContext, skipOnBeforeRouteHook) {
     (0, debug_js_1.debug)('Pages routes:', pageContext._pageRoutes);
     (0, getPageContextUrlComputed_js_1.assertPageContextUrl)(pageContext);
     const pageContextFromRoute = {};
     // onBeforeRoute()
-    const pageContextFromOnBeforeRouteHook = await (0, executeOnBeforeRouteHook_js_1.executeOnBeforeRouteHook)(pageContext);
-    if (pageContextFromOnBeforeRouteHook) {
-        if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
-            (0, utils_js_1.assert)(pageContextFromOnBeforeRouteHook.pageId);
-            return pageContextFromOnBeforeRouteHook;
-        }
-        else {
-            (0, utils_js_1.objectAssign)(pageContextFromRoute, pageContextFromOnBeforeRouteHook);
+    if (!skipOnBeforeRouteHook) {
+        const pageContextFromOnBeforeRouteHook = await (0, executeOnBeforeRouteHook_js_1.executeOnBeforeRouteHook)(pageContext);
+        if (pageContextFromOnBeforeRouteHook) {
+            if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
+                (0, utils_js_1.assert)(pageContextFromOnBeforeRouteHook.pageId);
+                return pageContextFromOnBeforeRouteHook;
+            }
+            else {
+                (0, utils_js_1.objectAssign)(pageContextFromRoute, pageContextFromOnBeforeRouteHook);
+            }
         }
+        // We take into account pageContext.urlLogical set by onBeforeRoute()
+        (0, utils_js_1.objectAssign)(pageContext, pageContextFromOnBeforeRouteHook);
     }
-    // We take into account pageContext.urlLogical set by onBeforeRoute()
-    (0, utils_js_1.objectAssign)(pageContext, pageContextFromOnBeforeRouteHook);
     // Vike's routing
     const allPageIds = pageContext._allPageIds;
     (0, utils_js_1.assertUsage)(allPageIds.length > 0, 'No page found. You must create at least one page.');

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.227';
+exports.PROJECT_VERSION = '0.4.228-commit-1553dee';

package/dist/cjs/utils/assert.js

@@ -98,12 +98,9 @@ function assertWarning(condition, msg, { onlyOnce, showStackTrace }) {
     if (onlyOnce) {
         const { alreadyLogged } = globalObject;
         const key = onlyOnce === true ? msg : onlyOnce;
-        if (alreadyLogged.has(key)) {
+        if (alreadyLogged.has(key))
             return;
-        }
-        else {
-            alreadyLogged.add(key);
-        }
+        alreadyLogged.add(key);
     }
     globalObject.onBeforeLog?.();
     if (showStackTrace) {

package/dist/cjs/utils/findPackageJson.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findPackageJson = findPackageJson;
 const findFile_js_1 = require("./findFile.js");
 const module_1 = require("module");
-// @ts-ignore `file://${__filename}` is shimmed at dist/cjs by dist-cjs-fixup.js.
-const importMetaUrl = `file://${__filename}`;
+// @ts-ignore `file:///${__filename.split('\\').join('/')}` is shimmed at dist/cjs by dist-cjs-fixup.js.
+const importMetaUrl = `file:///${__filename.split('\\').join('/')}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 function findPackageJson(cwd) {
     const packageJsonPath = (0, findFile_js_1.findFile)('package.json', cwd);

package/dist/cjs/utils/isFilePathAbsoluteFilesystem.js

@@ -24,8 +24,8 @@ function assertFilePathAbsoluteFilesystem(filePath) {
     // - For Linux users assertFilePathAbsoluteFilesystem() will erroneously succeed if `p` is a path absolute from the user root dir.
     //   - But that's okay because the assertion will eventually fail for Windows users.
     //   - On Linux there doesn't seem to be a way to distinguish between an absolute path starting from the filesystem root or starting from the user root directory, see comment at isFilePathAbsoluteFilesystem()
-    (0, assert_js_1.assert)(isFilePathAbsoluteFilesystem(filePath));
     (0, path_js_1.assertPosixPath)(filePath);
+    (0, assert_js_1.assert)(isFilePathAbsoluteFilesystem(filePath));
 }
 /**
  * Whether `filePath` is an absolute file path starting from the filesystem root.

package/dist/cjs/utils/isNpmPackage.js

@@ -10,10 +10,10 @@ const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
 function isNpmPackageImport(str, { cannotBePathAlias }) {
-    // We cannot distinguish path alises that look like npm package imports
     (0, assert_js_1.assert)(cannotBePathAlias);
     return isNpmPackageImport_unreliable(str);
 }
+// We cannot distinguish path aliases that look like npm package imports
 function isNpmPackageImport_unreliable(str) {
     const res = parse(str);
     return res !== null;

package/dist/cjs/utils/isScriptFile.js

@@ -8,12 +8,12 @@ const assert_js_1 = require("./assert.js");
 // We can't use a RegExp:
 //  - Needs to work with Micromatch: https://github.com/micromatch/micromatch because:
 //    - Vite's `import.meta.glob()` uses Micromatch
-//  - We need this to be a whitelist because:
+//  - We need this to be a allowlist because:
 //   - A pattern `*([a-zA-Z0-9]` doesn't work.
 //     - Because of ReScript: `.res` are ReScript source files which need to be ignored. (The ReScript compiler generates `.js` files alongside `.res` files.)
-//   - Black listing doesn't work.
-//     - We cannot implement a blacklist with a glob pattern.
-//     - A post `import.meta.glob()` blacklist filtering doesn't work because Vite would still process the files (e.g. including them in the bundle).
+//   - Block listing doesn't work.
+//     - We cannot implement a blocklist with a glob pattern.
+//     - A post `import.meta.glob()` blocklist filtering doesn't work because Vite would still process the files (e.g. including them in the bundle).
 // prettier-ignore
 // biome-ignore format:
 const extJavaScript = [

package/dist/cjs/utils/parseUrl.js

@@ -186,14 +186,14 @@ function parseProtocol(uri) {
     return { protocol, uriWithoutProtocol };
 }
 function isUrlProtocol(protocol) {
-    // Is there an altenrative to having a blacklist?
-    // - If the blacklist becomes too big, maybe use a whitelist instead ['tauri://', 'file://', 'capacitor://', 'http://', 'https://']
-    const blacklist = [
+    // Is there an alternative to having a blocklist?
+    // - If the blocklist becomes too big, maybe use a allowlist instead ['tauri://', 'file://', 'capacitor://', 'http://', 'https://']
+    const blocklist = [
         // https://docs.ipfs.tech/how-to/address-ipfs-on-web
         'ipfs://',
         'ipns://'
     ];
-    if (blacklist.includes(protocol))
+    if (blocklist.includes(protocol))
         return false;
     return protocol.endsWith('://');
 }

package/dist/cjs/utils/preservePropertyGetters.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preservePropertyGetters = preservePropertyGetters;
+const assert_js_1 = require("./assert.js");
+function preservePropertyGetters(objOriginal) {
+    // Store original getter descriptors
+    const getters = Object.fromEntries(Object.entries(Object.getOwnPropertyDescriptors(objOriginal)).filter(([_, desc]) => 'get' in desc));
+    // Make getters non-enumerable
+    for (const [key, desc] of Object.entries(getters)) {
+        Object.defineProperty(objOriginal, key, { ...desc, enumerable: false });
+    }
+    const restorePropertyGetters = function () {
+        const objCopy = this;
+        delete objOriginal._restorePropertyGetters;
+        delete objCopy._restorePropertyGetters;
+        for (const [key, desc] of Object.entries(getters)) {
+            if (objCopy !== objOriginal) {
+                (0, assert_js_1.assert)(!(key in objCopy));
+                Object.defineProperty(objCopy, key, desc); // Add property getters to copy
+            }
+            (0, assert_js_1.assert)(key in objOriginal);
+            Object.defineProperty(objOriginal, key, desc); // Restore original `enumerable` value
+        }
+    };
+    Object.defineProperty(objOriginal, '_restorePropertyGetters', {
+        value: restorePropertyGetters,
+        enumerable: true,
+        configurable: true
+    });
+}

package/dist/cjs/utils/requireResolve.js

@@ -1,37 +1,81 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireResolve = requireResolve;
+exports.requireResolveOptional = requireResolveOptional;
+exports.requireResolveNonUserFile = requireResolveNonUserFile;
+exports.requireResolveOptionalNonUserFile = requireResolveOptionalNonUserFile;
 const assert_js_1 = require("./assert.js");
 const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
 const assertSetup_js_1 = require("./assertSetup.js");
 const path_js_1 = require("./path.js");
 const isScriptFile_js_1 = require("./isScriptFile.js");
-const module_1 = require("module");
-// @ts-ignore `file://${__filename}` is shimmed at dist/cjs by dist-cjs-fixup.js.
-const importMetaUrl = `file://${__filename}`;
-const require_ = (0, module_1.createRequire)(importMetaUrl);
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+// @ts-ignore `file:///${__filename.split('\\').join('/')}` is shimmed at dist/cjs by dist-cjs-fixup.js.
+const importMetaUrl = `file:///${__filename.split('\\').join('/')}`;
+const require_ = (0, node_module_1.createRequire)(importMetaUrl);
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
 (0, assertSetup_js_1.assertIsNotProductionRuntime)();
-// We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
-// - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
-function requireResolve(importPath, cwd) {
+function requireResolve_(importPath, cwd, options) {
     (0, path_js_1.assertPosixPath)(cwd);
-    const clean = addFileExtensionsToRequireResolve();
-    importPath = removeFileExtention(importPath);
+    (0, path_js_1.assertPosixPath)(importPath);
+    cwd = resolveCwd(cwd);
+    let clean = () => { };
+    if (!options?.doNotHandleFileExtension) {
+        clean = addFileExtensionsToRequireResolve();
+        importPath = removeFileExtention(importPath);
+    }
     let importedFile;
     try {
+        // We still can't use import.meta.resolve() as of 23.1.0 (November 2024) because `parent` argument requires an experimental flag.
+        // - https://stackoverflow.com/questions/54977743/do-require-resolve-for-es-modules#comment139581675_62272600
         importedFile = require_.resolve(importPath, { paths: [cwd] });
     }
-    catch {
-        importedFile = null;
-    }
-    finally {
+    catch (err) {
         clean();
+        return { importedFile: undefined, err, hasFailed: true };
     }
-    if (importedFile) {
-        importedFile = (0, path_js_1.toPosixPath)(importedFile);
+    clean();
+    importedFile = (0, path_js_1.toPosixPath)(importedFile);
+    return { importedFile, err: undefined, hasFailed: false };
+}
+function requireResolveOptional(importPath, cwd) {
+    const res = requireResolve_(importPath, cwd);
+    if (res.hasFailed)
+        return null;
+    return res.importedFile;
+}
+function requireResolveOptionalNonUserFile(importPath, cwd) {
+    const res = requireResolve_(importPath, cwd, { doNotHandleFileExtension: true });
+    if (res.hasFailed)
+        return null;
+    return res.importedFile;
+}
+function requireResolveNonUserFile(importPath, cwd) {
+    const res = requireResolve_(importPath, cwd, { doNotHandleFileExtension: true });
+    if (res.hasFailed)
+        throw res.err;
+    return res.importedFile;
+}
+function requireResolve(importPath, cwd) {
+    const res = requireResolve_(importPath, cwd);
+    if (res.hasFailed)
+        throw res.err;
+    return res.importedFile;
+}
+function resolveCwd(cwd) {
+    let prefix = 'file://';
+    if (process.platform === 'win32')
+        prefix += '/';
+    if (cwd.startsWith(prefix)) {
+        cwd = cwd.slice(prefix.length);
+        cwd = node_path_1.default.posix.dirname(cwd);
     }
-    return importedFile;
+    (0, assert_js_1.assert)(!cwd.startsWith('file:'));
+    return cwd;
 }
 function removeFileExtention(importPath) {
     // Skip for Bun: https://github.com/vikejs/vike/issues/2204

package/dist/cjs/{node/plugin/shared → utils}/rollupSourceMap.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sourceMapRemove = sourceMapRemove;
-exports.sourceMapPassthrough = sourceMapPassthrough;
+exports.rollupSourceMapRemove = rollupSourceMapRemove;
+exports.rollupSourceMapPassthrough = rollupSourceMapPassthrough;
 // https://rollupjs.org/guide/en/#source-code-transformations
 /** Remove entire source mapping, to save KBs. */
-function sourceMapRemove(code) {
+function rollupSourceMapRemove(code) {
     return {
         code,
         map: { mappings: '' }
     };
 }
 /** Don't provide any source map, pass through current source map instead. */
-function sourceMapPassthrough(code) {
+function rollupSourceMapPassthrough(code) {
     return {
         code,
         map: null

package/dist/esm/client/client-routing-runtime/initOnLinkClick.js

@@ -3,9 +3,9 @@ import { isSameAsCurrentUrl, skipLink } from './skipLink.js';
 import { renderPageClientSide } from './renderPageClientSide.js';
 import { scrollToHashOrTop } from './setScrollPosition.js';
 function initOnLinkClick() {
-    document.addEventListener('click', onClick);
+    document.addEventListener('click', onLinkClick);
 }
-async function onClick(ev) {
+async function onLinkClick(ev) {
     if (!isNormalLeftClick(ev))
         return;
     const linkTag = findLinkTag(ev.target);

package/dist/esm/node/api/dev.js

@@ -1,12 +1,14 @@
 export { dev };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { createServer } from 'vite';
+import { setGlobalContext_isProduction } from '../runtime/globalContext.js';
 /**
  * Programmatically trigger `$ vike dev`
  *
  * https://vike.dev/api#dev
  */
 async function dev(options = {}) {
+    setGlobalContext_isProduction(false);
     const { viteConfigFromUserEnhanced } = await prepareViteApiCall(options, 'dev');
     const server = await createServer(viteConfigFromUserEnhanced);
     return {

package/dist/esm/node/plugin/plugins/build/handleAssetsManifest.js

@@ -296,16 +296,21 @@ function handleAssetsManifest_getBuildConfig(config) {
     };
 }
 async function handleAssetsManifest(config, viteEnv, options, bundle) {
-    if (isViteServerBuild_onlySsrEnv(config, viteEnv)) {
+    const isSsREnv = isViteServerBuild_onlySsrEnv(config, viteEnv);
+    if (isSsREnv) {
         assert(!assetsJsonFilePath);
         const outDirs = getOutDirs(config, viteEnv);
         assetsJsonFilePath = path.posix.join(outDirs.outDirRoot, 'assets.json');
         await writeAssetsManifestFile(outDirs, assetsJsonFilePath, config);
     }
     if (isViteServerBuild(config, viteEnv)) {
-        assert(assetsJsonFilePath);
-        // Replace __VITE_ASSETS_MANIFEST__ in all server-side bundles
-        await set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath);
+        // Replace __VITE_ASSETS_MANIFEST__ in server builds
+        // - Always replace it in dist/server/
+        // - Also in some other server builds such as dist/vercel/ from vike-vercel
+        // - Don't replace it in dist/rsc/ from vike-react-rsc since __VITE_ASSETS_MANIFEST__ doesn't exist there
+        const noop = await set_macro_ASSETS_MANIFEST(options, bundle, assetsJsonFilePath);
+        if (isSsREnv)
+            assert(!noop); // dist/server should always contain __VITE_ASSETS_MANIFEST__
     }
 }
 async function writeAssetsManifestFile(outDirs, assetsJsonFilePath, config) {