vike 0.4.247-commit-a642bde → 0.4.247-commit-14351e3

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

@@ -0,0 +1,188 @@
+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';
+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:vike:server:globalThis-constants';\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.
+        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;
+}

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

@@ -0,0 +1,230 @@
+export { pluginVirtualFiles };
+import { normalizePath } from 'vite';
+import { generateVirtualFilePageEntry } from './pluginVirtualFiles/generateVirtualFilePageEntry.js';
+import { generateVirtualFileGlobalEntryWithOldDesign } from './pluginVirtualFiles/generateVirtualFileGlobalEntryWithOldDesign.js';
+import { assert, assertPosixPath, isScriptFile, addVirtualFileIdPrefix, isVirtualFileId, removeVirtualFileIdPrefix, escapeRegex, virtualFileIdPrefix1, virtualFileIdPrefix2, } from '../utils.js';
+import { parseVirtualFileId } from '../../../shared-server-node/virtualFileId.js';
+import { reloadVikeConfig, isV1Design, getVikeConfigInternalOptional } from '../shared/resolveVikeConfigInternal.js';
+import pc from '@brillout/picocolors';
+import { logConfigInfo } from '../shared/loggerDev.js';
+import { getFilePathToShowToUserModule } from '../shared/getFilePath.js';
+import { isRunnable, updateUserFiles } from '../../../server/runtime/globalContext.js';
+import { isPlusFile } from '../shared/resolveVikeConfigInternal/crawlPlusFiles.js';
+import { isTemporaryBuildFile } from '../shared/resolveVikeConfigInternal/transpileAndExecuteFile.js';
+import { getVikeConfigError } from '../../../shared-server-node/getVikeConfigError.js';
+const filterRolldown = {
+    id: {
+        include: new RegExp(`^(${escapeRegex(virtualFileIdPrefix1)}|${escapeRegex(virtualFileIdPrefix2)})`),
+    },
+};
+const filterFunction = (id) => isVirtualFileId(id);
+function pluginVirtualFiles() {
+    let config;
+    return [
+        {
+            name: 'vike:pluginVirtualFiles',
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                    // TO-DO/next-major-release: remove
+                    if (!isV1Design())
+                        config.experimental.importGlobRestoreExtension = true;
+                },
+            },
+            resolveId: {
+                filter: filterRolldown,
+                handler(id) {
+                    assert(filterFunction(id));
+                    return addVirtualFileIdPrefix(id);
+                },
+            },
+            handleHotUpdate: {
+                async handler(ctx) {
+                    try {
+                        return await handleHotUpdate(ctx, config);
+                    }
+                    catch (err) {
+                        // Vite swallows errors thrown by handleHotUpdate()
+                        console.error(err);
+                        throw err;
+                    }
+                },
+            },
+            load: {
+                filter: filterRolldown,
+                async handler(id, options) {
+                    assert(filterFunction(id));
+                    id = removeVirtualFileIdPrefix(id);
+                    const isDev = config._isDev;
+                    assert(typeof isDev === 'boolean');
+                    const idParsed = parseVirtualFileId(id);
+                    if (idParsed) {
+                        if (idParsed.type === 'page-entry') {
+                            const code = await generateVirtualFilePageEntry(id, isDev);
+                            return code;
+                        }
+                        if (idParsed.type === 'global-entry') {
+                            const code = await generateVirtualFileGlobalEntryWithOldDesign(id, options, config, this.environment, isDev);
+                            return code;
+                        }
+                    }
+                },
+            },
+            configureServer: {
+                handler(server) {
+                    handleFileAddRemove(server, config);
+                },
+            },
+        },
+    ];
+}
+function handleFileAddRemove(server, config) {
+    server.watcher.prependListener('add', (f) => listener(f, false));
+    server.watcher.prependListener('unlink', (f) => listener(f, true));
+    return;
+    async function listener(file, isRemove) {
+        file = normalizePath(file);
+        if (isTemporaryBuildFile(file))
+            return;
+        const { moduleGraph } = server;
+        const isVikeConfigDep = await isVikeConfigDependency(file, moduleGraph);
+        const reload = () => reloadConfig(file, config, isRemove ? 'removed' : 'created', server);
+        // Config code
+        if (isVikeConfigDep && !isVikeConfigDep.isProcessedByVite) {
+            reload();
+            return;
+        }
+        // New or deleted + file
+        if (isPlusFile(file)) {
+            reload();
+            return;
+        }
+        // Runtime code => let Vite handle it
+        if (isVikeConfigDep && isVikeConfigDep.isProcessedByVite) {
+            assert(existsInViteModuleGraph(file, moduleGraph));
+            return;
+        }
+        // Trick: when importing a file that doesn't exist => we don't know whether `file` is that missing file => we take a leap of faith when the conditions below are met.
+        // - Not sure how reliable that trick is.
+        // - Reloading Vike's config is cheap and file creation/removal is rare => the trick is worth it.
+        // - Reproduction:
+        //   ```bash
+        //   rm someDep.js && sleep 2 && git checkout someDep.js
+        //   ```
+        if (isScriptFile(file) && getVikeConfigError() && !existsInViteModuleGraph(file, moduleGraph)) {
+            reload();
+            return;
+        }
+    }
+}
+function invalidateVikeVirtualFiles(server) {
+    const vikeVirtualFiles = getVikeVirtualFiles(server);
+    vikeVirtualFiles.forEach((mod) => {
+        server.moduleGraph.invalidateModule(mod);
+    });
+}
+// Vite calls its hook handleHotUpdate() whenever *any file* is modified — including files that aren't in Vite's module graph such as `pages/+config.js`
+async function handleHotUpdate(ctx, config) {
+    const { file, server } = ctx;
+    const isVikeConfigDep = await isVikeConfigDependency(ctx.file, ctx.server.moduleGraph);
+    if (isVikeConfigDep) {
+        if (!isVikeConfigDep.isProcessedByVite) {
+            /* Tailwind breaks this assertion, see https://github.com/vikejs/vike/discussions/1330#discussioncomment-7787238
+            const isViteModule = ctx.modules.length > 0
+            assert(!isViteModule)
+            */
+            reloadConfig(file, config, 'modified', server);
+            // Files such as `pages/+config.js` can potentially modify Vike's virtual files.
+            // Triggers a full page reload
+            const vikeVirtualFiles = getVikeVirtualFiles(server);
+            return vikeVirtualFiles;
+        }
+        else {
+            // Ensure we invalidate `file` *before* server.ssrLoadModule() in updateUserFiles()
+            // Vite already invalidates it, but *after* handleHotUpdate() and thus after server.ssrLoadModule()
+            ctx.modules.forEach((mod) => server.moduleGraph.invalidateModule(mod));
+            if (isRunnable(server)) {
+                await updateUserFiles();
+            }
+        }
+    }
+}
+async function isVikeConfigDependency(filePathAbsoluteFilesystem, moduleGraph) {
+    // Non-runtime Vike config files such as `pages/+config.js` which aren't processed by Vite.
+    // - They're missing in Vite's module graph.
+    // - Potentially modifies Vike's virtual files.
+    // - Same for all `pages/+config.js` dependencies.
+    assertPosixPath(filePathAbsoluteFilesystem);
+    const vikeConfigObject = await getVikeConfigInternalOptional();
+    if (vikeConfigObject) {
+        const { _vikeConfigDependencies: vikeConfigDependencies } = vikeConfigObject;
+        vikeConfigDependencies.forEach((f) => assertPosixPath(f));
+        if (vikeConfigDependencies.has(filePathAbsoluteFilesystem))
+            return { isProcessedByVite: false };
+    }
+    // Runtime Vike config files such as +data.js which are processed by Vite.
+    // - They're included in Vite's module graph.
+    // - They never modify Vike's virtual files.
+    // - Same for all `+data.js` dependencies.
+    const importers = getImporters(filePathAbsoluteFilesystem, moduleGraph);
+    const isPlusValueFileDependency = Array.from(importers).some((importer) => importer.file && isPlusFile(importer.file));
+    if (isPlusValueFileDependency)
+        return { isProcessedByVite: true };
+    return null;
+}
+function reloadConfig(filePath, config, op, server) {
+    // Ensure server.ssrLoadModule() loads fresh Vike virtual files (`reloadConfig()` > `updateUserFiles()` > `server.ssrLoadModule()`)
+    invalidateVikeVirtualFiles(server);
+    {
+        const filePathToShowToUserResolved = getFilePathToShowToUserModule(filePath, config);
+        const msg = `${op} ${pc.dim(filePathToShowToUserResolved)}`;
+        logConfigInfo(msg, 'info');
+    }
+    reloadVikeConfig();
+    updateUserFiles();
+}
+function getVikeVirtualFiles(server) {
+    const vikeVirtualFiles = Array.from(server.moduleGraph.urlToModuleMap.keys())
+        .filter((url) => parseVirtualFileId(url))
+        .map((url) => {
+        const mod = server.moduleGraph.urlToModuleMap.get(url);
+        assert(mod);
+        return mod;
+    });
+    return vikeVirtualFiles;
+}
+// Get all transitive importers (including the module itself)
+function getImporters(file, moduleGraph) {
+    const importers = new Set();
+    const mods = moduleGraph.getModulesByFile(file);
+    if (!mods)
+        return importers;
+    for (const mod of mods) {
+        getModuleImporters(mod).forEach((importer) => {
+            if (importer)
+                importers.add(importer);
+        });
+    }
+    return importers;
+}
+function getModuleImporters(mod, seen = new Set()) {
+    if (seen.has(mod))
+        return new Set();
+    seen.add(mod);
+    const importers = new Set();
+    if (mod.id)
+        importers.add(mod);
+    // Traverse through the importers (modules that import this module)
+    for (const importer of mod.importers) {
+        if (importer.id)
+            importers.add(importer);
+        getModuleImporters(importer, seen).forEach((importerTransitive) => {
+            if (importerTransitive)
+                importers.add(importerTransitive);
+        });
+    }
+    return importers;
+}
+function existsInViteModuleGraph(file, moduleGraph) {
+    return !!moduleGraph.getModulesByFile(file);
+}

package/dist/node/vite/shared/addSsrMiddleware.js

@@ -0,0 +1,55 @@
+export { addSsrMiddleware };
+import { renderPageServer } from '../../../server/runtime/renderPageServer.js';
+import { assertWarning } from '../utils.js';
+import pc from '@brillout/picocolors';
+function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled) {
+    middlewares.use(async (req, res, next) => {
+        if (res.headersSent)
+            return next();
+        const url = req.originalUrl || req.url;
+        if (!url)
+            return next();
+        const { headers } = req;
+        const pageContextInit = {
+            urlOriginal: url,
+            headersOriginal: headers,
+        };
+        Object.defineProperty(pageContextInit, 'userAgent', {
+            get() {
+                // TO-DO/next-major-release: assertUsage() instead of assertWarning()
+                assertWarning(false, `${pc.cyan('pageContext.userAgent')} is deprecated: use ${pc.cyan("pageContext.headers['user-agent']")} instead.`, {
+                    showStackTrace: true,
+                    onlyOnce: true,
+                });
+                return headers['user-agent'];
+            },
+            enumerable: false,
+        });
+        let pageContext;
+        try {
+            pageContext = await renderPageServer(pageContextInit);
+        }
+        catch (err) {
+            // Throwing an error in a connect middleware shut downs the server
+            console.error(err);
+            // - next(err) automatically uses buildErrorMessage() (pretty formatting of Rollup errors)
+            //   - But it only works for users using Vite's standalone dev server (it doesn't work for users using Vite's dev middleware)
+            // - We purposely don't use next(err) to align behavior: we use our own/copied implementation of buildErrorMessage() regardless of whether the user uses Vite's dev middleware or Vite's standalone dev server
+            return next();
+        }
+        if (pageContext.httpResponse.statusCode === 404 && isPreview && isPrerenderingEnabled) {
+            // Serve /dist/client/404.html instead
+            return next();
+        }
+        const configHeaders = (isPreview && config?.preview?.headers) || config?.server?.headers;
+        if (configHeaders) {
+            for (const [name, value] of Object.entries(configHeaders))
+                if (value)
+                    res.setHeader(name, value);
+        }
+        const { httpResponse } = pageContext;
+        httpResponse.headers.forEach(([name, value]) => res.setHeader(name, value));
+        res.statusCode = httpResponse.statusCode;
+        httpResponse.pipe(res);
+    });
+}

package/dist/node/vite/shared/findPageFiles.d.ts

@@ -0,0 +1,4 @@
+export { findPageFiles };
+import type { ResolvedConfig } from 'vite';
+import type { FileType } from '../../../shared-server-client/getPageFiles/fileTypes.js';
+declare function findPageFiles(config: ResolvedConfig, fileTypes: FileType[], isDev: boolean): Promise<string[]>;

package/dist/node/vite/shared/getClientEntrySrcDev.js

@@ -0,0 +1,40 @@
+export { getClientEntrySrcDev };
+import { assert, assertPosixPath, toPosixPath, pathJoin, assertIsImportPathNpmPackage, assertIsNotProductionRuntime, requireResolveNpmPackage, requireResolveDistFile, } from '../utils.js';
+assertIsNotProductionRuntime();
+function getClientEntrySrcDev(clientEntry, viteDevServer) {
+    let userRootDir = viteDevServer.config.root;
+    assert(userRootDir);
+    userRootDir = toPosixPath(userRootDir);
+    // The `?import` suffix is needed for MDX to be transpiled:
+    //   - Not transpiled: `/pages/markdown.page.mdx`
+    //   - Transpiled: `/pages/markdown.page.mdx?import`
+    // But `?import` doesn't work with `/@fs/`:
+    //   - Not transpiled: /@fs/home/runner/work/vike/packages/vike/examples/react-full/pages/markdown.page.mdx
+    //   - Not transpiled: /@fs/home/runner/work/vike/packages/vike/examples/react-full/pages/markdown.page.mdx?import
+    if (clientEntry.endsWith('?import')) {
+        assert(clientEntry.startsWith('/'));
+        return clientEntry;
+    }
+    assertPosixPath(clientEntry);
+    let filePath;
+    if (clientEntry.startsWith('/')) {
+        filePath = pathJoin(userRootDir, clientEntry);
+    }
+    else {
+        if (clientEntry.startsWith('@@vike/')) {
+            assert(clientEntry.endsWith('.js'));
+            filePath = requireResolveDistFile(`dist/${clientEntry.replace('@@vike/dist/', '')}`);
+        }
+        else {
+            assertIsImportPathNpmPackage(clientEntry);
+            filePath = requireResolveNpmPackage({ importPathNpmPackage: clientEntry, userRootDir });
+        }
+    }
+    if (!filePath.startsWith('/')) {
+        assert(process.platform === 'win32');
+        filePath = '/' + filePath;
+    }
+    filePath = '/@fs' + filePath;
+    assertPosixPath(filePath);
+    return filePath;
+}