vike 0.4.247 → 0.4.249-commit-775a43e

package/dist/node/vite/plugins/pluginReplaceConstantsEnvVars.js

@@ -0,0 +1,131 @@
+export { pluginReplaceConstantsEnvVars };
+import { loadEnv } from 'vite';
+import { assert, assertPosixPath, assertUsage, assertWarning, escapeRegex, isArray, isNotNullish, lowerFirst, } from '../utils.js';
+import { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
+import { normalizeId } from '../shared/normalizeId.js';
+import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+import { getMagicString } from '../shared/getMagicString.js';
+const PUBLIC_ENV_PREFIX = 'PUBLIC_ENV__';
+const PUBLIC_ENV_ALLOWLIST = [
+    // https://github.com/vikejs/vike/issues/1724
+    'STORYBOOK',
+];
+// TO-DO/eventually:
+// - Make import.meta.env work inside +config.js
+//   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
+//   - Or stop using Vite's `mode` implementation and have Vike implement its own `mode` feature? (So that the only dependencies are `$ vike build --mode staging` and `$ MODE=staging vike build`.)
+const skipNodeModules = '/node_modules/';
+const skipIrrelevant = 'import.meta.env.';
+const filterRolldown = {
+    id: {
+        exclude: `**${skipNodeModules}**`,
+    },
+    code: {
+        include: skipIrrelevant,
+    },
+};
+const filterFunction = (id, code) => {
+    if (id.includes(skipNodeModules))
+        return false;
+    if (!code.includes(skipIrrelevant))
+        return false;
+    return true;
+};
+function pluginReplaceConstantsEnvVars() {
+    let envVarsAll;
+    let envPrefix;
+    let config;
+    return [
+        {
+            name: 'vike:pluginReplaceConstantsEnvVars',
+            enforce: 'post',
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                    envVarsAll = loadEnv(config.mode, config.envDir || config.root, '');
+                    // Add process.env values defined by .env files
+                    Object.entries(envVarsAll).forEach(([key, val]) => { var _a; return ((_a = process.env)[key] ?? (_a[key] = val)); });
+                    envPrefix = getEnvPrefix(config);
+                    config.plugins.sort(lowerFirst((plugin) => (plugin.name === 'vite:define' ? 1 : 0)));
+                },
+            },
+            transform: {
+                filter: filterRolldown,
+                handler(code, id, options) {
+                    id = normalizeId(id);
+                    assertPosixPath(id);
+                    assertPosixPath(config.root);
+                    if (!id.startsWith(config.root))
+                        return; // skip linked dependencies
+                    assert(filterFunction(id, code));
+                    const isBuild = config.command === 'build';
+                    const isClientSide = !isViteServerSide_extraSafe(config, this.environment, options);
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    // Get regex operations
+                    const replacements = Object.entries(envVarsAll)
+                        // Skip env vars that start with [`config.envPrefix`](https://vite.dev/config/shared-options.html#envprefix) — they are already handled by Vite
+                        .filter(([envName]) => !envPrefix.some((prefix) => envName.startsWith(prefix)))
+                        // Skip constants like import.meta.env.DEV which are already handled by Vite
+                        .filter(([envName]) => !['DEV', 'PROD', 'SSR', 'MODE', 'BASE_URL'].includes(envName))
+                        .map(([envName, envVal]) => {
+                        const envStatement = `import.meta.env.${envName}`;
+                        const envStatementRegExpStr = escapeRegex(envStatement) + '\\b';
+                        // Show error (warning in dev) if client code contains a private environment variable (one that doesn't start with PUBLIC_ENV__ and that isn't included in `PUBLIC_ENV_ALLOWLIST`).
+                        if (isClientSide) {
+                            const skip = assertNoClientSideLeak({
+                                envName,
+                                envStatement,
+                                envStatementRegExpStr,
+                                code,
+                                id,
+                                config,
+                                isBuild,
+                            });
+                            if (skip)
+                                return null;
+                        }
+                        return { regExpStr: envStatementRegExpStr, replacement: envVal };
+                    })
+                        .filter(isNotNullish);
+                    // Apply regex operations
+                    replacements.forEach(({ regExpStr, replacement }) => {
+                        magicString.replaceAll(new RegExp(regExpStr, 'g'), JSON.stringify(replacement));
+                    });
+                    return getMagicStringResult();
+                },
+            },
+        },
+    ];
+}
+function getEnvPrefix(config) {
+    const { envPrefix } = config;
+    if (!envPrefix)
+        return [];
+    if (!isArray(envPrefix))
+        return [envPrefix];
+    return envPrefix;
+}
+function assertNoClientSideLeak({ envName, envStatement, envStatementRegExpStr, code, id, config, isBuild, }) {
+    const isPrivate = !envName.startsWith(PUBLIC_ENV_PREFIX) && !PUBLIC_ENV_ALLOWLIST.includes(envName);
+    // ✅ All good
+    if (!isPrivate)
+        return;
+    if (!new RegExp(envStatementRegExpStr).test(code))
+        return true;
+    // ❌ Security leak!
+    // - Warning in dev
+    // - assertUsage() and abort when building for production
+    const modulePath = getFilePathToShowToUserModule(id, config);
+    const errMsgAddendum = isBuild ? '' : ' (Vike will prevent your app from building for production)';
+    const envNameFixed = `${PUBLIC_ENV_PREFIX}${envName}`;
+    const errMsg = `${envStatement} is used in client-side file ${modulePath} which means that the environment variable ${envName} will be included in client-side bundles and, therefore, ${envName} will be publicly exposed which can be a security leak${errMsgAddendum}. Use ${envStatement} only in server-side files, or rename ${envName} to ${envNameFixed}, see https://vike.dev/env`;
+    if (isBuild) {
+        assertUsage(false, errMsg);
+    }
+    else {
+        // - Only a warning for faster development DX (e.g. when user toggles `ssr: boolean` or `onBeforeRenderIsomorph: boolean`).
+        // - Although only showing a warning can be confusing: https://github.com/vikejs/vike/issues/1641
+        assertWarning(false, errMsg, { onlyOnce: true });
+    }
+    assert(!isBuild); // we should abort if building for production
+}

package/dist/node/vite/plugins/pluginReplaceConstantsGlobalThis.d.ts

@@ -0,0 +1,13 @@
+export { pluginReplaceConstantsGlobalThis };
+export { VIRTUAL_FILE_ID_constantsGlobalThis };
+export type _LoadDeclareGlobal__VIKE__IS = never;
+import type { Plugin } from 'vite';
+declare global {
+    /** Like `import.meta.env.DEV` but works for `node_modules/` packages with `ssr.external` */
+    var __VIKE__IS_DEV: boolean;
+    /** Like `import.meta.env.SSR` but works for `node_modules/` packages with `ssr.external` */
+    var __VIKE__IS_CLIENT: boolean;
+    var __VIKE__IS_DEBUG: boolean;
+}
+declare const VIRTUAL_FILE_ID_constantsGlobalThis = "virtual:vike:server:constantsGlobalThis";
+declare function pluginReplaceConstantsGlobalThis(): Plugin[];

package/dist/node/vite/plugins/pluginReplaceConstantsGlobalThis.js

@@ -0,0 +1,78 @@
+export { pluginReplaceConstantsGlobalThis };
+export { VIRTUAL_FILE_ID_constantsGlobalThis };
+import { assert, isDebug, addVirtualFileIdPrefix, escapeRegex } from '../utils.js';
+import { isViteServerSide_applyToEnvironment, isViteServerSide_configEnvironment, isViteServerSide_extraSafe, } from '../shared/isViteServerSide.js';
+const isDebugVal = isDebug();
+globalThis.__VIKE__IS_CLIENT = false;
+globalThis.__VIKE__IS_DEBUG = isDebugVal;
+const VIRTUAL_FILE_ID_constantsGlobalThis = 'virtual:vike:server:constantsGlobalThis';
+const filterRolldown = {
+    id: {
+        include: new RegExp(escapeRegex(VIRTUAL_FILE_ID_constantsGlobalThis)),
+    },
+};
+const filterFunction = (id) => id === VIRTUAL_FILE_ID_constantsGlobalThis || id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis);
+function pluginReplaceConstantsGlobalThis() {
+    let config;
+    let isDev;
+    return [
+        {
+            name: 'vike:pluginReplaceConstantsGlobalThis:define',
+            config: {
+                handler(config) {
+                    assert(typeof config._isDev === 'boolean');
+                    isDev = config._isDev;
+                    globalThis.__VIKE__IS_DEV = isDev;
+                    return {
+                        define: {
+                            'globalThis.__VIKE__IS_DEV': JSON.stringify(isDev),
+                            'globalThis.__VIKE__IS_DEBUG': JSON.stringify(isDebugVal),
+                        },
+                    };
+                },
+            },
+            configEnvironment: {
+                handler(name, config) {
+                    const isClientSide = !isViteServerSide_configEnvironment(name, config);
+                    return {
+                        define: {
+                            'globalThis.__VIKE__IS_CLIENT': JSON.stringify(isClientSide),
+                        },
+                    };
+                },
+            },
+            configResolved(config_) {
+                config = config_;
+            },
+        },
+        {
+            name: 'vike:pluginReplaceConstantsGlobalThis:virtual-file',
+            // We only need the virtual file for the server-side (for node_modules/ packages with ssr.external) — the `define` values above always apply to the client-side.
+            applyToEnvironment(env) {
+                return isViteServerSide_applyToEnvironment(env);
+            },
+            resolveId: {
+                filter: filterRolldown,
+                handler(id) {
+                    assert(filterFunction(id));
+                    assert(id === VIRTUAL_FILE_ID_constantsGlobalThis);
+                    return addVirtualFileIdPrefix(id);
+                },
+            },
+            load: {
+                filter: filterRolldown,
+                handler(id, options) {
+                    assert(filterFunction(id));
+                    assert(isViteServerSide_extraSafe(config, this.environment, options));
+                    assert(typeof isDev === 'boolean');
+                    const code = [
+                        `globalThis.__VIKE__IS_DEV = ${JSON.stringify(isDev)};`,
+                        `globalThis.__VIKE__IS_CLIENT = false;`,
+                        `globalThis.__VIKE__IS_DEBUG = ${JSON.stringify(isDebugVal)};`,
+                    ].join('\n');
+                    return code;
+                },
+            },
+        },
+    ];
+}

package/dist/node/vite/plugins/pluginSetGlobalContext.js

@@ -0,0 +1,49 @@
+export { pluginSetGlobalContext };
+import { setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_isProductionAccordingToVite, } from '../../../server/runtime/globalContext.js';
+import { isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
+import { reloadVikeConfig } from '../shared/resolveVikeConfigInternal.js';
+import { getViteConfigRuntime } from '../shared/getViteConfigRuntime.js';
+function pluginSetGlobalContext() {
+    let isServerReload = false;
+    return [
+        {
+            name: 'vike:pluginSetGlobalContext:pre',
+            enforce: 'pre',
+            // This hook is called not only at server start but also at server restart (a new `viteDevServer` instance is created)
+            configureServer: {
+                order: 'pre',
+                handler(viteDevServer) {
+                    if (isServerReload)
+                        reloadVikeConfig();
+                    isServerReload = true;
+                    setGlobalContext_viteDevServer(viteDevServer);
+                    markSetup_viteDevServer();
+                },
+            },
+            configurePreviewServer: {
+                handler() {
+                    markSetup_vitePreviewServer();
+                },
+            },
+            config: {
+                order: 'pre',
+                handler(_, env) {
+                    const isViteDev = isDevCheck(env);
+                    setGlobalContext_isProductionAccordingToVite(!isViteDev);
+                    markSetup_isViteDev(isViteDev);
+                },
+            },
+        },
+        {
+            name: 'vike:pluginSetGlobalContext:post',
+            enforce: 'post',
+            configResolved: {
+                order: 'post',
+                async handler(config) {
+                    const viteConfigRuntime = getViteConfigRuntime(config);
+                    setGlobalContext_viteConfig(config, viteConfigRuntime);
+                },
+            },
+        },
+    ];
+}

package/dist/node/vite/plugins/pluginVirtualFiles/debug.js

@@ -0,0 +1,2 @@
+import { createDebug } from '../../utils.js';
+export const debug = createDebug('vike:virtualFiles');

package/dist/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntry.js

@@ -0,0 +1,61 @@
+export { generateVirtualFileGlobalEntry };
+import { generateVirtualFileId } from '../../../../shared-server-node/virtualFileId.js';
+import { debug } from './debug.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { serializeConfigValues, } from '../../../../shared-server-client/page-configs/serialize/serializeConfigValues.js';
+import { VIRTUAL_FILE_ID_constantsGlobalThis } from '../pluginReplaceConstantsGlobalThis.js';
+async function generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting) {
+    const vikeConfig = await getVikeConfigInternal(true);
+    const { _pageConfigs: pageConfigs, _pageConfigGlobal: pageConfigGlobal } = vikeConfig;
+    return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
+}
+function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {
+    const lines = [];
+    const importStatements = [];
+    const filesEnv = new Map();
+    if (!isForClientSide) {
+        importStatements.push(`import '${VIRTUAL_FILE_ID_constantsGlobalThis}';`);
+    }
+    lines.push('export const pageConfigsSerialized = [');
+    lines.push(getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
+    lines.push('];');
+    lines.push('export const pageConfigGlobalSerialized = {');
+    lines.push(getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv));
+    lines.push('};');
+    if (!isForClientSide && isDev) {
+        // https://vite.dev/guide/api-environment-frameworks.html
+        lines.push('if (import.meta.hot) import.meta.hot.accept();');
+    }
+    let code = [...importStatements, ...lines].join('\n');
+    if (!isForClientSide) {
+        code = `import '${VIRTUAL_FILE_ID_constantsGlobalThis}';\n` + code;
+    }
+    debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    return code;
+}
+function getCodePageConfigsSerialized(pageConfigs, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
+    const lines = [];
+    pageConfigs.forEach((pageConfig) => {
+        const { pageId, routeFilesystem, isErrorPage } = pageConfig;
+        lines.push(`  {`);
+        lines.push(`    pageId: ${JSON.stringify(pageId)},`);
+        lines.push(`    isErrorPage: ${JSON.stringify(isErrorPage)},`);
+        lines.push(`    routeFilesystem: ${JSON.stringify(routeFilesystem)},`);
+        const virtualFileId = JSON.stringify(generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide }));
+        lines.push(`    loadVirtualFilePageEntry: () => ({ moduleId: ${virtualFileId}, moduleExportsPromise: import(${virtualFileId}) }),`);
+        lines.push(`    configValuesSerialized: {`);
+        lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', true));
+        lines.push(`    },`);
+        lines.push(`  },`);
+    });
+    const code = lines.join('\n');
+    return code;
+}
+function getCodePageConfigGlobalSerialized(pageConfigGlobal, isForClientSide, isClientRouting, isDev, importStatements, filesEnv) {
+    const lines = [];
+    lines.push(`  configValuesSerialized: {`);
+    lines.push(...serializeConfigValues(pageConfigGlobal, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '    ', null));
+    lines.push(`  },`);
+    const code = lines.join('\n');
+    return code;
+}

package/dist/node/vite/plugins/pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js

@@ -0,0 +1,189 @@
+export { generateVirtualFileGlobalEntryWithOldDesign };
+import { assert, assertPosixPath, scriptFileExtensionPattern, debugGlob, isVersionMatch, assertWarning, } from '../../utils.js';
+import { parseVirtualFileId } from '../../../../shared-server-node/virtualFileId.js';
+import { version as viteVersion } from 'vite';
+import { fileTypes } from '../../../../shared-server-client/getPageFiles/fileTypes.js';
+import path from 'node:path';
+import { generateVirtualFileGlobalEntry } from './generateVirtualFileGlobalEntry.js';
+import { getVikeConfigInternal, isV1Design as isV1Design_ } from '../../shared/resolveVikeConfigInternal.js';
+import { getOutDirs } from '../../shared/getOutDirs.js';
+import { isViteServerSide_extraSafe } from '../../shared/isViteServerSide.js';
+import { resolveIncludeAssetsImportedByServer } from '../../../../server/runtime/renderPageServer/getPageAssets/retrievePageAssetsProd.js';
+import { VIRTUAL_FILE_ID_constantsGlobalThis } from '../pluginReplaceConstantsGlobalThis.js';
+async function generateVirtualFileGlobalEntryWithOldDesign(id, options, config, env, isDev) {
+    const idParsed = parseVirtualFileId(id);
+    assert(idParsed && idParsed.type === 'global-entry');
+    const { isForClientSide, isClientRouting } = idParsed;
+    assert(isForClientSide === !isViteServerSide_extraSafe(config, env, options));
+    const code = await getCode(config, isForClientSide, isClientRouting, isDev, id);
+    return code;
+}
+async function getCode(config, isForClientSide, isClientRouting, isDev, id) {
+    const { command } = config;
+    assert(command === 'serve' || command === 'build');
+    const isBuild = command === 'build';
+    assert(isDev === !isBuild);
+    let content = '';
+    if (!isForClientSide) {
+        content += `import '${VIRTUAL_FILE_ID_constantsGlobalThis}';\n`;
+    }
+    {
+        const globRoots = getGlobRoots(config);
+        debugGlob('Glob roots: ', globRoots);
+        content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, isDev, id);
+    }
+    debugGlob(`Glob imports for ${isForClientSide ? 'client' : 'server'}:\n`, content);
+    return content;
+}
+function determineInjection({ fileType, isForClientSide, isClientRouting, isPrerendering, isBuild, }) {
+    if (!isForClientSide) {
+        return {
+            includeImport: fileType === '.page.server' || fileType === '.page' || fileType === '.page.route',
+            includeExportNames: isPrerendering && isBuild
+                ? fileType === '.page.client' || fileType === '.page.server' || fileType === '.page' // We extensively use `PageFile['exportNames']` while pre-rendering, in order to avoid loading page files unnecessarily, and therefore reducing memory usage.
+                : fileType === '.page.client',
+        };
+    }
+    else {
+        const includeImport = fileType === '.page.client' || fileType === '.css' || fileType === '.page';
+        if (!isClientRouting) {
+            return {
+                includeImport,
+                includeExportNames: false,
+            };
+        }
+        else {
+            return {
+                includeImport: includeImport || fileType === '.page.route',
+                includeExportNames: fileType === '.page.client' || fileType === '.page.server' || fileType === '.page',
+            };
+        }
+    }
+}
+async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, isDev, id) {
+    let fileContent = `// Generated by Vike
+
+export const pageFilesLazy = {};
+export const pageFilesEager = {};
+export const pageFilesExportNamesLazy = {};
+export const pageFilesExportNamesEager = {};
+export const pageFilesList = [];
+export const neverLoaded = {};
+
+${await generateVirtualFileGlobalEntry(isForClientSide, isDev, id, isClientRouting)}
+
+`;
+    // We still use import.meta.glob() when using th V1 design in order to not break the V1 design deprecation warning
+    const isV1Design = isV1Design_();
+    const vikeConfig = await getVikeConfigInternal();
+    // Old design => no + files => only to enable pre-rendering is setting `vike({prerender})` in vite.config.js
+    const isPrerendering = !!vikeConfig.config.prerender;
+    fileTypes
+        .filter((fileType) => fileType !== '.css')
+        .forEach((fileType) => {
+        const { includeImport, includeExportNames } = determineInjection({
+            fileType,
+            isForClientSide,
+            isClientRouting,
+            isPrerendering,
+            isBuild,
+        });
+        if (includeImport) {
+            fileContent += getGlobs(globRoots, isBuild, fileType, null, isV1Design);
+        }
+        if (includeExportNames) {
+            fileContent += getGlobs(globRoots, isBuild, fileType, 'extractExportNames', isV1Design);
+        }
+    });
+    const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
+    if (includeAssetsImportedByServer && isForClientSide) {
+        fileContent += getGlobs(globRoots, isBuild, '.page.server', 'extractAssets', isV1Design);
+    }
+    return fileContent;
+}
+function getGlobs(globRoots, isBuild, fileType, query, isV1Design) {
+    const isEager = isBuild && (query === 'extractExportNames' || fileType === '.page.route');
+    let pageFilesVar;
+    if (query === 'extractExportNames') {
+        if (!isEager) {
+            pageFilesVar = 'pageFilesExportNamesLazy';
+        }
+        else {
+            pageFilesVar = 'pageFilesExportNamesEager';
+        }
+    }
+    else if (query === 'extractAssets') {
+        assert(!isEager);
+        pageFilesVar = 'neverLoaded';
+    }
+    else if (!query) {
+        if (!isEager) {
+            pageFilesVar = 'pageFilesLazy';
+        }
+        else {
+            // Used for `.page.route.js` files
+            pageFilesVar = 'pageFilesEager';
+        }
+    }
+    else {
+        assert(false);
+    }
+    const varNameSuffix = (fileType === '.page' && 'Isomorph') ||
+        (fileType === '.page.client' && 'Client') ||
+        (fileType === '.page.server' && 'Server') ||
+        (fileType === '.page.route' && 'Route');
+    assert(varNameSuffix);
+    const varName = `${pageFilesVar}${varNameSuffix}`;
+    const varNameLocals = [];
+    return [
+        ...globRoots.map((globRoot, i) => {
+            const varNameLocal = `${varName}${i + 1}`;
+            varNameLocals.push(varNameLocal);
+            const globIncludePath = `'${getGlobPath(globRoot.includeDir, fileType)}'`;
+            const globExcludePath = globRoot.excludeDir ? `'!${getGlobPath(globRoot.excludeDir, fileType)}'` : null;
+            const globOptions = { eager: isEager };
+            if (query) {
+                const isNewViteInterface = isVersionMatch(viteVersion, ['5.1.0']);
+                if (isNewViteInterface &&
+                    // When used for the old design, the new syntax breaks Vike's CI (surprinsigly so). I couldn't reproduce locally (I didn't dig much).
+                    isV1Design) {
+                    globOptions.query = `?${query}`;
+                }
+                else {
+                    globOptions.as = query;
+                    const msg = [
+                        "Update to the new V1 design to get rid of Vite's warning:",
+                        'The glob option "as" has been deprecated in favour of "query".',
+                        'See https://vike.dev/migration/v1-design for how to migrate.',
+                    ].join(' ');
+                    assertWarning(!isNewViteInterface, msg, { onlyOnce: true });
+                }
+            }
+            const globPaths = globExcludePath ? `[${globIncludePath}, ${globExcludePath}]` : `[${globIncludePath}]`;
+            const globLine = `const ${varNameLocal} = import.meta.glob(${globPaths}, ${JSON.stringify(globOptions)});`;
+            return globLine;
+        }),
+        `const ${varName} = {${varNameLocals.map((varNameLocal) => `...${varNameLocal}`).join(',')}};`,
+        `${pageFilesVar}['${fileType}'] = ${varName};`,
+        '',
+    ].join('\n');
+}
+function getGlobRoots(config) {
+    const globRoots = [
+        {
+            includeDir: '/',
+            excludeDir: path.posix.relative(config.root, getOutDirs(config, undefined).outDirRoot),
+        },
+    ];
+    return globRoots;
+}
+function getGlobPath(globRootDir, fileType) {
+    assertPosixPath(globRootDir);
+    let globPath = [...globRootDir.split('/'), '**', `*${fileType}.${scriptFileExtensionPattern}`]
+        .filter(Boolean)
+        .join('/');
+    if (!globPath.startsWith('/')) {
+        globPath = '/' + globPath;
+    }
+    return globPath;
+}

package/dist/node/vite/plugins/pluginVirtualFiles/generateVirtualFilePageEntry.js

@@ -0,0 +1,52 @@
+export { generateVirtualFilePageEntry };
+import { assert, getProjectError } from '../../utils.js';
+import { parseVirtualFileId, generateVirtualFileId } from '../../../../shared-server-node/virtualFileId.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { extractAssetsAddQuery } from '../../../../shared-server-node/extractAssetsQuery.js';
+import { debug } from './debug.js';
+import { serializeConfigValues, } from '../../../../shared-server-client/page-configs/serialize/serializeConfigValues.js';
+import { handleAssetsManifest_isFixEnabled } from '../build/handleAssetsManifest.js';
+import { getConfigValueBuildTime } from '../../../../shared-server-client/page-configs/getConfigValueBuildTime.js';
+import { resolveIncludeAssetsImportedByServer } from '../../../../server/runtime/renderPageServer/getPageAssets/retrievePageAssetsProd.js';
+async function generateVirtualFilePageEntry(id, isDev) {
+    const result = parseVirtualFileId(id);
+    assert(result && result.type === 'page-entry');
+    /* This assertion fails when using includeAssetsImportedByServer
+    {
+      const isForClientSide = !config.build.ssr
+      assert(result.isForClientSide === isForClientSide)
+    }
+    */
+    const { pageId, isForClientSide } = result;
+    const vikeConfig = await getVikeConfigInternal(true);
+    const { _pageConfigs: pageConfigs } = vikeConfig;
+    const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
+    if (!isDev) {
+        assert(pageConfig);
+    }
+    else {
+        /* This assertion sometimes fail. It happens very seldom and I couldn't reproduce it (https://gist.github.com/brillout/9e212ce829f4d62a912ca163ffa8881a). I suspect some kind of HMR race condition. UPDATE: [December 2024] This just happened at test/@cloudflare_vite-plugin/ — it isn't blocking, reloading the page fixes the issue.
+        assert(pageConfig, { id, pageId })
+        /*/
+        if (!pageConfig)
+            throw getProjectError('Outdated request');
+        //*/
+    }
+    const code = getCode(pageConfig, isForClientSide, pageId, resolveIncludeAssetsImportedByServer(vikeConfig.config), isDev);
+    debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
+    return code;
+}
+function getCode(pageConfig, isForClientSide, pageId, includeAssetsImportedByServer, isDev) {
+    const lines = [];
+    const importStatements = [];
+    const filesEnv = new Map();
+    const isClientRouting = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
+    lines.push('export const configValuesSerialized = {');
+    lines.push(...serializeConfigValues(pageConfig, importStatements, filesEnv, { isForClientSide, isClientRouting, isDev }, '', false));
+    lines.push('};');
+    if (!handleAssetsManifest_isFixEnabled() && includeAssetsImportedByServer && isForClientSide && !isDev) {
+        importStatements.push(`import '${extractAssetsAddQuery(generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide: false }))}'`);
+    }
+    const code = [...importStatements, ...lines].join('\n');
+    return code;
+}