vike 0.4.150 → 0.4.151

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

@@ -12,7 +12,6 @@ const buildConfig_js_1 = require("./plugins/buildConfig.js");
 const previewConfig_js_1 = require("./plugins/previewConfig.js");
 const autoFullBuild_js_1 = require("./plugins/autoFullBuild.js");
 const index_js_1 = require("./plugins/devConfig/index.js");
-const manifest_js_1 = require("./plugins/manifest.js");
 const packageJsonFile_js_1 = require("./plugins/packageJsonFile.js");
 const removeRequireHookPlugin_js_1 = require("./plugins/removeRequireHookPlugin.js");
 const index_js_2 = require("./plugins/importUserCode/index.js");
@@ -28,6 +27,7 @@ const extensionsAssets_js_1 = require("./plugins/extensionsAssets.js");
 const baseUrls_js_1 = require("./plugins/baseUrls.js");
 const envVars_js_1 = require("./plugins/envVars.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const assertFileEnv_js_1 = require("./plugins/assertFileEnv.js");
 (0, utils_js_2.markEnvAsVite)();
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeConfig) {
@@ -39,7 +39,6 @@ function plugin(vikeConfig) {
         (0, buildConfig_js_1.buildConfig)(),
         (0, previewConfig_js_1.previewConfig)(),
         ...(0, autoFullBuild_js_1.autoFullBuild)(),
-        ...(0, manifest_js_1.manifest)(),
         (0, packageJsonFile_js_1.packageJsonFile)(),
         (0, removeRequireHookPlugin_js_1.removeRequireHookPlugin)(),
         (0, distFileNames_js_1.distFileNames)(),
@@ -50,7 +49,8 @@ function plugin(vikeConfig) {
         ...(0, index_js_4.importBuild)(),
         (0, extensionsAssets_js_1.extensionsAssets)(),
         (0, baseUrls_js_1.baseUrls)(vikeConfig),
-        (0, envVars_js_1.envVarsPlugin)()
+        (0, envVars_js_1.envVarsPlugin)(),
+        (0, assertFileEnv_js_1.assertFileEnv)()
     ];
     return plugins;
 }

package/dist/cjs/node/plugin/plugins/assertFileEnv.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertFileEnv = void 0;
+const utils_js_1 = require("../utils.js");
+const extractAssetsPlugin_js_1 = require("./extractAssetsPlugin.js");
+const extractExportNamesPlugin_js_1 = require("./extractExportNamesPlugin.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function assertFileEnv() {
+    let config;
+    let isDev = false;
+    return {
+        name: 'vike:assertFileEnv',
+        // - We need to set `enforce: 'pre'` because, otherwise, the resolvedId() hook of Vite's internal plugin `vite:resolve` is called before and it doesn't seem to call `this.resolve()` which means that the resolveId() hook below is never called.
+        //   - Vite's `vite:resolve` plugin: https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/resolve.ts#L105
+        // - It's actually a good thing if the resolveId() hook below is the first one to be called because it doesn't actually resolve any ID, so all other resolveId() hooks will be called as normal. And with `this.resolve()` we get the information we want from all other resolvedId() hooks.
+        // - Path aliases are already resolved, even when using `enforce: 'pre'`. For example:
+        //   ```js
+        //   // /pages/index/+Page.tsx
+        //
+        //   // The value of `source` is `/home/rom/code/vike/examples/path-aliases/components/Counter` (instead of `#root/components/Counter`)
+        //   // The value of `importer` is `/home/rom/code/vike/examples/path-aliases/pages/index/+Page.tsx`
+        //   import { Counter } from '#root/components/Counter'
+        //   ```
+        enforce: 'pre',
+        resolveId: {
+            /* I don't know why, but path aliases aren't resolved anymore when setting `order: 'pre'`. (In principle, I'd assume that `this.resolve()` would resolve the alias but it doesn't.)
+            order: 'pre',
+            */
+            async handler(source, importer, options) {
+                // TODO/v1-release: remove
+                if (extractAssetsPlugin_js_1.extractAssetsRE.test(source) || extractExportNamesPlugin_js_1.extractExportNamesRE.test(source))
+                    return;
+                // Seems like Vite is doing some funky stuff here.
+                if (importer?.endsWith('.html'))
+                    return;
+                const resolved = await this.resolve(source, importer, {
+                    // Needed for old Vite plugins: https://vitejs.dev/guide/migration#rollup-4:~:text=For%20Vite%20plugins%2C%20this.resolve%20skipSelf%20option%20is%20now%20true%20by%20default.
+                    skipSelf: true,
+                    ...options
+                });
+                // resolved is null when import path is erroneous and doesn't actually point to a file
+                if (!resolved)
+                    return;
+                const modulePath = resolved.id.split('?')[0];
+                // `.server.js` and `.client.js` should only apply to user files
+                if (modulePath.includes('/node_modules/'))
+                    return;
+                // TODO/v1-release: remove
+                if (modulePath.endsWith('.css'))
+                    return;
+                const isServerSide = options?.ssr;
+                const envActual = isServerSide ? 'server' : 'client';
+                const envExpect = isServerSide ? 'client' : 'server';
+                const suffix = `.${envExpect}.`;
+                // Everything nonimal
+                if (!modulePath.includes(suffix))
+                    return;
+                // Show error message
+                let errMsg;
+                let modulePathPretty = (0, utils_js_1.getFilePathRelativeToUserRootDir)(modulePath, config.root);
+                modulePathPretty = modulePathPretty.replaceAll(suffix, picocolors_1.default.bold(suffix));
+                errMsg = `${(0, utils_js_1.capitalizeFirstLetter)(envExpect)}-only module ${modulePathPretty} (https://vike.dev/file-env) imported on the ${envActual}-side`;
+                if (importer &&
+                    // Don't show Vike's virtual modules that import the entry plus files such as /pages/about/+Page.js
+                    !importer.includes('virtual:vike:') &&
+                    // I don't know why and who sets importer to '<stdin>' (I guess Vite?)
+                    importer !== '<stdin>') {
+                    const importerPath = (0, utils_js_1.getFilePathRelativeToUserRootDir)(importer.split('?')[0], config.root);
+                    errMsg += ` by ${importerPath}`;
+                }
+                if (isDev) {
+                    errMsg += ' (building your app for production will be prevented and an error will be thrown)';
+                }
+                errMsg += '.';
+                if (isDev) {
+                    (0, utils_js_1.assertWarning)(false, errMsg, { onlyOnce: true });
+                }
+                else {
+                    (0, utils_js_1.assertUsage)(false, errMsg);
+                }
+            }
+        },
+        configResolved(config_) {
+            config = config_;
+        },
+        configureServer() {
+            isDev = true;
+        },
+        // Ensure this plugin works
+        transform(_code, id, options) {
+            if (isDev)
+                return;
+            // TODO/v1-release: remove
+            if (extractAssetsPlugin_js_1.extractAssetsRE.test(id) || extractExportNamesPlugin_js_1.extractExportNamesRE.test(id))
+                return;
+            if (id.split('?')[0].endsWith('.css'))
+                return;
+            const isServerSide = options?.ssr;
+            const envWrong = isServerSide ? 'client' : 'server';
+            (0, utils_js_1.assert)(!id.includes(`.${envWrong}.`));
+        }
+    };
+}
+exports.assertFileEnv = assertFileEnv;

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

@@ -63,9 +63,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 = !(0, isViteCliCall_js_1.isViteCliCall)() ? null : (0, isViteCliCall_js_1.getViteConfigFromCli)();
     const configInline = {
         ...configFromCli,

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

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeClientEntries = exports.assertRollupInput = exports.buildConfig = void 0;
 const utils_js_1 = require("../utils.js");
-const virtualFileImportUserCode_js_1 = require("../../shared/virtual-files/virtualFileImportUserCode.js");
 const getVikeConfig_js_1 = require("./importUserCode/v1-design/getVikeConfig.js");
 const helpers_js_1 = require("../../../shared/page-configs/helpers.js");
 const findPageFiles_js_1 = require("../shared/findPageFiles.js");
@@ -16,7 +15,7 @@ const module_1 = require("module");
 const getClientEntryFilePath_js_1 = require("../../shared/getClientEntryFilePath.js");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("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 = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 const manifestTempFile = '_temp_manifest.json';
@@ -30,14 +29,9 @@ function buildConfig() {
             order: 'post',
             async handler(config) {
                 assertRollupInput(config);
-                const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
                 const entries = await getEntries(config);
                 (0, utils_js_1.assert)(Object.keys(entries).length > 0);
-                const input = {
-                    ...entries,
-                    ...userInputs
-                };
-                config.build.rollupOptions.input = input;
+                config.build.rollupOptions.input = (0, utils_js_1.injectRollupInputs)(entries, config);
                 addLogHook();
             }
         },
@@ -76,12 +70,12 @@ async function getEntries(config) {
     const { pageConfigs } = await (0, getVikeConfig_js_1.getVikeConfig)(config, false);
     (0, utils_js_1.assertUsage)(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
     if ((0, utils_js_1.viteIsSSR)(config)) {
-        const serverEntries = analyzeServerEntries(pageConfigs);
+        const pageEntries = getPageEntries(pageConfigs);
         const entries = {
-            pageFiles: virtualFileImportUserCode_js_1.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;
     }
@@ -106,6 +100,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;
@@ -120,6 +122,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;
         }
@@ -138,14 +141,6 @@ function analyzeClientEntries(pageConfigs, config) {
     return { hasClientRouting, hasServerRouting, clientEntries };
 }
 exports.analyzeClientEntries = analyzeClientEntries;
-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) {
@@ -201,20 +196,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]));
-    }
-    (0, utils_js_1.assert)((0, utils_js_1.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)
@@ -243,9 +224,9 @@ function addLogHook() {
     });
 }
 function assertRollupInput(config) {
-    const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
+    const userInputs = (0, utils_js_1.normalizeRollupInput)(config.build.rollupOptions.input);
     const htmlInputs = Object.values(userInputs).filter((entry) => entry.endsWith('.html') || entry.endsWith('.htm'));
     const htmlInput = htmlInputs[0];
-    (0, utils_js_1.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`);
+    (0, utils_js_1.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`);
 }
 exports.assertRollupInput = assertRollupInput;

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

@@ -11,7 +11,7 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const path_1 = __importDefault(require("path"));
 const module_1 = require("module");
 const assertResolveAlias_js_1 = require("./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 = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 function commonConfig() {

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

@@ -10,7 +10,7 @@ const fs_1 = __importDefault(require("fs"));
 const fileTypes_js_1 = require("../../../../shared/getPageFiles/fileTypes.js");
 const module_1 = require("module");
 const picocolors_1 = __importDefault(require("@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 = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 function resolveExtensions(configs, config) {

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

@@ -9,7 +9,7 @@ const path_1 = __importDefault(require("path"));
 const utils_js_1 = require("../../utils.js");
 const import_1 = require("@brillout/import");
 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);
 async function getStemPackages(userAppRootDir) {

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

@@ -11,7 +11,7 @@ const utils_js_1 = require("../../utils.js");
 const module_1 = require("module");
 const path_2 = require("path");
 const url_1 = require("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 = `file://${__filename}`;
 const require_ = (0, module_1.createRequire)(importMetaUrl);
 const __dirname_ = (0, path_2.dirname)((0, url_1.fileURLToPath)(importMetaUrl));

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

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVikeManifest = void 0;
+const utils_js_1 = require("../../utils.js");
+const assertPluginManifest_js_1 = require("../../../shared/assertPluginManifest.js");
+const extractExportNamesPlugin_js_1 = require("../extractExportNamesPlugin.js");
+const path_1 = __importDefault(require("path"));
+const globalContext_js_1 = require("../../../runtime/globalContext.js");
+function getVikeManifest(config, configVike) {
+    const runtimeManifest = (0, globalContext_js_1.getRuntimeManifest)(configVike);
+    const manifest = {
+        version: utils_js_1.projectInfo.projectVersion,
+        usesClientRouter: (0, extractExportNamesPlugin_js_1.isUsingClientRouter)(),
+        manifestKeyMap: getManifestKeyMap(configVike, config),
+        ...runtimeManifest
+    };
+    (0, assertPluginManifest_js_1.assertPluginManifest)(manifest);
+    return manifest;
+}
+exports.getVikeManifest = getVikeManifest;
+function getManifestKeyMap(configVike, config) {
+    const manifestKeyMap = {};
+    configVike.extensions
+        .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
+        .flat()
+        .filter(utils_js_1.isNotNullish)
+        .forEach(({ importPath, filePath }) => {
+        // Recreating https://github.com/vitejs/vite/blob/8158ece72b66307e7b607b98496891610ca70ea2/packages/vite/src/node/plugins/manifest.ts#L38
+        const filePathRelative = path_1.default.posix.relative(config.root, (0, utils_js_1.toPosixPath)(filePath));
+        (0, utils_js_1.assertPosixPath)(filePathRelative);
+        (0, utils_js_1.assertPosixPath)(importPath);
+        manifestKeyMap[importPath] = filePathRelative;
+    });
+    return manifestKeyMap;
+}

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

@@ -8,47 +8,85 @@ const plugin_js_1 = require("@brillout/vite-plugin-import-build/plugin.js");
 const utils_js_1 = require("../../utils.js");
 const path_1 = __importDefault(require("path"));
 const module_1 = require("module");
-// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const getConfigVike_js_1 = require("../../../shared/getConfigVike.js");
+const getVikeManifest_js_1 = require("./getVikeManifest.js");
+const promises_1 = __importDefault(require("fs/promises"));
+const virtualFileImportUserCode_js_1 = require("../../../shared/virtual-files/virtualFileImportUserCode.js");
+// @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = `file://${__filename}`;
 const require_ = (0, module_1.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 (0, getConfigVike_js_1.getConfigVike)(config);
+            },
+            async writeBundle(options, bundle) {
+                if (!(0, utils_js_1.viteIsSSR)(config))
+                    return;
+                await replace_ASSETS_MAP(options, bundle);
             }
         },
         (0, plugin_js_1.importBuild)({
-            getImporterCode: ({ findBuildEntry }) => {
-                const pageFilesEntry = findBuildEntry('pageFiles');
-                return getImporterCode(config, pageFilesEntry);
+            getImporterCode: () => {
+                return getEntryCode(config, configVike);
             },
             libraryName: utils_js_1.projectInfo.projectName
         })
     ];
 }
 exports.importBuild = importBuild;
-function getImporterCode(config, pageFilesEntry) {
-    const filePathAbsolute = (0, utils_js_1.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 } = (0, utils_js_1.getOutDirs)(config);
-    const filePathRelative = path_1.default.posix.relative(outDirServer, filePathAbsolute);
-    // The only reason we went for using CJS require() instead of ESM import() is because import() doesn't support .json files
+function getEntryCode(config, configVike) {
+    const importPath = getImportPath(config);
+    const vikeManifest = (0, getVikeManifest_js_1.getVikeManifest)(config, configVike);
     const importerCode = [
-        '(async () => {',
-        `  const { setImportBuildGetters } = await import('${filePathRelative}');`,
+        `  import { setImportBuildGetters } from '${importPath}';`,
+        `  import * as pageFiles from '${virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer}';`,
         '  setImportBuildGetters({',
-        `    pageFiles: () => import('./${pageFilesEntry}'),`,
-        "    clientManifest: () => require('../assets.json'),",
-        // TODO: use virtual file instead of generating vike.json
-        "    pluginManifest: () => require('../client/vike.json'),",
+        `    pageFiles: () => pageFiles,`,
+        // TODO: rename clientManifest -> assetManifest
+        `    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;
+    (0, utils_js_1.assert)(dir);
+    // I guess importBuild won't be found in the bundle when using @vitejs/plugin-legacy
+    const importBuildEntry = (0, plugin_js_1.findImportBuildBundleEntry)(bundle);
+    const importBuildFilePath = path_1.default.join(dir, importBuildEntry.fileName);
+    const assetsJsonFilePath = path_1.default.join(dir, '..', 'assets.json');
+    const [assetsJsonString, importBuildFileContent] = await Promise.all([
+        await promises_1.default.readFile(assetsJsonFilePath, 'utf8'),
+        await promises_1.default.readFile(importBuildFilePath, 'utf8')
+    ]);
+    const importBuildFileContentFixed = importBuildFileContent.replace(ASSETS_MAP, assetsJsonString);
+    (0, utils_js_1.assert)(importBuildFileContentFixed !== importBuildFileContent);
+    await promises_1.default.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 = (0, utils_js_1.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`));
+    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 } = (0, utils_js_1.getOutDirs)(config);
+        const filePathRelative = path_1.default.posix.relative(outDirServer, filePathAbsolute);
+        return filePathRelative;
+    }
+}

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

@@ -37,6 +37,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 }
     },
@@ -77,6 +80,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/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -10,22 +10,23 @@ const fast_glob_1 = __importDefault(require("fast-glob"));
 const child_process_1 = require("child_process");
 const util_1 = require("util");
 const execA = (0, util_1.promisify)(child_process_1.exec);
+const globalObject = (0, utils_js_1.getGlobalObject)('crawlPlusFiles.ts', {
+    gitIsMissing: false
+});
 async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
     (0, utils_js_1.assertPosixPath)(userRootDir);
     (0, utils_js_1.assertPosixPath)(outDirAbsoluteFilesystem);
-    // Vike prepends userRootDir without resolving, e.g. outDirRelativeFromUserRootDir can be /home/rom/my-monorepo/my-app/../my-build/dist/ while userRootDir is /home/rom/my-monorepo/my-app/
-    (0, utils_js_1.assert)(outDirAbsoluteFilesystem.startsWith(userRootDir));
     let outDirRelativeFromUserRootDir = path_1.default.posix.relative(userRootDir, outDirAbsoluteFilesystem);
     if (outDirRelativeFromUserRootDir.startsWith('../')) {
         // config.outDir is outside of config.root => it's going to be ignored anyways
         outDirRelativeFromUserRootDir = null;
     }
     (0, utils_js_1.assert)(outDirRelativeFromUserRootDir === null || !outDirRelativeFromUserRootDir.startsWith('.'));
-    const timeBase = new Date().getTime();
+    const timeBefore = new Date().getTime();
     let files = [];
     const res = await gitLsFiles(userRootDir, outDirRelativeFromUserRootDir);
     if (res &&
-        // Fallback to fast-glob for users that dynamically generate plus files (we assume generetad plus files to be skipped because they are usually included in .gitignore)
+        // Fallback to fast-glob for users that dynamically generate plus files. (Assuming all (generetad) plus files to be skipped because users usually included them in `.gitignore`.)
         res.length > 0) {
         files = res;
     }
@@ -33,10 +34,11 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
         files = await fastGlob(userRootDir, outDirRelativeFromUserRootDir);
     }
     {
-        const time = new Date().getTime() - timeBase;
+        const timeAfter = new Date().getTime();
+        const timeSpent = timeAfter - timeBefore;
         if (isDev) {
-            // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
-            (0, utils_js_1.assertWarning)(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on Vike's GitHub.`, {
+            // We only warn in dev, because while building it's expected to take a long time as crawling is competing for resources with other tasks.
+            (0, utils_js_1.assertWarning)(timeSpent < 2 * 1000, `Crawling your user files took an unexpected long time (${timeSpent}ms). Create a new issue on Vike's GitHub.`, {
                 onlyOnce: 'slow-page-files-search'
             });
         }
@@ -56,37 +58,54 @@ async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
 exports.crawlPlusFiles = crawlPlusFiles;
 // Same as fastGlob() but using `$ git ls-files`
 async function gitLsFiles(userRootDir, outDirRelativeFromUserRootDir) {
-    if (!(await isUsingGit(userRootDir)))
+    if (globalObject.gitIsMissing)
         return null;
+    const ignoreAsPatterns = getIgnoreAsPatterns(outDirRelativeFromUserRootDir);
+    const ignoreAsFilterFn = getIgnoreAsFilterFn(outDirRelativeFromUserRootDir);
     const cmd = [
         'git ls-files',
         ...utils_js_1.scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
-        ...getIgnorePatterns(outDirRelativeFromUserRootDir).map((pattern) => `--exclude="${pattern}"`),
+        ...ignoreAsPatterns.map((pattern) => `--exclude="${pattern}"`),
         // --others lists untracked files only (but using .gitignore because --exclude-standard)
         // --cached adds the tracked files to the output
         '--others --cached --exclude-standard'
     ].join(' ');
-    let files = await runCmd(cmd, userRootDir);
-    files = files.filter(
-    // We have to repeat the same exclusion logic here because the `git ls-files` option --exclude only applies to untracked files. (We use --exclude only to speed up the command.)
-    (file) => getIgnoreFilter(file, outDirRelativeFromUserRootDir));
-    // Remove tracked but deleted files
-    const filesIgnore = await runCmd('git ls-files --deleted', userRootDir);
-    files = files.filter((file) => !filesIgnore.includes(file));
+    let files;
+    let filesDeleted;
+    try {
+        ;
+        [files, filesDeleted] = await Promise.all([
+            // Main command
+            runCmd(cmd, userRootDir),
+            // Get tracked by deleted files
+            runCmd('git ls-files --deleted', userRootDir)
+        ]);
+    }
+    catch (err) {
+        if (await isGitMissing(userRootDir)) {
+            globalObject.gitIsMissing = true;
+            return null;
+        }
+        throw err;
+    }
+    files = files
+        // We have to repeat the same exclusion logic here because the `git ls-files` option --exclude only applies to untracked files. (We use --exclude only to speed up the command.)
+        .filter(ignoreAsFilterFn)
+        .filter((file) => !filesDeleted.includes(file));
     return files;
 }
 // Same as gitLsFiles() but using fast-glob
 async function fastGlob(userRootDir, outDirRelativeFromUserRootDir) {
     const files = await (0, fast_glob_1.default)(`**/+*.${utils_js_1.scriptFileExtensions}`, {
-        ignore: getIgnorePatterns(outDirRelativeFromUserRootDir),
+        ignore: getIgnoreAsPatterns(outDirRelativeFromUserRootDir),
         cwd: userRootDir,
         dot: false
     });
     return files;
 }
 // Same as getIgnoreFilter() but as glob pattern
-function getIgnorePatterns(outDirRelativeFromUserRootDir) {
-    const ignorePatterns = [
+function getIgnoreAsPatterns(outDirRelativeFromUserRootDir) {
+    const ignoreAsPatterns = [
         '**/node_modules/**',
         // Allow:
         // ```
@@ -97,31 +116,30 @@ function getIgnorePatterns(outDirRelativeFromUserRootDir) {
     ];
     if (outDirRelativeFromUserRootDir) {
         (0, utils_js_1.assert)(!outDirRelativeFromUserRootDir.startsWith('/'));
-        ignorePatterns.push(`${outDirRelativeFromUserRootDir}/**`);
+        ignoreAsPatterns.push(`${outDirRelativeFromUserRootDir}/**`);
     }
-    return ignorePatterns;
+    return ignoreAsPatterns;
 }
 // Same as getIgnorePatterns() but for Array.filter()
-function getIgnoreFilter(file, outDirRelativeFromUserRootDir) {
-    (0, utils_js_1.assert)(!file.startsWith('/'));
+function getIgnoreAsFilterFn(outDirRelativeFromUserRootDir) {
     (0, utils_js_1.assert)(outDirRelativeFromUserRootDir === null || !outDirRelativeFromUserRootDir.startsWith('/'));
-    return (!file.includes('node_modules/') &&
+    return (file) => !file.includes('node_modules/') &&
         !file.includes('.telefunc.') &&
-        (!outDirRelativeFromUserRootDir || !file.startsWith(`${outDirRelativeFromUserRootDir}/`)));
+        (outDirRelativeFromUserRootDir === null || !file.startsWith(`${outDirRelativeFromUserRootDir}/`));
 }
 // Whether Git is installed and whether userRootDir is inside a Git repository
-async function isUsingGit(userRootDir) {
+async function isGitMissing(userRootDir) {
     let res;
     try {
         res = await execA('git rev-parse --is-inside-work-tree', { cwd: userRootDir });
     }
     catch {
-        return false;
+        return true;
     }
     const { stdout, stderr } = res;
     (0, utils_js_1.assert)(stderr.toString().trim() === '');
     (0, utils_js_1.assert)(stdout.toString().trim() === 'true');
-    return true;
+    return false;
 }
 async function runCmd(cmd, cwd) {
     const res = await execA(cmd, { cwd });