vike 0.4.247 → 0.4.248

package/dist/node/vite/plugins/pluginDev/optimizeDeps.js

@@ -0,0 +1,226 @@
+export { optimizeDeps };
+export { resolveOptimizeDeps };
+import { findPageFiles } from '../../shared/findPageFiles.js';
+import { assert, assertIsImportPathNpmPackage, createDebug, getNpmPackageName, isArray, isFilePathAbsoluteFilesystem, isVirtualFileId, requireResolveOptional, } from '../../utils.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { analyzeClientEntries } from '../build/pluginBuildConfig.js';
+import { virtualFileIdGlobalEntryClientCR, virtualFileIdGlobalEntryClientSR, } from '../../../../shared-server-node/virtualFileId.js';
+import { getFilePathResolved } from '../../shared/getFilePath.js';
+import { getConfigValueSourcesRelevant } from '../pluginVirtualFiles/getConfigValueSourcesRelevant.js';
+const debug = createDebug('vike:optimizeDeps');
+// Add dependencies that cannot be discovered by Vite during the scanning phase
+const LATE_DISCOVERED = [
+    // Workaround for https://github.com/vitejs/vite-plugin-react/issues/650
+    // - The issue was closed as completed with https://github.com/vitejs/vite/pull/20495 but it doesn't fix the issue and the workaround is still needed.
+    // - TO-DO/eventually: try removing the workaround and see if the CI fails (at test/@cloudflare_vite-plugin/) — maybe the issue will get fixed at some point.
+    'react/jsx-dev-runtime',
+    // Workaround for https://github.com/vikejs/vike/issues/2823#issuecomment-3514325487
+    '@compiled/react/runtime',
+];
+const optimizeDeps = {
+    optimizeDeps: {
+        exclude: [
+            // We must exclude Vike's client runtime so it can import virtual modules
+            'vike/client',
+            'vike/client/router',
+        ],
+        include: [
+            // Avoid:
+            // ```
+            // 9:28:58 AM [vite] ✨ new dependencies optimized: @brillout/json-serializer/parse
+            // 9:28:58 AM [vite] ✨ optimized dependencies changed. reloading
+            // ```
+            'vike > @brillout/json-serializer/parse',
+            'vike > @brillout/json-serializer/stringify',
+            'vike > @brillout/picocolors',
+        ],
+    },
+    ssr: {
+        optimizeDeps: {
+            exclude: [
+                '@brillout/import',
+                '@brillout/json-serializer',
+                '@brillout/picocolors',
+                '@brillout/vite-plugin-server-entry',
+                'vike',
+            ],
+        },
+    },
+};
+// Populate optimizeDeps with dynamic entries:
+// - User's + files (i.e. Vike entries)
+// - Late discovered dependencies (if they exist)
+// - Make server environments inherit from ssr.optimizeDeps (it isn't the case by default)
+async function resolveOptimizeDeps(config) {
+    const vikeConfig = await getVikeConfigInternal();
+    const { _pageConfigs: pageConfigs } = vikeConfig;
+    // Retrieve user's + files (i.e. Vike entries)
+    const { entriesClient, entriesServer, includeClient, includeServer } = await getPageDeps(config, pageConfigs);
+    // Add late discovered dependencies, if they exist
+    LATE_DISCOVERED.forEach((dep) => {
+        const userRootDir = config.root;
+        const resolved = requireResolveOptional({ importPath: dep, userRootDir, importerFilePath: null });
+        const resolvedInsideRepo = resolved && resolved.startsWith(userRootDir);
+        if (resolvedInsideRepo) {
+            // We add `dep` only if `resolvedInsideRepo === true` otherwise Vite logs a warning like the following.
+            // - ```console
+            //   [11:22:42.464][/examples/vue-full][npm run dev][stderr] Failed to resolve dependency: react/jsx-dev-runtime, present in client 'optimizeDeps.include'
+            //   ```
+            // - ```console
+            //   [12:24:53.225][/test/@cloudflare_vite-plugin/test-dev.test.ts][npm run dev][stderr] Failed to resolve dependency: @compiled/react/runtime, present in ssr 'optimizeDeps.include'
+            //   ```
+            includeClient.push(dep);
+            includeServer.push(dep);
+        }
+        else if (config.optimizeDeps.include?.includes(dep)) {
+            // Monorepo => always `resolvedInsideRepo === false` — we use this other approach to workaround missing 'react/jsx-dev-runtime'
+            includeServer.push(dep);
+        }
+    });
+    // Set optimizeDeps (client-side)
+    config.optimizeDeps.include = add(config.optimizeDeps.include, includeClient);
+    config.optimizeDeps.entries = add(config.optimizeDeps.entries, entriesClient);
+    // Set optimizeDeps (server-side)
+    for (const envName in config.environments) {
+        const env = config.environments[envName];
+        if (env.consumer === 'server' && env.optimizeDeps.noDiscovery === false) {
+            env.optimizeDeps.include = add(env.optimizeDeps.include, includeServer);
+            env.optimizeDeps.entries = add(env.optimizeDeps.entries, entriesServer);
+        }
+    }
+    // Debug
+    if (debug.isActivated)
+        debug('optimizeDeps', {
+            'config.optimizeDeps.entries': config.optimizeDeps.entries,
+            'config.optimizeDeps.include': config.optimizeDeps.include,
+            'config.optimizeDeps.exclude': config.optimizeDeps.exclude,
+            // @ts-ignore Vite doesn't seem to support ssr.optimizeDeps.entries (vite@7.0.6, July 2025)
+            'config.ssr.optimizeDeps.entries': config.ssr.optimizeDeps.entries,
+            'config.ssr.optimizeDeps.include': config.ssr.optimizeDeps.include,
+            'config.ssr.optimizeDeps.exclude': config.ssr.optimizeDeps.exclude,
+        });
+}
+async function getPageDeps(config, pageConfigs) {
+    let entriesClient = [];
+    let entriesServer = [];
+    let includeClient = [];
+    let includeServer = [];
+    const addEntry = (e, isForClientSide, definedAt) => {
+        assert(e);
+        // optimizeDeps.entries expects filesystem absolute paths
+        assert(isVirtualFileId(e) || isFilePathAbsoluteFilesystem(e));
+        if (isExcluded(e, isForClientSide, definedAt))
+            return;
+        if (isForClientSide) {
+            entriesClient.push(e);
+        }
+        else {
+            entriesServer.push(e);
+        }
+    };
+    const addInclude = (e, isForClientSide, definedAt) => {
+        assert(e);
+        // optimizeDeps.include expects npm packages
+        assert(!e.startsWith('/'));
+        // Shouldn't be a path alias, as path aliases would need to be added to optimizeDeps.entries instead of optimizeDeps.include
+        assertIsImportPathNpmPackage(e);
+        if (isExcluded(e, isForClientSide, definedAt))
+            return;
+        if (isForClientSide) {
+            includeClient.push(e);
+        }
+        else {
+            includeServer.push(e);
+        }
+    };
+    const isExcluded = (e, isForClientSide, definedAt) => {
+        const exclude = isForClientSide ? config.optimizeDeps.exclude : config.ssr.optimizeDeps.exclude;
+        if (!exclude)
+            return false;
+        if (definedAt?.importPathAbsolute) {
+            const npmPackageName = getNpmPackageName(definedAt.importPathAbsolute);
+            if (npmPackageName && exclude.includes(npmPackageName))
+                return true;
+        }
+        return exclude.includes(e);
+    };
+    // V1 design
+    {
+        ;
+        [true, false].forEach((isForClientSide) => {
+            pageConfigs.forEach((pageConfig) => {
+                Object.entries(pageConfig.configValueSources).forEach(([configName]) => {
+                    const runtimeEnv = {
+                        isForClientSide,
+                        isDev: true,
+                        // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
+                        isClientRouting: true,
+                    };
+                    const sourcesRelevant = getConfigValueSourcesRelevant(configName, runtimeEnv, pageConfig);
+                    sourcesRelevant.forEach((configValueSource) => {
+                        if (!configValueSource.valueIsLoadedWithImport && !configValueSource.valueIsFilePath)
+                            return;
+                        const { definedAt } = configValueSource;
+                        if (definedAt.definedBy)
+                            return;
+                        if (definedAt.filePathAbsoluteUserRootDir !== null) {
+                            addEntry(
+                            // optimizeDeps.entries expects filesystem absolute paths
+                            definedAt.filePathAbsoluteFilesystem, isForClientSide, definedAt);
+                        }
+                        else {
+                            addInclude(
+                            // optimizeDeps.include expects npm packages
+                            definedAt.importPathAbsolute, isForClientSide, definedAt);
+                        }
+                    });
+                });
+            });
+        });
+    }
+    // V0.4 design
+    {
+        const pageFiles = await findPageFiles(config, ['.page', '.page.client'], true);
+        const userRootDir = config.root;
+        pageFiles.forEach((filePathAbsoluteUserRootDir) => {
+            const entry = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
+            const { filePathAbsoluteFilesystem } = entry;
+            addEntry(filePathAbsoluteFilesystem, true);
+        });
+    }
+    // Add virtual files.
+    // - This doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
+    //   - Should we make it work? E.g. by creating a temporary file at node_modules/.vike/virtualFiles.js
+    //   - Or should we remove it? And make sure getPageDeps() also works for aliased import paths
+    //     - If we do, then we need to adjust include/entries (maybe by making include === entries -> will Vite complain?)
+    {
+        const { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
+        Object.values(clientEntries).forEach((e) => addEntry(e, true));
+        if (hasClientRouting)
+            addEntry(virtualFileIdGlobalEntryClientCR, true);
+        if (hasServerRouting)
+            addEntry(virtualFileIdGlobalEntryClientSR, true);
+    }
+    entriesClient = entriesClient;
+    entriesServer = entriesServer;
+    includeClient = includeClient;
+    includeServer = includeServer;
+    return {
+        entriesClient,
+        entriesServer,
+        includeClient,
+        includeServer,
+    };
+}
+function add(input, listAddendum) {
+    const list = !input ? [] : isArray(input) ? unique(input) : [input];
+    listAddendum.forEach((e) => {
+        if (!list.includes(e))
+            list.push(e);
+    });
+    return list;
+}
+function unique(arr) {
+    const arrUnique = Array.from(new Set(arr));
+    return arr.length !== arrUnique.length ? arrUnique : arr;
+}

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

@@ -0,0 +1,5 @@
+export { pluginDev };
+export { logDockerHint };
+import { type Plugin, type ResolvedConfig } from 'vite';
+declare function pluginDev(): Plugin[];
+declare function logDockerHint(configHost: ResolvedConfig['server']['host']): void;

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

@@ -0,0 +1,73 @@
+export { pluginDev };
+export { logDockerHint };
+import { optimizeDeps, resolveOptimizeDeps } from './pluginDev/optimizeDeps.js';
+import { determineFsAllowList } from './pluginDev/determineFsAllowList.js';
+import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
+import { applyDev, assertWarning, isDocker, isDebugError } from '../utils.js';
+import { interceptViteLogs } from '../shared/loggerVite.js';
+import pc from '@brillout/picocolors';
+import { swallowViteLogConnected, swallowViteLogConnected_clean } from '../shared/loggerVite.js';
+function pluginDev() {
+    let config;
+    return [
+        {
+            name: 'vike:pluginDev',
+            apply: applyDev,
+            config: {
+                handler() {
+                    return {
+                        appType: 'custom',
+                        ...optimizeDeps,
+                    };
+                },
+            },
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                    await resolveOptimizeDeps(config);
+                    await determineFsAllowList(config);
+                    interceptViteLogs(config);
+                    logDockerHint(config.server.host);
+                },
+            },
+        },
+        {
+            name: 'vike:pluginDev:post',
+            apply: applyDev,
+            // The SSR middleware should be last middleware
+            enforce: 'post',
+            configureServer: {
+                order: 'post',
+                handler(server) {
+                    swallowViteLogConnected_clean(); // If inside a configureServer() `pre` hook => too early
+                    const hasHonoViteDevServer = !!config.plugins.find((p) => p.name === '@hono/vite-dev-server');
+                    if (config.server.middlewareMode || hasHonoViteDevServer)
+                        return;
+                    return () => {
+                        addSsrMiddleware(server.middlewares, config, false, null);
+                    };
+                },
+            },
+            // Setting `configResolved.clearScreen = false` doesn't work
+            config: {
+                order: 'post',
+                handler() {
+                    if (isDebugError()) {
+                        return { clearScreen: false };
+                    }
+                },
+            },
+            configResolved: {
+                order: 'post',
+                handler() {
+                    swallowViteLogConnected();
+                },
+            },
+        },
+    ];
+}
+function logDockerHint(configHost) {
+    if (isDocker()) {
+        assertWarning(configHost, `Your app seems to be running inside a Docker or Podman container but ${pc.cyan('--host')} isn't set which means that your Vike app won't be accessible from outside the container, see https://vike.dev/docker`, { onlyOnce: true });
+    }
+}

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

@@ -0,0 +1,241 @@
+// 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, createDebug, isScriptFile, assertUsage, rollupSourceMapRemove, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, } from '../utils.js';
+import { extractAssetsAddQuery } from '../../../shared-server-node/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-server-node/assertV1Design.js';
+import { normalizeId } from '../shared/normalizeId.js';
+import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
+import { resolveIncludeAssetsImportedByServer } from '../../../server/runtime/renderPageServer/getPageAssets/retrievePageAssetsProd.js';
+const extractAssetsRE = /(\?|&)extractAssets(?:&|$)/;
+const rawRE = /(\?|&)raw(?:&|$)/;
+const urlRE = /(\?|&)url(?:&|$)/;
+const EMPTY_MODULE_ID = 'virtual:vike:empty-module';
+const debug = createDebug('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/node/vite/plugins/pluginExtractExportNames.js

@@ -0,0 +1,112 @@
+export { pluginExtractExportNames };
+export { isUsingClientRouter };
+export { extractExportNamesRE };
+import { assert, getFileExtension, createDebug, 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 = createDebug('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;
+}