vike 0.4.247-commit-903de25 → 0.4.247-commit-c3d567b

package/dist/node/vite/plugins/build/pluginBuildApp.js

@@ -0,0 +1,174 @@
+export { pluginBuildApp };
+import { runPrerender_forceExit } from '../../../prerender/runPrerenderEntry.js';
+import { resolveOutDir } from '../../shared/getOutDirs.js';
+import { assert, assertWarning, getGlobalObject, onSetupBuild } from '../../utils.js';
+import { isPrerenderAutoRunEnabled, wasPrerenderRun } from '../../../prerender/context.js';
+import { isViteCli, getViteConfigForBuildFromCli } from '../../shared/isViteCli.js';
+import pc from '@brillout/picocolors';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { isVikeCliOrApi } from '../../../../shared-server-node/api-context.js';
+import { handleAssetsManifest, handleAssetsManifest_assertUsageCssTarget } from './handleAssetsManifest.js';
+import { isViteServerSide_onlySsrEnv } from '../../shared/isViteServerSide.js';
+import { runPrerenderFromAutoRun } from '../../../prerender/runPrerenderEntry.js';
+import { getManifestFilePathRelative } from '../../shared/getManifestFilePathRelative.js';
+import { logErrorServer } from '../../../../server/runtime/logErrorServer.js';
+const globalObject = getGlobalObject('build/pluginBuildApp.ts', {
+    forceExit: false,
+});
+function pluginBuildApp() {
+    let config;
+    return [
+        {
+            name: 'vike:build:pluginBuildApp:pre',
+            apply: 'build',
+            enforce: 'pre',
+            config: {
+                order: 'pre',
+                handler(_config) {
+                    return {
+                        builder: {
+                            // Can be overridden by another plugin e.g vike-vercel https://github.com/vikejs/vike/pull/2184#issuecomment-2659425195
+                            async buildApp(builder) {
+                                assert(builder.environments.client);
+                                assert(builder.environments.ssr);
+                                await builder.build(builder.environments.client);
+                                await builder.build(builder.environments.ssr);
+                                if (isPrerenderForceExit()) {
+                                    runPrerender_forceExit();
+                                    assert(false);
+                                }
+                            },
+                        },
+                    };
+                },
+            },
+        },
+        {
+            name: 'vike:build:pluginBuildApp',
+            apply: 'build',
+            config: {
+                handler(config) {
+                    return {
+                        environments: {
+                            ssr: {
+                                consumer: 'server',
+                                build: {
+                                    outDir: resolveOutDir(config, true),
+                                    ssr: true,
+                                },
+                            },
+                            client: {
+                                consumer: 'client',
+                                build: {
+                                    outDir: resolveOutDir(config, false),
+                                    copyPublicDir: true,
+                                    ssr: false,
+                                },
+                            },
+                        },
+                    };
+                },
+            },
+        },
+        {
+            name: 'vike:build:pluginBuildApp:autoFullBuild:pre',
+            apply: 'build',
+            enforce: 'pre',
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                    await abortViteBuildSsr();
+                },
+            },
+            // TO-DO/eventually: stop using this writeBundle() hack and, instead, use the buildApp() implementation above.
+            // - Could it cause issues if a tool uses the writeBundle() hack together with getVikeConfig() ?
+            writeBundle: {
+                /* We can't use this because it breaks Vite's logging. TO-DO/eventually: try again with latest Vite version.
+                sequential: true,
+                order: 'pre',
+                */
+                async handler(options, bundle) {
+                    try {
+                        handleAssetsManifest_assertUsageCssTarget(config, this.environment);
+                        await handleAssetsManifest(config, this.environment, options, bundle);
+                        await triggerPrerendering(config, this.environment, bundle);
+                    }
+                    catch (err) {
+                        // We use try-catch also because:
+                        // - Vite/Rollup swallows errors thrown inside the writeBundle() hook. (It doesn't swallow errors thrown inside the first writeBundle() hook while building the client-side, but it does swallow errors thrown inside the second writeBundle() while building the server-side triggered after Vike calls Vite's `build()` API.)
+                        // - Avoid Rollup prefixing the error with [vike:build:pluginBuildApp], see for example https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
+                        logErrorServer(err, null);
+                        process.exit(1);
+                    }
+                },
+            },
+        },
+        {
+            name: 'vike:build:pluginBuildApp:autoFullBuild:post',
+            apply: 'build',
+            enforce: 'post',
+            closeBundle: {
+                sequential: true,
+                order: 'post',
+                handler() {
+                    onSetupBuild();
+                },
+            },
+        },
+    ];
+}
+async function triggerPrerendering(config, viteEnv, bundle) {
+    const vikeConfig = await getVikeConfigInternal();
+    if (!isViteServerSide_onlySsrEnv(config, viteEnv))
+        return;
+    if (isDisabled(vikeConfig))
+        return;
+    // Workaround for @vitejs/plugin-legacy
+    //  - The legacy plugin triggers its own Rollup build for the client-side.
+    //  - The legacy plugin doesn't generate a manifest => we can use that to detect the legacy plugin build.
+    //  - Issue & reproduction: https://github.com/vikejs/vike/issues/1154#issuecomment-1965954636
+    if (!bundle[getManifestFilePathRelative(config.build.manifest)])
+        return;
+    if (!isPrerenderAutoRunEnabled(vikeConfig))
+        return;
+    const configInline = getFullBuildInlineConfig(config);
+    const res = await runPrerenderFromAutoRun(configInline);
+    globalObject.forceExit = res.forceExit;
+    assert(wasPrerenderRun());
+}
+async function abortViteBuildSsr() {
+    const vikeConfig = await getVikeConfigInternal();
+    if (vikeConfig.config.disableAutoFullBuild !== true && isViteCli() && getViteConfigForBuildFromCli()?.build.ssr) {
+        assertWarning(false, `The CLI call ${pc.cyan('$ vite build --ssr')} is superfluous since ${pc.cyan('$ vite build')} also builds the server-side. If you want two separate build steps then use https://vike.dev/disableAutoFullBuild or use Vite's ${pc.cyan('build()')} API.`, { onlyOnce: true });
+        process.exit(0);
+    }
+}
+function isDisabled(vikeConfig) {
+    const { disableAutoFullBuild } = vikeConfig.config;
+    if (disableAutoFullBuild === undefined || disableAutoFullBuild === 'prerender') {
+        const isUserUsingViteApi = !isViteCli() && !isVikeCliOrApi();
+        return isUserUsingViteApi;
+    }
+    else {
+        return disableAutoFullBuild;
+    }
+}
+function isPrerenderForceExit() {
+    return globalObject.forceExit;
+}
+function getFullBuildInlineConfig(config) {
+    const configFromCli = !isViteCli() ? null : getViteConfigForBuildFromCli();
+    if (config._viteConfigFromUserResolved) {
+        return config._viteConfigFromUserResolved;
+    }
+    else {
+        return {
+            ...configFromCli,
+            configFile: configFromCli?.configFile || config.configFile,
+            root: config.root,
+            build: {
+                ...configFromCli?.build,
+            },
+        };
+    }
+}

package/dist/node/vite/plugins/build/pluginBuildConfig.js

@@ -0,0 +1,219 @@
+export { pluginBuildConfig };
+export { assertRollupInput };
+export { analyzeClientEntries };
+import { assert, addOnBeforeAssertLog, removeFileExtension, unique, assertUsage, injectRollupInputs, normalizeRollupInput, onSetupBuild, assertIsImportPathNpmPackage, requireResolveDistFile, } from '../../utils.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { findPageFiles } from '../../shared/findPageFiles.js';
+import { generateVirtualFileId } from '../../../../shared-server-node/virtualFileId.js';
+import { extractAssetsAddQuery } from '../../../../shared-server-node/extractAssetsQuery.js';
+import { prependEntriesDir } from '../../../../shared-server-node/prependEntriesDir.js';
+import { getFilePathResolved } from '../../shared/getFilePath.js';
+import { getConfigValueBuildTime } from '../../../../shared-server-client/page-configs/getConfigValueBuildTime.js';
+import { isViteServerSide_viteEnvOptional } from '../../shared/isViteServerSide.js';
+import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, handleAssetsManifest_alignCssTarget, } from './handleAssetsManifest.js';
+import { resolveIncludeAssetsImportedByServer } from '../../../../server/runtime/renderPageServer/getPageAssets/retrievePageAssetsProd.js';
+function pluginBuildConfig() {
+    return [
+        {
+            name: 'vike:build:pluginBuildConfig:post2',
+            apply: 'build',
+            enforce: 'post',
+            configResolved: {
+                order: 'post',
+                async handler(config) {
+                    handleAssetsManifest_alignCssTarget(config);
+                    onSetupBuild();
+                    assertRollupInput(config);
+                    const entries = await getEntries(config);
+                    assert(Object.keys(entries).length > 0);
+                    config.build.rollupOptions.input = injectRollupInputs(entries, config);
+                    addLogHook();
+                    handleAssetsManifest_assertUsageCssCodeSplit(config);
+                },
+            },
+            config: {
+                order: 'post',
+                async handler() {
+                    onSetupBuild();
+                    const build = await handleAssetsManifest_getBuildConfig();
+                    return { build };
+                },
+            },
+            buildStart: {
+                handler() {
+                    onSetupBuild();
+                },
+            },
+        },
+    ];
+}
+async function getEntries(config) {
+    const vikeConfig = await getVikeConfigInternal();
+    const { _pageConfigs: pageConfigs } = vikeConfig;
+    // TO-DO/next-major-release: remove
+    const pageFileEntries = await getPageFileEntries(config, resolveIncludeAssetsImportedByServer(vikeConfig.config));
+    assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
+    if (isViteServerSide_viteEnvOptional(config)) {
+        const pageEntries = getPageEntries(pageConfigs);
+        const entries = {
+            ...pageFileEntries,
+            // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
+            ...pageEntries,
+        };
+        return entries;
+    }
+    else {
+        let { hasClientRouting, hasServerRouting, clientEntries } = analyzeClientEntries(pageConfigs, config);
+        if (Object.entries(pageFileEntries).length > 0) {
+            hasClientRouting = true;
+            hasServerRouting = true;
+        }
+        const entries = {
+            ...clientEntries,
+            ...pageFileEntries,
+        };
+        const clientRoutingEntry = requireResolveDistFile('dist/client/runtime-client-routing/entry.js');
+        const serverRoutingEntry = requireResolveDistFile('dist/client/runtime-server-routing/entry.js');
+        if (hasClientRouting) {
+            entries['entries/entry-client-routing'] = clientRoutingEntry;
+        }
+        if (hasServerRouting) {
+            entries['entries/entry-server-routing'] = serverRoutingEntry;
+        }
+        return entries;
+    }
+}
+function getPageEntries(pageConfigs) {
+    const pageEntries = {};
+    pageConfigs.forEach((pageConfig) => {
+        const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, false);
+        pageEntries[entryName] = entryTarget;
+    });
+    return pageEntries;
+}
+function analyzeClientEntries(pageConfigs, config) {
+    let hasClientRouting = false;
+    let hasServerRouting = false;
+    let clientEntries = {};
+    let clientEntryList = [];
+    pageConfigs.forEach((pageConfig) => {
+        const configValue = getConfigValueBuildTime(pageConfig, 'clientRouting', 'boolean');
+        if (configValue?.value) {
+            hasClientRouting = true;
+        }
+        else {
+            hasServerRouting = true;
+        }
+        {
+            // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
+            const { entryName, entryTarget } = getEntryFromPageConfig(pageConfig, true);
+            clientEntries[entryName] = entryTarget;
+        }
+        {
+            const clientEntry = getConfigValueBuildTime(pageConfig, 'client', 'string')?.value ?? null;
+            if (clientEntry) {
+                clientEntryList.push(clientEntry);
+            }
+        }
+    });
+    clientEntryList = unique(clientEntryList);
+    clientEntryList.forEach((clientEntry) => {
+        const { entryName, entryTarget } = getEntryFromClientEntry(clientEntry, config);
+        clientEntries[entryName] = entryTarget;
+    });
+    return { hasClientRouting, hasServerRouting, clientEntries };
+}
+// Ensure Rollup creates entries for each page file, see https://github.com/vikejs/vike/issues/350
+// (Otherwise the page files may be missing in the client manifest.json)
+async function getPageFileEntries(config, includeAssetsImportedByServer) {
+    const isForClientSide = !isViteServerSide_viteEnvOptional(config);
+    const fileTypes = isForClientSide ? ['.page', '.page.client'] : ['.page', '.page.server'];
+    if (isForClientSide && includeAssetsImportedByServer) {
+        fileTypes.push('.page.server');
+    }
+    let pageFiles = await findPageFiles(config, fileTypes, false);
+    const pageFileEntries = {};
+    pageFiles = unique(pageFiles);
+    pageFiles.forEach((pageFile) => {
+        let addExtractAssetsQuery = false;
+        if (isForClientSide && pageFile.includes('.page.server.')) {
+            assert(includeAssetsImportedByServer);
+            addExtractAssetsQuery = true;
+        }
+        const { entryName, entryTarget } = getEntryFromClientEntry(pageFile, config, addExtractAssetsQuery);
+        pageFileEntries[entryName] = entryTarget;
+    });
+    return pageFileEntries;
+}
+function getEntryFromClientEntry(clientEntry, config, addExtractAssetsQuery) {
+    if (!clientEntry.startsWith('/')) {
+        assertIsImportPathNpmPackage(clientEntry);
+        const entryTarget = clientEntry;
+        const entryName = prependEntriesDir(clientEntry);
+        return { entryName, entryTarget };
+    }
+    const filePathAbsoluteUserRootDir = clientEntry;
+    assert(filePathAbsoluteUserRootDir.startsWith('/'));
+    const filePath = getFilePathResolved({
+        filePathAbsoluteUserRootDir,
+        userRootDir: config.root,
+    });
+    let entryTarget = filePath.filePathAbsoluteFilesystem;
+    if (addExtractAssetsQuery)
+        entryTarget = extractAssetsAddQuery(entryTarget);
+    let entryName = filePathAbsoluteUserRootDir;
+    if (addExtractAssetsQuery)
+        entryName = extractAssetsAddQuery(entryName);
+    entryName = removeFileExtension(entryName);
+    entryName = prependEntriesDir(entryName);
+    return { entryName, entryTarget };
+}
+function getEntryFromPageConfig(pageConfig, isForClientSide) {
+    let { pageId } = pageConfig;
+    const entryTarget = generateVirtualFileId({ type: 'page-entry', pageId, isForClientSide });
+    let entryName = pageId;
+    // Avoid:
+    // ```
+    // dist/client/assets/entries/.Dp9wM6PK.js
+    // dist/server/entries/.mjs
+    // ```
+    if (entryName === '/')
+        entryName = 'root';
+    entryName = prependEntriesDir(entryName);
+    assert(!entryName.endsWith('/'));
+    return { entryName, entryTarget };
+}
+function addLogHook() {
+    const tty = process.stdout.isTTY && !process.env.CI; // Equals https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts#L27
+    if (!tty)
+        return;
+    let lastLog = null;
+    ['stdout', 'stderr'].forEach((stdName) => {
+        var methodOriginal = process[stdName].write;
+        process[stdName].write = function (...args) {
+            lastLog = String(args[0]);
+            return methodOriginal.apply(process[stdName], args);
+        };
+    });
+    // Exhaustive list extracted from writeLine() calls at https://github.com/vitejs/vite/blob/193d55c7b9cbfec5b79ebfca276d4a721e7de14d/packages/vite/src/node/plugins/reporter.ts
+    // prettier-ignore
+    // biome-ignore format:
+    const viteTransientLogs = [
+        'transforming (',
+        'rendering chunks (',
+        'computing gzip size ('
+    ];
+    addOnBeforeAssertLog(() => {
+        // Using viteTransientLogs is very conservative as clearing the current line is low risk. (We can assume that important messages, such as errors, include a trailing new line. Usually, only transient messages have no trailing new lines.)
+        if (viteTransientLogs.some((s) => lastLog?.startsWith(s))) {
+            process.stdout.clearLine(0);
+            process.stdout.cursorTo(0);
+        }
+    });
+}
+function assertRollupInput(config) {
+    const userInputs = normalizeRollupInput(config.build.rollupOptions.input);
+    const htmlInputs = Object.values(userInputs).filter((entry) => entry.endsWith('.html') || entry.endsWith('.htm'));
+    const htmlInput = htmlInputs[0];
+    assertUsage(htmlInput === undefined, `The entry ${htmlInput} of config build.rollupOptions.input is an HTML entry which is forbidden when using Vike, instead follow https://vike.dev/add`);
+}

package/dist/node/vite/plugins/build/pluginModuleBanner.js

@@ -0,0 +1,49 @@
+export { pluginModuleBanner };
+import { assert, removeVirtualFileIdPrefix } from '../../utils.js';
+import { getMagicString } from '../../shared/getMagicString.js';
+// Rollup's banner feature doesn't work with Vite: https://github.com/vitejs/vite/issues/8412
+// But, anyways, we want to prepend the banner at the beginning of each module, not at the beginning of each file (I believe that's what Rollup's banner feature does).
+function pluginModuleBanner() {
+    let config;
+    return [
+        {
+            name: 'vike:build:pluginModuleBanner',
+            enforce: 'post',
+            apply: 'build',
+            applyToEnvironment(environment) {
+                const { config } = environment;
+                const { consumer } = config;
+                const { minify } = config.build;
+                assert(minify === false || minify, { minify, consumer });
+                return !minify;
+            },
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
+            },
+            transform: {
+                order: 'post',
+                /* Using a Rolldown hook filter doesn't make sense here: we apply this transformer to each module. But we use applyToEnvironment() to conditionally apply this plugin.
+                filter: {},
+                */
+                handler(code, id) {
+                    const { minify } = this.environment.config.build;
+                    assert(minify === false, { minify });
+                    if (id.startsWith('\0'))
+                        id = id;
+                    id = removeVirtualFileIdPrefix(id);
+                    if (id.startsWith(config.root))
+                        id = id.slice(config.root.length + 1);
+                    id = id.replaceAll('*/', '*\\/'); // https://github.com/vikejs/vike/issues/2377
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    // Use legal comment so that esbuild doesn't remove it.
+                    // - Terser still removes the comment, but I guess users use terser to minify JavaScript so I guess it's a good thing that comment is removed.
+                    // - https://esbuild.github.io/api/#legal-comments
+                    magicString.prepend(`/*! ${id} [vike:pluginModuleBanner] */\n`);
+                    return getMagicStringResult();
+                },
+            },
+        },
+    ];
+}

package/dist/node/vite/plugins/build/pluginProdBuildEntry.js

@@ -0,0 +1,106 @@
+export { pluginProdBuildEntry };
+export { set_macro_ASSETS_MANIFEST };
+import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
+import { virtualFileIdGlobalEntryServer } from '../../../../shared-server-node/virtualFileId.js';
+import { assert, PROJECT_VERSION, requireResolveDistFile } from '../../utils.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { isUsingClientRouter } from '../pluginExtractExportNames.js';
+import { assertBuildInfo } from '../../../../server/runtime/globalContext.js';
+import { getOutDirs } from '../../shared/getOutDirs.js';
+import { getViteConfigRuntime } from '../../shared/getViteConfigRuntime.js';
+const ASSETS_MANIFEST = '__VITE_ASSETS_MANIFEST__';
+function pluginProdBuildEntry() {
+    let config;
+    return [
+        {
+            name: 'vike:build:pluginProdBuildEntry',
+            apply: 'build',
+            enforce: 'post',
+            configResolved: {
+                async handler(config_) {
+                    config = config_;
+                },
+            },
+        },
+        ...serverProductionEntryPlugin({
+            getServerProductionEntry: () => {
+                return getServerProductionEntryCode(config);
+            },
+            libraryName: 'Vike',
+        }),
+    ];
+}
+function getServerProductionEntryCode(config) {
+    const importPath = getImportPath(config);
+    const buildInfo = {
+        versionAtBuildTime: PROJECT_VERSION,
+        usesClientRouter: isUsingClientRouter(), // TO-DO/next-major-release: remove
+        viteConfigRuntime: getViteConfigRuntime(config),
+    };
+    assertBuildInfo(buildInfo);
+    // After the old design is removed, let's maybe simplify and move everything into a single virtual module
+    const importerCode = [
+        `  import { setGlobalContext_prodBuildEntry } from '${importPath}';`,
+        `  import * as virtualFileExportsGlobalEntry from '${virtualFileIdGlobalEntryServer}';`,
+        `  {`,
+        // Because of a Rollup bug, we have to assign ASSETS_MANIFEST to a variable before passing it to setGlobalContext_prodBuildEntry()
+        // - This workaround doesn't work: https://github.com/vikejs/vike/commit/d5f3a4f7aae5a8bc44192e6cbb2bcb9007be188d
+        `    const assetsManifest = ${ASSETS_MANIFEST};`,
+        `    const buildInfo = ${JSON.stringify(buildInfo, null, 2)};`,
+        '    setGlobalContext_prodBuildEntry({',
+        `      virtualFileExportsGlobalEntry,`,
+        `      assetsManifest,`,
+        `      buildInfo,`,
+        '    });',
+        `  }`,
+        '',
+    ].join('\n');
+    return importerCode;
+}
+// Set the value of the ASSETS_MANIFEST constant inside dist/server/entry.js (or dist/server/index.js)
+async function set_macro_ASSETS_MANIFEST(assetsJsonFilePath, bundle, outDir) {
+    assert(outDir);
+    const chunkPath = find_ASSETS_MANIFEST(bundle);
+    // Some server builds don't contain __VITE_ASSETS_MANIFEST__ such as dist/rsc/ from vike-react-rsc
+    if (!chunkPath) {
+        const noop = true; // no operation
+        return noop;
+    }
+    assert(assetsJsonFilePath);
+    const chunkFilePath = path.join(outDir, chunkPath);
+    const [assetsJsonString, chunkFileContent] = await Promise.all([
+        await fs.readFile(assetsJsonFilePath, 'utf8'),
+        await fs.readFile(chunkFilePath, 'utf8'),
+    ]);
+    const serverEntryFileContentPatched = chunkFileContent.replace(ASSETS_MANIFEST, assetsJsonString);
+    assert(serverEntryFileContentPatched !== chunkFileContent);
+    await fs.writeFile(chunkFilePath, serverEntryFileContentPatched);
+    const noop = false;
+    return noop;
+}
+function find_ASSETS_MANIFEST(bundle) {
+    let chunkPath;
+    for (const filePath in bundle) {
+        const chunk = bundle[filePath];
+        if ('code' in chunk && chunk.code.includes(ASSETS_MANIFEST)) {
+            assert(!chunkPath);
+            chunkPath = filePath;
+        }
+    }
+    return chunkPath;
+}
+function getImportPath(config) {
+    // We resolve filePathAbsolute even if we don't use it: we use require.resolve() as an assertion that the relative path is correct
+    const filePathAbsolute = requireResolveDistFile('dist/server/__internal/index.js');
+    if (
+    // Let's implement a new config if a user needs the import to be a relative path instead of 'vike/__internal' (AFAIK a relative path is needed only if a framework has npm package 'vike' as direct dependency instead of a peer dependency and if the user of that framework uses pnpm)
+    true) {
+        return 'vike/__internal';
+    }
+    else {
+        const { outDirServer } = getOutDirs(config, undefined);
+        const filePathRelative = path.posix.relative(outDirServer, filePathAbsolute);
+        return filePathRelative;
+    }
+}

package/dist/node/vite/plugins/non-runnable-dev/pluginViteRPC.d.ts

@@ -0,0 +1,22 @@
+export { pluginViteRPC };
+import type { Plugin, ViteDevServer } from 'vite';
+import type { ClientDependency } from '../../../../shared-server-client/getPageFiles/analyzePageClientSide/ClientDependency.js';
+export type ViteRPC = ReturnType<typeof getViteRpcFunctions>;
+declare function getViteRpcFunctions(viteDevServer: ViteDevServer): {
+    transformIndexHtmlRPC(html: string): Promise<string>;
+    retrievePageAssetsDevRPC(clientDependencies: ClientDependency[], clientEntries: string[]): Promise<{
+        clientEntriesSrc: string[];
+        assetUrls: string[];
+    }>;
+    getViteConfigRuntimeRPC(): Promise<{
+        root: string;
+        build: {
+            outDir: string;
+        };
+        _baseViteOriginal: string;
+        vitePluginServerEntry: {
+            inject: boolean | undefined;
+        };
+    }>;
+};
+declare function pluginViteRPC(): Plugin[];

package/dist/node/vite/plugins/non-runnable-dev/pluginViteRPC.js

@@ -0,0 +1,30 @@
+export { pluginViteRPC };
+import { createViteRPC, isDevCheck } from '../../utils.js';
+import { retrievePageAssetsDev } from '../../../../server/runtime/renderPageServer/getPageAssets/retrievePageAssetsDev.js';
+import { getViteConfigRuntime } from '../../shared/getViteConfigRuntime.js';
+function getViteRpcFunctions(viteDevServer) {
+    return {
+        async transformIndexHtmlRPC(html) {
+            return await viteDevServer.transformIndexHtml('/', html);
+        },
+        async retrievePageAssetsDevRPC(clientDependencies, clientEntries) {
+            return await retrievePageAssetsDev(viteDevServer, clientDependencies, clientEntries);
+        },
+        async getViteConfigRuntimeRPC() {
+            return getViteConfigRuntime(viteDevServer.config);
+        },
+    };
+}
+function pluginViteRPC() {
+    return [
+        {
+            name: 'vike:pluginViteRPC:1',
+            apply: (_, configEnv) => isDevCheck(configEnv),
+            configureServer: {
+                handler(viteDevServer) {
+                    createViteRPC(viteDevServer, getViteRpcFunctions);
+                },
+            },
+        },
+    ];
+}

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

@@ -0,0 +1,52 @@
+export { pluginBaseUrls };
+import { resolveBase } from '../../../shared-server-node/resolveBase.js';
+import { assert } from '../utils.js';
+import { getVikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
+function pluginBaseUrls() {
+    let basesResolved;
+    return [
+        {
+            name: 'vike:pluginBaseUrls',
+            enforce: 'post',
+            config: {
+                async handler(config) {
+                    const isDev = config._isDev;
+                    assert(typeof isDev === 'boolean');
+                    const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
+                    const vikeConfig = await getVikeConfigInternal();
+                    basesResolved = resolveBase(baseViteOriginal, vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null);
+                    // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
+                    process.env.BASE_SERVER = basesResolved.baseServer;
+                    process.env.BASE_ASSETS = basesResolved.baseAssets;
+                    return {
+                        envPrefix: [
+                            'VITE_', // Vite doesn't seem to merge in its default, see https://github.com/vikejs/vike/issues/554
+                            'BASE_SERVER',
+                            'BASE_ASSETS',
+                        ],
+                        base: basesResolved.baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
+                        _baseViteOriginal: baseViteOriginal,
+                    };
+                },
+            },
+            configResolved: {
+                async handler(config) {
+                    const vikeConfig = await getVikeConfigInternal();
+                    const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.config.baseServer ?? null, vikeConfig.config.baseAssets ?? null, config);
+                    assert(basesResolved2.baseServer === basesResolved.baseServer);
+                    assert(basesResolved2.baseAssets === basesResolved.baseAssets);
+                    /* In dev, Vite seems buggy around setting vite.config.js#base to an absolute URL (e.g. http://localhost:8080/cdn/)
+                 *  - In dev, Vite removes the URL origin. (I.e. it resolves the user config `vite.config.js#base: 'http://localhost:8080/cdn/'` to resolved config `config.base === '/cdn/'`.)
+                 *  - Instead of having an internal Vike assertion fail, we let the user discover Vite's buggy behavior.
+                assert(config.base === baseAssets)
+                */
+                },
+            },
+        },
+    ];
+}
+function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
+    let baseViteOriginal = config._baseViteOriginal;
+    assert(baseViteOriginal === null || typeof baseViteOriginal == 'string');
+    return resolveBase(baseViteOriginal, baseServer, baseAssets);
+}

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

@@ -0,0 +1,17 @@
+export { pluginCommon };
+export declare let viteVersionUser: string | null | undefined;
+import { type InlineConfig, type Plugin } from 'vite';
+import type { VitePluginServerEntryOptions } from '@brillout/vite-plugin-server-entry/plugin';
+declare module 'vite' {
+    interface UserConfig {
+        vitePluginServerEntry?: VitePluginServerEntryOptions;
+        _isDev?: boolean;
+        _rootResolvedEarly?: string;
+        _baseViteOriginal?: string;
+        _viteConfigFromUserResolved?: InlineConfig;
+    }
+}
+declare global {
+    var __VIKE__IS_PROCESS_SHARED_WITH_VITE: undefined | true;
+}
+declare function pluginCommon(vikeVitePluginOptions: unknown): Plugin[];