vike 0.4.247-commit-903de25 → 0.4.247-commit-14351e3

package/dist/esm/node/vite/plugins/pluginExtractAssets.js

@@ -1,241 +0,0 @@
-// TO-DO/next-major-release: remove
-// Remove this workaround if the other workaround config.build.ssrEmitAssets turns out to be reliable.
-//  - Remove this file then revert this commit: https://github.com/vikejs/vike/commit/805a18974f13420a78fcc30fdd676696e405c3ca
-// Workaround to make client-side bundles include the CSS imports living in server-side-only code.
-//  - This is needed for HTML-only pages, and React Server Components.
-//  - We recommend using the debug flag to get an idea of how this plugin works: `$ DEBUG=vike:pluginExtractAssets pnpm exec vike build`. Then have a look at `dist/client/manifest.json` and see how `.page.server.js` entries have zero JavaScript but only CSS.
-//  - This approach supports import path aliases `vite.config.js#resolve.alias` https://vitejs.dev/config/#resolve-alias
-export { pluginExtractAssets };
-export { extractAssetsRE };
-import { assert, assertPosixPath, styleFileRE, createDebugger, isScriptFile, assertUsage, rollupSourceMapRemove, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, } from '../utils.js';
-import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
-import { isAsset } from '../shared/isAsset.js';
-import { getImportStatements } from '../shared/parseEsModule.js';
-import pc from '@brillout/picocolors';
-import { handleAssetsManifest_isFixEnabled } from './build/handleAssetsManifest.js';
-import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
-import { assertV1Design } from '../../shared/assertV1Design.js';
-import { normalizeId } from '../shared/normalizeId.js';
-import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
-import { resolveIncludeAssetsImportedByServer } from '../../runtime/renderPage/getPageAssets/retrievePageAssetsProd.js';
-const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
-const rawRE = /(\?|&)raw(?:&|$)/;
-const urlRE = /(\?|&)url(?:&|$)/;
-const EMPTY_MODULE_ID = 'virtual:vike:empty-module';
-const debug = createDebugger('vike:pluginExtractAssets');
-const filterRolldown = {
-    id: {
-        include: extractAssetsRE,
-    },
-};
-const filterFunction = (id) => extractAssetsRE.test(id);
-function pluginExtractAssets() {
-    let config;
-    let vikeConfig;
-    let isFixEnabled;
-    return [
-        // This plugin removes all JavaScript from server-side only code, so that only CSS imports remains. (And also static files imports e.g. `import logoURL from './logo.svg.js'`).
-        {
-            name: 'vike:pluginExtractAssets:remove-javaScript',
-            // In dev, things just work. (Because Vite's module graph erroneously conflates the Vite server-side importees with the client-side importees.)
-            apply: 'build',
-            enforce: 'post',
-            transform: {
-                filter: filterRolldown,
-                async handler(src, id, options) {
-                    id = normalizeId(id);
-                    assert(filterFunction(id));
-                    if (isFixEnabled) {
-                        // I'm guessing isFixEnabled can only be true when mixing both designs: https://github.com/vikejs/vike/issues/1480
-                        assertV1Design(vikeConfig._pageConfigs, true);
-                        assert(false);
-                    }
-                    const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
-                    assert(includeAssetsImportedByServer);
-                    assert(!isViteServerSide_extraSafe(config, this.environment, options));
-                    const importStatements = await getImportStatements(src);
-                    const moduleNames = getImportedModules(importStatements);
-                    const code = moduleNames.map((moduleName) => `import '${moduleName}';`).join('\n');
-                    debugTransformResult(id, code, importStatements);
-                    return rollupSourceMapRemove(code);
-                },
-            },
-        },
-        // This plugin appends `?extractAssets` to module IDs
-        {
-            name: 'vike:pluginExtractAssets:append-extractAssets-query',
-            apply: 'build',
-            // We ensure this plugin to be run before:
-            //  - rollup's `alias` plugin; https://github.com/rollup/plugins/blob/5363f55aa1933b6c650832b08d6a54cb9ea64539/packages/alias/src/index.ts
-            //  - Vite's `vite:resolve` plugin; https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/resolve.ts#L105
-            enforce: 'pre',
-            resolveId: {
-                async handler(source, importer, options) {
-                    if (isViteServerSide_extraSafe(config, this.environment, options)) {
-                        // When building for the server, there should never be a `?extractAssets` query
-                        assert(!extractAssetsRE.test(source));
-                        assert(importer === undefined || !extractAssetsRE.test(importer));
-                        return;
-                    }
-                    // If there is no `importer` then `module` is an entry.
-                    // We don't need to append `?extractAssets` to entries because they already have `?extractAssets` as Vike appends `?extractAssets` to entries by using `import.meta.glob('/**/*.page.server.js', { as: "extractAssets" })` (see `generateImportGlobs.ts`).
-                    if (!importer) {
-                        return;
-                    }
-                    // We only append `?extractAssets` if the parent module has `?extractAssets`
-                    if (!extractAssetsRE.test(importer)) {
-                        return;
-                    }
-                    const includeAssetsImportedByServer = resolveIncludeAssetsImportedByServer(vikeConfig.config);
-                    assert(includeAssetsImportedByServer);
-                    let resolution = null;
-                    try {
-                        resolution = await this.resolve(source, importer, { skipSelf: true, ...options });
-                    }
-                    catch { }
-                    // Sometimes Rollup fails to resolve. If it fails to resolve, we assume the dependency to be an npm package and we skip it. (I guess Rollup should always be able to resolve local dependencies?)
-                    if (!resolution)
-                        return emptyModule(source, importer);
-                    const { id: file, external } = resolution;
-                    // Nothing is externalized when building for the client-side
-                    assert(external === false);
-                    // We include:
-                    //  - CSS(/LESS/SCSS/...) files
-                    //  - Asset files (`.svg`, `.pdf`, ...)
-                    //  - URL imports (e.g. `import scriptUrl from './script.js?url.js'`)
-                    if (styleFileRE.test(file) || isAsset(file) || urlRE.test(file)) {
-                        debugOperation('INCLUDED', file, importer);
-                        return resolution;
-                    }
-                    // We erase `source` if its file doesn't contain JavaScript
-                    if (!isScriptFile(file)) {
-                        return emptyModule(file, importer);
-                    }
-                    // If the import path resolves to a file in `node_modules/`, we ignore that file:
-                    //  - Direct CSS dependencies are included though, such as `import 'bootstrap/theme/dark.css'`. (Because the above if-branch for CSS files will add the file.)
-                    //  - Loading CSS from a library (living in `node_modules/`) in a non-direct way is unconventional; we can safely not support this case. (I'm not aware of any library that does this.)
-                    assertPosixPath(file);
-                    if (file.includes('/node_modules/')) {
-                        return emptyModule(file, importer);
-                    }
-                    // When a library is symlinked, it lives outside `root`.
-                    assertPosixPath(config.root);
-                    if (!file.startsWith(config.root)) {
-                        return emptyModule(file, importer);
-                    }
-                    return appendExtractAssetsQuery(file, importer);
-                },
-            },
-        },
-        {
-            name: 'vike:pluginExtractAssets-3',
-            apply: 'build',
-            load: {
-                handler(id) {
-                    if (!isVirtualFileId(id))
-                        return undefined;
-                    id = removeVirtualFileIdPrefix(id);
-                    if (id === EMPTY_MODULE_ID) {
-                        return '// Erased by vike:pluginExtractAssets';
-                    }
-                },
-            },
-            config: {
-                handler() {
-                    if (debug.isActivated) {
-                        return { logLevel: 'silent' };
-                    }
-                },
-            },
-        },
-        {
-            name: 'vike:pluginExtractAssets-4',
-            configResolved: {
-                async handler(config_) {
-                    config = config_;
-                    vikeConfig = await getVikeConfigInternal();
-                    isFixEnabled = handleAssetsManifest_isFixEnabled();
-                    if (!isFixEnabled) {
-                        // https://github.com/vikejs/vike/issues/1060
-                        assertUsage(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');
-                    }
-                },
-            },
-        },
-    ];
-}
-function emptyModule(file, importer) {
-    debugOperation('NUKED', file, importer);
-    return addVirtualFileIdPrefix(EMPTY_MODULE_ID);
-}
-function appendExtractAssetsQuery(file, importer) {
-    debugOperation('TRANSFORMED', file, importer);
-    return extractAssetsAddQuery(file);
-}
-function getImportedModules(importStatements) {
-    const moduleNames = importStatements
-        .map(analyzeImport)
-        .filter(({ moduleName, skip }) => {
-        debug(`import ${skip ? 'SKIPPED' : 'INCLUDED'} : ${moduleName}`);
-        return !skip;
-    })
-        .map(({ moduleName }) => {
-        assert(moduleName);
-        return moduleName;
-    });
-    return moduleNames;
-}
-function analyzeImport(importStatement) {
-    const { a: assertion, n } = importStatement;
-    // `n` is `undefined` for dynamic imports with variable, e.g. `import(moduleName)`
-    if (n === undefined)
-        return { moduleName: null, skip: true };
-    const moduleName = n;
-    // Remove assertions such as:
-    //  - `import json from './json.json' assert { type: 'json.js' }`
-    //  - `import('asdf', { assert: { type: 'json' }})
-    if (assertion !== -1) {
-        return { moduleName, skip: true };
-    }
-    // Add imports such as `import logoUrl from './logo.svg?url.js'`
-    if (urlRE.test(moduleName)) {
-        return { moduleName, skip: false };
-    }
-    // Remove imports such as `import logoUrl from './logo.svg?raw.js'`
-    if (rawRE.test(moduleName)) {
-        return { moduleName, skip: true };
-    }
-    /* We shouldn't do this because of aliased imports
-    if (!moduleName.startsWith('.')) {
-      return { moduleName, skip: true }
-    }
-    */
-    // It seems like we need to manually nuke `react`; it seems that what the React runtime `@vitejs/react` injects is not picked up by our `resolveId` hook.
-    if (/^react($|\/)/.test(moduleName)) {
-        return { moduleName, skip: true };
-    }
-    return { moduleName, skip: false };
-}
-function debugOperation(operation, id, importer) {
-    debug(`import ${operation}: ${id} (importer: ${importer})`);
-}
-function stringifyImportStatements(importStatements) {
-    const importsStr = importStatements.map((importStatement) => {
-        const { a: assertion, n } = importStatement;
-        // `n` is `undefined` for dynamic imports with variable, e.g. `import(moduleName)`
-        if (n === undefined)
-            return 'import(...)';
-        let importStr = `import '${n}'`;
-        if (assertion !== -1) {
-            importStr += ' assert { ... }';
-        }
-        return importStr;
-    });
-    return importsStr;
-}
-function debugTransformResult(id, code, importStatements) {
-    const importStatementsStr = stringifyImportStatements(importStatements)
-        .map((s) => pc.cyan(s))
-        .join(', ');
-    debug(`source TRANSFORMED: ${id} (CODE: ${pc.cyan(code.split('\n').join(' '))}, IMPORTS: ${importStatementsStr})`);
-}

package/dist/esm/node/vite/plugins/pluginExtractExportNames.js

@@ -1,112 +0,0 @@
-export { pluginExtractExportNames };
-export { isUsingClientRouter };
-export { extractExportNamesRE };
-import { assert, getFileExtension, createDebugger, getGlobalObject, assertUsage, rollupSourceMapRemove, } from '../utils.js';
-import { getExportNames } from '../shared/parseEsModule.js';
-import { normalizeId } from '../shared/normalizeId.js';
-import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
-const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
-const debug = createDebugger('vike:pluginExtractExportNames');
-const globalObject = getGlobalObject('plugins/pluginExtractExportNames.ts', {});
-const filterRolldown = {
-    id: {
-        include: extractExportNamesRE,
-    },
-};
-const filterFunction = (id) => extractExportNamesRE.test(id);
-function pluginExtractExportNames() {
-    let isDev = false;
-    let config;
-    return [
-        {
-            name: 'vike:pluginExtractExportNames',
-            enforce: 'post',
-            transform: {
-                filter: filterRolldown,
-                async handler(src, id, options) {
-                    id = normalizeId(id);
-                    const isClientSide = !isViteServerSide_extraSafe(config, this.environment, options);
-                    assert(filterFunction(id));
-                    const code = await getExtractExportNamesCode(src, isClientSide, !isDev, id);
-                    debug('id ' + id, ['result:\n' + code.code.trim(), 'src:\n' + src.trim()]);
-                    return code;
-                },
-            },
-            configureServer: {
-                handler() {
-                    isDev = true;
-                },
-            },
-            configResolved: {
-                handler(config_) {
-                    config = config_;
-                },
-            },
-            config: {
-                handler() {
-                    if (debug.isActivated) {
-                        return { logLevel: 'silent' };
-                    }
-                },
-            },
-        },
-    ];
-}
-async function getExtractExportNamesCode(src, isClientSide, isProduction, id) {
-    const { exportNames, wildcardReExports } = await getExportNames(src);
-    if (isClientSide && exportNames.includes('clientRouting')) {
-        globalObject.usesClientRouter = true;
-    }
-    const code = getCode(exportNames, wildcardReExports, isClientSide, isProduction, id);
-    return rollupSourceMapRemove(code);
-}
-function getCode(exportNames, wildcardReExports, isClientSide, isProduction, id) {
-    let code = '';
-    const reExportVarNames = wildcardReExports.map((reExportedModuleName, i) => {
-        const varName = `m${i}`;
-        code += `import { exportNames as ${varName} } from '${addQuery(reExportedModuleName, id)}'`;
-        code += '\n';
-        return varName;
-    });
-    code += '\n';
-    code += `export const exportNames = [${[
-        ...exportNames.map((n) => JSON.stringify(n)),
-        ...reExportVarNames.map((varName) => `...${varName}`),
-    ].join(', ')}];`;
-    code = injectHmr(code, isClientSide, isProduction);
-    return code;
-}
-function addQuery(moduleName, id) {
-    if (moduleName.includes('?')) {
-        assert(moduleName.split('?').length === 2);
-        moduleName = moduleName.replace('?', '?extractExportNames&');
-    }
-    else {
-        const fileExtension = getFileExtension(moduleName);
-        if (!fileExtension) {
-            assert(extractExportNamesRE.test(id));
-            const idReal = id.split('?')[0];
-            assertUsage(false, `Modify the re-export of ${idReal}, see https://github.com/vikejs/vike/issues/864#issuecomment-1537202290`);
-        }
-        moduleName = `${moduleName}?extractExportNames&lang.${fileExtension}`;
-    }
-    return moduleName;
-}
-function injectHmr(code, isClientSide, isProduction) {
-    if (isProduction) {
-        return code;
-    }
-    if (isClientSide) {
-        code += '\n';
-        code += `if (import.meta.hot) import.meta.hot.accept((mod) => { exportNames.length=0; exportNames.push(...mod.exportNames); });`;
-    }
-    else {
-        // Ensure Vite considers the module as `isSelfAccepting`. (Needed because Vite's module graph erroneously conflates the Vite server-side modules with their client-side counterparts.)
-        code += '\n';
-        code += 'if(false){import.meta.hot.accept(()=>{})};';
-    }
-    return code;
-}
-function isUsingClientRouter() {
-    return globalObject.usesClientRouter === true;
-}

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

@@ -1,129 +0,0 @@
-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, '');
-                    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/esm/node/vite/plugins/pluginSetGlobalContext.js

@@ -1,49 +0,0 @@
-export { pluginSetGlobalContext };
-import { setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_isProductionAccordingToVite, } from '../../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/esm/node/vite/plugins/pluginVirtualFiles/debug.js

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

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

@@ -1,60 +0,0 @@
-export { generateVirtualFileGlobalEntry };
-import { generateVirtualFileId } from '../../../shared/virtualFileId.js';
-import { debug } from './debug.js';
-import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
-import { serializeConfigValues } from '../../../../shared/page-configs/serialize/serializeConfigValues.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:vike:server:globalThis-constants';");
-    }
-    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:vike:server:globalThis-constants';\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;
-}