vike 0.4.150 → 0.4.151-commit-19bc995

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUrlPathname = void 0;
+const assertIsNotBrowser_js_1 = require("../../utils/assertIsNotBrowser.js");
+const utils_js_1 = require("../utils.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)(); // Don't bloat the client
+/** Given a `routeString` and `routeParams`, resolve `urlPathname`.
+ *
+ * Basically, the correct implementation of following:
+ * ```js
+ * let urlPathname = routeString
+ * Object.entries(routeParams).forEach(([key, val]) => {
+ *   urlPathname = urlPathname.replaceAll(key, val)
+ * })
+ * ```
+ */
+function resolveUrlPathname(routeString, routeParams) {
+    let parts = [{ val: routeString, type: 'ROUTE_STRING' }];
+    Object.entries(routeParams).forEach(([key, val]) => {
+        if (key.startsWith('*')) {
+            (0, utils_js_1.assert)(key === '*' || /\d+/.test(key.slice(1)));
+            (0, utils_js_1.assertUsage)(key === '*', "Resolving URL with multiple globs isn't implemented yet");
+        }
+        else {
+            key = `@${key}`;
+        }
+        parts = parts
+            .map((part) => {
+            if (part.type === 'URL') {
+                return part;
+            }
+            else {
+                return part.val
+                    .split(key)
+                    .map((rest, i) => {
+                    const partURL = { val, type: 'URL' };
+                    const partRouteString = { val: rest, type: 'ROUTE_STRING' };
+                    return i === 0 ? [partRouteString] : [partURL, partRouteString];
+                })
+                    .flat();
+            }
+        })
+            .flat();
+    });
+    const urlPathname = parts.map((p) => p.val).join('');
+    return urlPathname;
+}
+exports.resolveUrlPathname = resolveUrlPathname;

package/dist/cjs/utils/debug.js

@@ -10,33 +10,47 @@ const getTerminWidth_js_1 = require("./getTerminWidth.js");
 // Avoid this to be loaded in the browser. For isomorphic code: instead of `import { createDebugger } from './utils.js'`, use `globalThis.createDebugger()`.
 (0, assert_js_1.assert)(!(0, isBrowser_js_1.isBrowser)());
 globalThis.__brillout_debug_createDebugger = createDebugger;
-function createDebugger(namespace, optionsGlobal) {
-    (0, checkType_js_1.checkType)(namespace);
-    const debugWithOptions = (options) => {
+function createDebugger(flag, optionsGlobal) {
+    (0, checkType_js_1.checkType)(flag);
+    const debugWithOptions = (optionsLocal) => {
         return (...msgs) => {
-            if (!isDebugEnabled(namespace))
-                return;
-            let [msgFirst, ...msgsRest] = msgs;
-            const padding = ' '.repeat(namespace.length + 1);
-            const optionsResolved = { ...optionsGlobal, ...options };
-            msgFirst = formatMsg(msgFirst, optionsResolved, padding, 'FIRST');
-            msgsRest = msgsRest.map((msg, i) => {
-                const position = i === msgsRest.length - 1 ? 'LAST' : 'MIDDLE';
-                return formatMsg(msg, optionsResolved, padding, position);
-            });
-            console.log('\x1b[1m%s\x1b[0m', namespace, msgFirst);
-            msgsRest.forEach((msg) => {
-                console.log(msg);
-            });
+            const options = { ...optionsGlobal, ...optionsLocal };
+            debug_(flag, options, ...msgs);
         };
     };
     const debug = (...msgs) => debugWithOptions({})(...msgs);
-    (0, objectAssign_js_1.objectAssign)(debug, { options: debugWithOptions, isEnabled: isDebugEnabled(namespace) });
+    (0, objectAssign_js_1.objectAssign)(debug, { options: debugWithOptions, isEnabled: isDebugEnabled(flag) });
     return debug;
 }
 exports.createDebugger = createDebugger;
-function isDebugEnabled(namespace) {
-    (0, checkType_js_1.checkType)(namespace);
+function debug_(flag, options, ...msgs) {
+    if (!isDebugEnabled(flag))
+        return;
+    let [msgFirst, ...msgsRest] = msgs;
+    const padding = ' '.repeat(flag.length + 1);
+    msgFirst = formatMsg(msgFirst, options, padding, 'FIRST');
+    msgsRest = msgsRest.map((msg, i) => {
+        const position = i === msgsRest.length - 1 ? 'LAST' : 'MIDDLE';
+        return formatMsg(msg, options, padding, position);
+    });
+    let logFirst;
+    let logsRest;
+    const noNewLine = msgsRest.length <= 1 && [msgFirst, ...msgsRest].every((m) => typeof m === 'string' && !m.includes('\n'));
+    if (noNewLine) {
+        logFirst = [msgFirst, ...msgsRest].map((m) => String(m).trim());
+        logsRest = [];
+    }
+    else {
+        logFirst = [msgFirst];
+        logsRest = msgsRest;
+    }
+    console.log('\x1b[1m%s\x1b[0m', flag, ...logFirst);
+    logsRest.forEach((msg) => {
+        console.log(msg);
+    });
+}
+function isDebugEnabled(flag) {
+    (0, checkType_js_1.checkType)(flag);
     let DEBUG;
     // - `process` can be undefined in edge workers
     // - We want bundlers to be able to statically replace `process.env.*`
@@ -44,7 +58,7 @@ function isDebugEnabled(namespace) {
         DEBUG = process.env.DEBUG;
     }
     catch { }
-    return DEBUG?.includes(namespace) ?? false;
+    return DEBUG?.includes(flag) ?? false;
 }
 exports.isDebugEnabled = isDebugEnabled;
 function formatMsg(info, options, padding, position) {

package/dist/cjs/utils/getDependencyPackageJson.js

@@ -17,7 +17,7 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntime.js");
 const module_1 = require("module");
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 (0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();

package/dist/cjs/utils/getFilePathAbsolute.js

@@ -11,7 +11,7 @@ const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntim
 const isNpmPackage_js_1 = require("./isNpmPackage.js");
 const assertPathIsFilesystemAbsolute_js_1 = require("./assertPathIsFilesystemAbsolute.js");
 const module_1 = require("module");
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 (0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();

package/dist/cjs/utils/getOutDirs.js

@@ -9,7 +9,10 @@ const assert_js_1 = require("./assert.js");
 const path_shim_js_1 = require("./path-shim.js");
 const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const debug_js_1 = require("./debug.js");
+const debug = (0, debug_js_1.createDebugger)('vike:outDir');
 function getOutDirs(config) {
+    debug('getOutDirs()', new Error().stack);
     let outDirRoot;
     {
         const outDir = getOutDirFromViteResolvedConfig(config);
@@ -23,12 +26,17 @@ function getOutDirs(config) {
             outDirRoot = outDir.slice(0, -1 * '/client'.length);
         }
     }
-    return getOutDirsAll(outDirRoot, config.root);
+    const outDirs = getOutDirsAll(outDirRoot, config.root);
+    debug('outDirRoot', outDirRoot);
+    debug('outDirs', outDirs);
+    return outDirs;
 }
 exports.getOutDirs = getOutDirs;
 /** Appends `client/` or `server/` to `config.build.outDir` */
 function resolveOutDir(config) {
+    debug('resolveOutDir()', new Error().stack);
     const outDir = getOutDirFromViteUserConfig(config) || 'dist';
+    debug('outDir', 'outDir');
     // outDir may already be resolved when using Telefunc + vike (because both Telefunc and vike use this logic)
     if (!isOutDirRoot(outDir)) {
         assertOutDirResolved(outDir, config);
@@ -37,9 +45,11 @@ function resolveOutDir(config) {
     else {
         const { outDirClient, outDirServer } = determineOutDirs(outDir);
         if ((0, viteIsSSR_js_1.viteIsSSR)(config)) {
+            debug('outDirServer', 'outDirServer');
             return outDirServer;
         }
         else {
+            debug('outDirClient', 'outDirClient');
             return outDirClient;
         }
     }

package/dist/cjs/utils/injectRollupInputs.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRollupInput = exports.injectRollupInputs = void 0;
+const assert_js_1 = require("./assert.js");
+const isObject_js_1 = require("./isObject.js");
+function injectRollupInputs(inputsNew, config) {
+    const inputsCurrent = normalizeRollupInput(config.build.rollupOptions.input);
+    const input = {
+        ...inputsNew,
+        ...inputsCurrent
+    };
+    return input;
+}
+exports.injectRollupInputs = injectRollupInputs;
+function normalizeRollupInput(input) {
+    if (!input) {
+        return {};
+    }
+    // Usually `input` is an oject, but the user can set it as a `string` or `string[]`
+    if (typeof input === 'string') {
+        input = [input];
+    }
+    if (Array.isArray(input)) {
+        return Object.fromEntries(input.map((input) => [input, input]));
+    }
+    (0, assert_js_1.assert)((0, isObject_js_1.isObject)(input));
+    return input;
+}
+exports.normalizeRollupInput = normalizeRollupInput;

package/dist/cjs/utils/isPlainObject.js

@@ -10,7 +10,7 @@ function isPlainObject(value) {
         return true;
     }
     return (
-    /* Doesn't work in Cloudlfare Pages workers
+    /* Doesn't work in Cloudflare Pages workers
     value.constructor === Object
     */
     value.constructor.name === 'Object');

package/dist/cjs/utils/projectInfo.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = exports.projectInfo = void 0;
 const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
-const PROJECT_VERSION = '0.4.150';
+const PROJECT_VERSION = '0.4.151-commit-19bc995';
 exports.PROJECT_VERSION = PROJECT_VERSION;
 const projectInfo = {
     projectName: 'Vike',

package/dist/cjs/utils/requireResolve.js

@@ -7,7 +7,7 @@ const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntim
 const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
 const isScriptFile_js_1 = require("./isScriptFile.js");
 const module_1 = require("module");
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)();

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

@@ -25,10 +25,10 @@ async function getPageContextFromHooks_firstRender(pageContext) {
         _hasPageContextFromClient: false
     });
     objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContextFromHooks._pageId, pageContext));
-    {
+    for (const hookName of ['data', 'onBeforeRender']) {
         const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
-        if (onBeforeRenderClientOnlyExists(pageContextForHook)) {
-            const pageContextFromHook = await executeOnBeforeRenderHookClientSide(pageContextForHook);
+        if (hookClientOnlyExists(hookName, pageContextForHook)) {
+            const pageContextFromHook = await executeHookClientSide(hookName, pageContextForHook);
             objectAssign(pageContextFromHooks, pageContextFromHook);
         }
     }
@@ -56,31 +56,34 @@ async function getPageContextFromHooks_uponNavigation(pageContext) {
     return pageContextFromHooks;
 }
 async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
-    let pageContextFromHooks = {};
-    objectAssign(pageContextFromHooks, { _hasPageContextFromClient: false });
-    objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContext._pageId, pageContext));
-    let pageContextFetchedFromServer = false;
-    // Needs to be called before any client-side hook, because it may contain pageContextInit.user which is needed for guard() and onBeforeRender()
+    const getPageContextFromHooksInit = async (pageId) => {
+        const pageContextFromHooks = {
+            _hasPageContextFromClient: false,
+            _pageId: pageId
+        };
+        const pageContextFromPageFiles = await loadPageFilesClientSide(pageId, pageContext);
+        objectAssign(pageContextFromHooks, pageContextFromPageFiles);
+        return pageContextFromHooks;
+    };
+    let pageContextFromHooks = await getPageContextFromHooksInit(pageContext._pageId);
+    let hasPageContextFromServer = false;
+    // If pageContextInit has some client data or if one of the hooks guard(), data() or onBeforeRender() is server-side
+    // only, then we need to fetch pageContext from the server.
+    // We do it before executing any client-side hook, because it contains pageContextInit which may be needed for guard() / data() / onBeforeRender(), for example pageContextInit.user is crucial for guard()
     if (
     // For the error page, we cannot fetch pageContext from the server because the pageContext JSON request is based on the URL
     !isErrorPage &&
-        // true if pageContextInit has some client data or the onBeforeRender hook is server-side only:
+        // true if pageContextInit has some client data or at least one of the data() and onBeforeRender() hooks is server-side only:
         (await hasPageContextServer({ ...pageContext, ...pageContextFromHooks }))) {
         const pageContextFromServer = await fetchPageContextFromServer(pageContext);
-        pageContextFetchedFromServer = true;
+        hasPageContextFromServer = true;
         if (!pageContextFromServer['_isError']) {
             objectAssign(pageContextFromHooks, pageContextFromServer);
         }
         else {
             const errorPageId = getErrorPageId(pageContext._pageFilesAll, pageContext._pageConfigs);
             assert(errorPageId);
-            pageContextFromHooks = {};
-            objectAssign(pageContextFromHooks, {
-                _hasPageContextFromClient: false,
-                isHydration: false,
-                _pageId: errorPageId
-            });
-            objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContextFromHooks._pageId, pageContext));
+            pageContextFromHooks = await getPageContextFromHooksInit(errorPageId);
             assert(hasProp(pageContextFromServer, 'is404', 'boolean'));
             assert(hasProp(pageContextFromServer, 'pageProps', 'object'));
             assert(hasProp(pageContextFromServer.pageProps, 'is404', 'boolean'));
@@ -89,54 +92,73 @@ async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
             objectAssign(pageContextFromHooks, pageContextFromServer);
         }
     }
-    else {
-        objectAssign(pageContextFromHooks, { _hasPageContextFromServer: false });
-        // We don't need to call guard() on the client-side if we fetch pageContext from the server side. (Because the `${url}.pageContext.json` HTTP request will already trigger the routing and guard() hook on the serve-side.)
-        // We cannot call guard() before retrieving pageContext from server, since the server-side may define pageContextInit.user which is paramount for guard() hooks
-        if (!isErrorPage) {
-            // Should we really call the guard() hook on the client-side? Shouldn't we make the guard() hook a server-side only hook? Or maybe make its env configurable like onBeforeRender()?
-            await executeGuardHook({
-                ...pageContext,
-                ...pageContextFromHooks
-            }, (pageContext) => preparePageContextForUserConsumptionClientSide(pageContext, true));
-        }
-    }
-    // For the error page, we also execute the client-side onBeforeRender() hook, but maybe we shouldn't? The server-side does it as well (but maybe it shouldn't).
-    {
-        const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
-        if (onBeforeRenderClientOnlyExists(pageContextForHook) || !pageContextFetchedFromServer) {
-            // This won't do anything if no hook has been defined or if the hook's env.client is false.
-            const pageContextFromHook = await executeOnBeforeRenderHookClientSide(pageContextForHook);
-            objectAssign(pageContextFromHooks, pageContextFromHook);
+    // At this point, we need to call the client-side guard(), data() and onBeforeRender() hooks, if they exist on client
+    // env. However if we have fetched pageContext from the server, some of them might have run already on the
+    // server-side, so we run only the client-only ones in this case.
+    // Note: for the error page, we also execute the client-side data() and onBeforeRender() hooks, but maybe we
+    // shouldn't? The server-side does it as well (but maybe it shouldn't).
+    for (const hookName of ['guard', 'data', 'onBeforeRender']) {
+        const pageContextForHook = {
+            _hasPageContextFromServer: hasPageContextFromServer,
+            ...pageContext,
+            ...pageContextFromHooks
+        };
+        if (hookName === 'guard') {
+            if (!isErrorPage &&
+                // We don't need to call guard() on the client-side if we fetch pageContext from the server side. (Because the `${url}.pageContext.json` HTTP request will already trigger the routing and guard() hook on the server-side.)
+                !hasPageContextFromServer) {
+                // Should we really call the guard() hook on the client-side? Shouldn't we make the guard() hook a server-side
+                // only hook? Or maybe make its env configurable like data() and onBeforeRender()?
+                await executeGuardHook(pageContextForHook, (pageContext) => preparePageContextForUserConsumptionClientSide(pageContext, true));
+            }
         }
         else {
-            assert(pageContextFetchedFromServer);
+            assert(hookName === 'data' || hookName === 'onBeforeRender');
+            if (hookClientOnlyExists(hookName, pageContextForHook) || !hasPageContextFromServer) {
+                // This won't do anything if no hook has been defined or if the hook's env.client is false.
+                const pageContextFromHook = await executeHookClientSide(hookName, pageContextForHook);
+                objectAssign(pageContextFromHooks, pageContextFromHook);
+            }
+            else {
+                assert(hasPageContextFromServer);
+            }
         }
     }
+    objectAssign(pageContextFromHooks, {
+        _hasPageContextFromServer: hasPageContextFromServer
+    });
     return pageContextFromHooks;
 }
-async function executeOnBeforeRenderHookClientSide(pageContext) {
-    const hook = getHook(pageContext, 'onBeforeRender');
+async function executeHookClientSide(hookName, pageContext) {
+    const hook = getHook(pageContext, hookName);
     if (!hook) {
         // No hook defined or hook's env.client is false
-        const pageContextFromOnBeforeRender = {
-            _hasPageContextFromClient: false
+        return null;
+    }
+    const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide(pageContext, true);
+    const hookResult = await executeHook(() => hook.hookFn(pageContextForUserConsumption), hook);
+    const pageContextFromHook = {};
+    if (hookName === 'onBeforeRender') {
+        assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
+        // Note: hookResult looks like { pageContext: { ... } }
+        const pageContextFromOnBeforeRender = hookResult?.pageContext;
+        if (pageContextFromOnBeforeRender) {
+            objectAssign(pageContextFromHook, { _hasPageContextFromClient: true });
+            objectAssign(pageContextFromHook, pageContextFromOnBeforeRender);
+        }
+    }
+    else {
+        assert(hookName === 'data');
+        // Note: hookResult can be anything (e.g. an object) and is to be assigned to pageContext.data
+        const pageContextFromData = {
+            data: hookResult
         };
-        return pageContextFromOnBeforeRender;
+        if (hookResult) {
+            objectAssign(pageContextFromHook, { _hasPageContextFromClient: true });
+        }
+        objectAssign(pageContextFromHook, pageContextFromData);
     }
-    const onBeforeRender = hook.hookFn;
-    const pageContextFromOnBeforeRender = {
-        _hasPageContextFromClient: true
-    };
-    const pageContextForUserConsumption = preparePageContextForUserConsumptionClientSide({
-        ...pageContext,
-        ...pageContextFromOnBeforeRender
-    }, true);
-    const hookResult = await executeHook(() => onBeforeRender(pageContextForUserConsumption), hook);
-    assertOnBeforeRenderHookReturn(hookResult, hook.hookFilePath);
-    const pageContextFromHook = hookResult?.pageContext;
-    objectAssign(pageContextFromOnBeforeRender, pageContextFromHook);
-    return pageContextFromOnBeforeRender;
+    return pageContextFromHook;
 }
 // Workaround for the fact that the client-side cannot known whether a pageContext JSON request is needed in order to fetch pageContextInit data passed to the client.
 //  - The workaround is reliable as long as the user sets additional pageContextInit to undefined instead of not defining the property:
@@ -155,35 +177,53 @@ function setPageContextInitHasClientData(pageContext) {
         globalObject.pageContextInitHasClientData = true;
     }
 }
+// TODO/v1-release: make it sync
 async function hasPageContextServer(pageContext) {
-    return !!globalObject.pageContextInitHasClientData || (await onBeforeRenderServerOnlyExists(pageContext));
+    return (!!globalObject.pageContextInitHasClientData ||
+        (await hookServerOnlyExists('data', pageContext)) ||
+        (await hookServerOnlyExists('onBeforeRender', pageContext)));
 }
-async function onBeforeRenderServerOnlyExists(pageContext) {
+// TODO/v1-release: make it sync
+/**
+ * @param hookName
+ * @param pageContext
+ * @returns `true` if the given page has a `hookName` hook defined with a server-only env.
+ */
+async function hookServerOnlyExists(hookName, pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
         const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
-        const onBeforeRenderEnv = getConfigValue(pageConfig, 'onBeforeRenderEnv')?.value ?? {};
-        assert(isObject(onBeforeRenderEnv));
-        return !!onBeforeRenderEnv.server && !onBeforeRenderEnv.client;
+        const hookEnv = getConfigValue(pageConfig, `${hookName}Env`)?.value ?? {};
+        assert(isObject(hookEnv));
+        return !!hookEnv.server && !hookEnv.client;
     }
     else {
         // TODO/v1-release: remove
         // V0.4
+        // data() hooks didn't exist in the V0.4 design
+        if (hookName === 'data')
+            return false;
+        assert(hookName === 'onBeforeRender');
         const { hasOnBeforeRenderServerSideOnlyHook } = await analyzePageServerSide(pageContext._pageFilesAll, pageContext._pageId);
         return hasOnBeforeRenderServerSideOnlyHook;
     }
 }
-function onBeforeRenderClientOnlyExists(pageContext) {
+/**
+ * @param hookName
+ * @param pageContext
+ * @returns `true` if the given page has a `hookName` hook defined with a client-only env.
+ */
+function hookClientOnlyExists(hookName, pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
         const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
-        const onBeforeRenderEnv = getConfigValue(pageConfig, 'onBeforeRenderEnv')?.value ?? {};
-        assert(isObject(onBeforeRenderEnv));
-        return !!onBeforeRenderEnv.client && !onBeforeRenderEnv.server;
+        const hookEnv = getConfigValue(pageConfig, `${hookName}Env`)?.value ?? {};
+        assert(isObject(hookEnv));
+        return !!hookEnv.client && !hookEnv.server;
     }
     else {
         // TODO/v1-release: remove
-        // Client-only onBeforeRender() hooks were never supported for the V0.4 design
+        // Client-only onBeforeRender() or data() hooks were never supported for the V0.4 design
         return false;
     }
 }
@@ -212,7 +252,6 @@ async function fetchPageContextFromServer(pageContext) {
     }
     assert(hasProp(pageContextFromServer, '_pageId', 'string'));
     removeBuiltInOverrides(pageContextFromServer);
-    objectAssign(pageContextFromServer, { _hasPageContextFromServer: true });
     return pageContextFromServer;
 }
 function isAlreadyServerSideRouted(err) {

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

@@ -133,7 +133,7 @@ async function renderPageClientSide(renderArgs) {
             console.error(err);
         }
         else {
-            // We swallow throw redirect()/render() called by client-side hooks onBeforeRender() and guard()
+            // We swallow throw redirect()/render() called by client-side hooks onBeforeRender(), data() and guard()
             // We handle the abort error down below.
         }
         if (shouldSwallowAndInterrupt(err, pageContext, isFirstRender))

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

@@ -8,7 +8,6 @@ import { buildConfig } from './plugins/buildConfig.js';
 import { previewConfig } from './plugins/previewConfig.js';
 import { autoFullBuild } from './plugins/autoFullBuild.js';
 import { devConfig } from './plugins/devConfig/index.js';
-import { manifest } from './plugins/manifest.js';
 import { packageJsonFile } from './plugins/packageJsonFile.js';
 import { removeRequireHookPlugin } from './plugins/removeRequireHookPlugin.js';
 import { importUserCode } from './plugins/importUserCode/index.js';
@@ -24,18 +23,18 @@ import { extensionsAssets } from './plugins/extensionsAssets.js';
 import { baseUrls } from './plugins/baseUrls.js';
 import { envVarsPlugin } from './plugins/envVars.js';
 import pc from '@brillout/picocolors';
+import { assertFileEnv } from './plugins/assertFileEnv.js';
 markEnvAsVite();
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeConfig) {
     const plugins = [
-        resolveVikeConfig(vikeConfig),
+        resolveVikeConfig(vikeConfig), // The configResolved() hook of resolveVikeConfig() should be the first called
         ...commonConfig(),
         importUserCode(),
         ...devConfig(),
         buildConfig(),
         previewConfig(),
         ...autoFullBuild(),
-        ...manifest(),
         packageJsonFile(),
         removeRequireHookPlugin(),
         distFileNames(),
@@ -46,7 +45,8 @@ function plugin(vikeConfig) {
         ...importBuild(),
         extensionsAssets(),
         baseUrls(vikeConfig),
-        envVarsPlugin()
+        envVarsPlugin(),
+        assertFileEnv()
     ];
     return plugins;
 }

package/dist/esm/node/plugin/plugins/assertFileEnv.d.ts

@@ -0,0 +1,3 @@
+export { assertFileEnv };
+import type { Plugin } from 'vite';
+declare function assertFileEnv(): Plugin;