vike 0.4.150-commit-d9acc70 → 0.4.150-commit-d0822a3

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';
@@ -35,7 +34,6 @@ function plugin(vikeConfig) {
         buildConfig(),
         previewConfig(),
         ...autoFullBuild(),
-        ...manifest(),
         packageJsonFile(),
         removeRequireHookPlugin(),
         distFileNames(),

package/dist/esm/node/plugin/plugins/autoFullBuild.js

@@ -57,9 +57,10 @@ async function triggerFullBuild(config, configVike, bundle) {
         return; // already triggered
     if (isDisabled(configVike))
         return;
+    /* Is this @vitejs/plugin-legacy workaround still needed? Should we re-implement it?
     // vike.json missing => it isn't a `$ vite build` call (e.g. @vitejs/plugin-legacy calls Vite's build() API) => skip
-    if (!bundle['vike.json'])
-        return;
+    if (!bundle['vike.json']) return
+    */
     const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
     const configInline = {
         ...configFromCli,

package/dist/esm/node/plugin/plugins/buildConfig.js

@@ -1,8 +1,7 @@
 export { buildConfig };
 export { assertRollupInput };
 export { analyzeClientEntries };
-import { assert, resolveOutDir, isObject, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage } from '../utils.js';
-import { virtualFileIdImportUserCodeServer } from '../../shared/virtual-files/virtualFileImportUserCode.js';
+import { assert, resolveOutDir, viteIsSSR, getFilePathAbsolute, addOnBeforeLogHook, removeFileExtention, unique, assertPosixPath, assertUsage, injectRollupInputs, normalizeRollupInput } from '../utils.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 import { getConfigValue } from '../../../shared/page-configs/helpers.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
@@ -13,7 +12,7 @@ import { createRequire } from 'module';
 import { getClientEntryFilePath } from '../../shared/getClientEntryFilePath.js';
 import fs from 'fs/promises';
 import path from 'path';
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 const manifestTempFile = '_temp_manifest.json';
@@ -27,14 +26,9 @@ function buildConfig() {
             order: 'post',
             async handler(config) {
                 assertRollupInput(config);
-                const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
                 const entries = await getEntries(config);
                 assert(Object.keys(entries).length > 0);
-                const input = {
-                    ...entries,
-                    ...userInputs
-                };
-                config.build.rollupOptions.input = input;
+                config.build.rollupOptions.input = injectRollupInputs(entries, config);
                 addLogHook();
             }
         },
@@ -72,12 +66,12 @@ async function getEntries(config) {
     const { pageConfigs } = await getVikeConfig(config, false);
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
     if (viteIsSSR(config)) {
-        const serverEntries = analyzeServerEntries(pageConfigs);
+        const pageEntries = getPageEntries(pageConfigs);
         const entries = {
-            pageFiles: virtualFileIdImportUserCodeServer,
-            importBuild: resolve('dist/esm/node/importBuild.js'),
+            // importBuild: resolve('dist/esm/node/importBuild.js'), // TODO/next-major-release: remove
             ...pageFileEntries,
-            ...serverEntries
+            // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
+            ...pageEntries
         };
         return entries;
     }
@@ -102,6 +96,14 @@ async function getEntries(config) {
         return entries;
     }
 }
+function getPageEntries(pageConfigs) {
+    const pageEntries = {};
+    pageConfigs.forEach((pageConfig) => {
+        const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, false);
+        pageEntries[entryName] = entryTarget;
+    });
+    return pageEntries;
+}
 function analyzeClientEntries(pageConfigs, config) {
     let hasClientRouting = false;
     let hasServerRouting = false;
@@ -116,6 +118,7 @@ function analyzeClientEntries(pageConfigs, config) {
             hasServerRouting = true;
         }
         {
+            // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
             const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, true);
             clientEntries[entryName] = entryTarget;
         }
@@ -133,14 +136,6 @@ function analyzeClientEntries(pageConfigs, config) {
     });
     return { hasClientRouting, hasServerRouting, clientEntries };
 }
-function analyzeServerEntries(pageConfigs) {
-    const serverEntries = {};
-    pageConfigs.forEach((pageConfig) => {
-        const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, false);
-        serverEntries[entryName] = entryTarget;
-    });
-    return serverEntries;
-}
 // Ensure Rollup creates entries for each page file, see https://github.com/vikejs/vike/issues/350
 // (Otherwise the page files may be missing in the client manifest.json)
 async function getPageFileEntries(config, includeAssetsImportedByServer) {
@@ -196,20 +191,6 @@ function resolve(filePath) {
     // [RELATIVE_PATH_FROM_DIST] Current directory: node_modules/vike/dist/esm/node/plugin/plugins/
     return require_.resolve(`../../../../../${filePath}`);
 }
-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]));
-    }
-    assert(isObject(input));
-    return input;
-}
 function addLogHook() {
     const tty = process.stdout.isTTY && !process.env.CI; // Equals https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts#L27
     if (!tty)
@@ -241,5 +222,5 @@ function assertRollupInput(config) {
     const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
     const htmlInputs = Object.values(userInputs).filter((entry) => entry.endsWith('.html') || entry.endsWith('.htm'));
     const htmlInput = htmlInputs[0];
-    assertUsage(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using vike, instead follow https://vike.dev/add`);
+    assertUsage(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using Vike, instead follow https://vike.dev/add`);
 }

package/dist/esm/node/plugin/plugins/commonConfig.js

@@ -6,7 +6,7 @@ import pc from '@brillout/picocolors';
 import path from 'path';
 import { createRequire } from 'module';
 import { assertResolveAlias } from './commonConfig/assertResolveAlias.js';
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 function commonConfig() {

package/dist/esm/node/plugin/plugins/config/resolveExtensions.js

@@ -5,7 +5,7 @@ import fs from 'fs';
 import { isValidFileType } from '../../../../shared/getPageFiles/fileTypes.js';
 import { createRequire } from 'module';
 import pc from '@brillout/picocolors';
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 function resolveExtensions(configs, config) {

package/dist/esm/node/plugin/plugins/config/stemUtils.js

@@ -4,7 +4,7 @@ import path from 'path';
 import { assert, assertUsage, assertWarning, toPosixPath, assertPosixPath, getDependencyRootDir, findUserPackageJsonPath } from '../../utils.js';
 import { import_ } from '@brillout/import';
 import { createRequire } from '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 = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 async function getStemPackages(userAppRootDir) {

package/dist/esm/node/plugin/plugins/devConfig/determineFsAllowList.js

@@ -6,7 +6,7 @@ import { assert } from '../../utils.js';
 import { createRequire } from 'module';
 import { dirname } from 'path';
 import { fileURLToPath } from 'url';
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 const __dirname_ = dirname(fileURLToPath(importMetaUrl));

package/dist/esm/node/plugin/plugins/importBuild/getVikeManifest.d.ts

@@ -0,0 +1,5 @@
+export { getVikeManifest };
+import { ResolvedConfig } from 'vite';
+import { type PluginManifest } from '../../../shared/assertPluginManifest.js';
+import type { ConfigVikeResolved } from '../../../../shared/ConfigVike.js';
+declare function getVikeManifest(config: ResolvedConfig, configVike: ConfigVikeResolved): PluginManifest;

package/dist/esm/node/plugin/plugins/importBuild/getVikeManifest.js

@@ -0,0 +1,32 @@
+export { getVikeManifest };
+import { projectInfo, toPosixPath, assertPosixPath, isNotNullish } from '../../utils.js';
+import { assertPluginManifest } from '../../../shared/assertPluginManifest.js';
+import { isUsingClientRouter } from '../extractExportNamesPlugin.js';
+import path from 'path';
+import { getRuntimeManifest } from '../../../runtime/globalContext.js';
+function getVikeManifest(config, configVike) {
+    const runtimeManifest = getRuntimeManifest(configVike);
+    const manifest = {
+        version: projectInfo.projectVersion,
+        usesClientRouter: isUsingClientRouter(),
+        manifestKeyMap: getManifestKeyMap(configVike, config),
+        ...runtimeManifest
+    };
+    assertPluginManifest(manifest);
+    return manifest;
+}
+function getManifestKeyMap(configVike, config) {
+    const manifestKeyMap = {};
+    configVike.extensions
+        .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
+        .flat()
+        .filter(isNotNullish)
+        .forEach(({ importPath, filePath }) => {
+        // Recreating https://github.com/vitejs/vite/blob/8158ece72b66307e7b607b98496891610ca70ea2/packages/vite/src/node/plugins/manifest.ts#L38
+        const filePathRelative = path.posix.relative(config.root, toPosixPath(filePath));
+        assertPosixPath(filePathRelative);
+        assertPosixPath(importPath);
+        manifestKeyMap[importPath] = filePathRelative;
+    });
+    return manifestKeyMap;
+}

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

@@ -1,54 +1,86 @@
 export { importBuild };
-import { importBuild as importBuild_ } from '@brillout/vite-plugin-import-build/plugin.js';
-import { getOutDirs, projectInfo, toPosixPath } from '../../utils.js';
+import { importBuild as importBuild_, findImportBuildBundleEntry } from '@brillout/vite-plugin-import-build/plugin.js';
+import { assert, getOutDirs, projectInfo, toPosixPath, viteIsSSR } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+import { getConfigVike } from '../../../shared/getConfigVike.js';
+import { getVikeManifest } from './getVikeManifest.js';
+import fs from 'fs/promises';
+import { virtualFileIdImportUserCodeServer } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
+const ASSETS_MAP = '__VITE_ASSETS_MAP__';
 function importBuild() {
     let config;
+    let configVike;
     return [
         {
             name: 'vike:importBuild:config',
             enforce: 'post',
-            configResolved(config_) {
+            async configResolved(config_) {
                 config = config_;
+                configVike = await getConfigVike(config);
+            },
+            async writeBundle(options, bundle) {
+                if (!viteIsSSR(config))
+                    return;
+                await replace_ASSETS_MAP(options, bundle);
             }
         },
         importBuild_({
-            getImporterCode: ({ findBuildEntry }) => {
-                const pageFilesEntry = findBuildEntry('pageFiles');
-                return getImporterCode(config, pageFilesEntry);
+            getImporterCode: () => {
+                return getEntryCode(config, configVike);
             },
             libraryName: projectInfo.projectName
         })
     ];
 }
-function getImporterCode(config, pageFilesEntry) {
+function getEntryCode(config, configVike) {
     const importPath = getImportPath(config);
-    // The only reason we went for using CJS require() instead of ESM import() is because import() doesn't support .json files
+    const vikeManifest = getVikeManifest(config, configVike);
     const importerCode = [
-        '(async () => {',
-        `  const { setImportBuildGetters } = await import('${importPath}');`,
+        `  import { setImportBuildGetters } from '${importPath}';`,
+        `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,
         '  setImportBuildGetters({',
-        `    pageFiles: () => import('./${pageFilesEntry}'),`,
+        `    pageFiles: () => pageFiles,`,
         // TODO: rename clientManifest -> assetManifest
-        // TODO: rename PluginManifest -> vikeManifest
-        // TODO: use virtual file instead of generating vike.json
-        "    clientManifest: () => require('../assets.json'),",
-        "    pluginManifest: () => require('../client/vike.json'),",
+        `    clientManifest: () => { return ${ASSETS_MAP} },`,
+        // TODO: rename pluginManifest -> vikeManifest
+        `    pluginManifest: () => (${JSON.stringify(vikeManifest, null, 2)}),`,
         '  });',
-        '})()',
         ''
     ].join('\n');
     return importerCode;
 }
+async function replace_ASSETS_MAP(options, bundle) {
+    const { dir } = options;
+    assert(dir);
+    // I guess importBuild won't be found in the bundle when using @vitejs/plugin-legacy
+    const importBuildEntry = findImportBuildBundleEntry(bundle);
+    const importBuildFilePath = path.join(dir, importBuildEntry.fileName);
+    const assetsJsonFilePath = path.join(dir, '..', 'assets.json');
+    const [assetsJsonString, importBuildFileContent] = await Promise.all([
+        await fs.readFile(assetsJsonFilePath, 'utf8'),
+        await fs.readFile(importBuildFilePath, 'utf8')
+    ]);
+    const importBuildFileContentFixed = importBuildFileContent.replace(ASSETS_MAP, assetsJsonString);
+    assert(importBuildFileContentFixed !== importBuildFileContent);
+    await fs.writeFile(importBuildFilePath, importBuildFileContentFixed);
+}
 function getImportPath(config) {
+    // We resolve filePathAbsolute even if we don't use it: we use require.resolve() as an assertion that the relative path is correct
     const filePathAbsolute = toPosixPath(
     // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
     require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
-    const { outDirServer } = getOutDirs(config);
-    const filePathRelative = path.posix.relative(outDirServer, filePathAbsolute);
-    return filePathRelative;
+    if (
+    // Let's implement a new config if a user needs the import to be a relative path instead of 'vike/__internal/loadImportBuild' (AFAIK a relative path is needed only if a framework has npm package 'vike' as direct dependency instead of a peer dependency and if the user of that framework uses pnpm)
+    true) {
+        return 'vike/__internal/loadImportBuild';
+    }
+    else {
+        const { outDirServer } = getOutDirs(config);
+        const filePathRelative = path.posix.relative(outDirServer, filePathAbsolute);
+        return filePathRelative;
+    }
 }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -36,6 +36,9 @@ const configDefinitionsBuiltIn = {
     guard: {
         env: { server: true, client: 'if-client-routing' }
     },
+    data: {
+        env: { server: true }
+    },
     iKnowThePerformanceRisksOfAsyncRouteFunctions: {
         env: { server: true, client: 'if-client-routing', eager: true }
     },
@@ -76,6 +79,10 @@ const configDefinitionsBuiltIn = {
         env: { client: true },
         _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
     },
+    dataEnv: {
+        env: { client: true },
+        _computed: (configValueSources) => !isConfigSet(configValueSources, 'data') ? null : getConfigEnv(configValueSources, 'data')
+    },
     hooksTimeout: {
         env: { server: true, client: true }
     }

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

@@ -18,3 +18,4 @@ export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
 export * from '../../utils/deepEqual.js';
 export * from '../../utils/assertKeys.js';
+export * from '../../utils/injectRollupInputs.js';

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

@@ -24,3 +24,4 @@ export * from '../../utils/getPropAccessNotation.js';
 export * from '../../utils/mergeCumulativeValues.js';
 export * from '../../utils/deepEqual.js';
 export * from '../../utils/assertKeys.js';
+export * from '../../utils/injectRollupInputs.js';

package/dist/esm/node/runtime/html/serializePageContextClientSide.js

@@ -16,7 +16,8 @@ const PASS_TO_CLIENT = [
     '_abortCaller',
     */
     '_pageContextInitHasClientData',
-    '_pageId'
+    '_pageId',
+    'data' // for data() hook
 ];
 const PASS_TO_CLIENT_ERROR_PAGE = ['pageProps', 'is404', '_isError'];
 function serializePageContextClientSide(pageContext) {