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

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

@@ -1,175 +0,0 @@
-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 { logErrorHint } from '../../../runtime/renderPage/logErrorHint.js';
-import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
-import { isVikeCliOrApi } from '../../../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';
-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
-                        console.error(err);
-                        logErrorHint(err);
-                        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/esm/node/vite/plugins/build/pluginBuildConfig.js

@@ -1,219 +0,0 @@
-export { pluginBuildConfig };
-export { assertRollupInput };
-export { analyzeClientEntries };
-import { assert, addOnBeforeLogHook, 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/virtualFileId.js';
-import { extractAssetsAddQuery } from '../../../shared/extractAssetsQuery.js';
-import { prependEntriesDir } from '../../../shared/prependEntriesDir.js';
-import { getFilePathResolved } from '../../shared/getFilePath.js';
-import { getConfigValueBuildTime } from '../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { isViteServerSide_viteEnvOptional } from '../../shared/isViteServerSide.js';
-import { handleAssetsManifest_assertUsageCssCodeSplit, handleAssetsManifest_getBuildConfig, handleAssetsManifest_alignCssTarget, } from './handleAssetsManifest.js';
-import { resolveIncludeAssetsImportedByServer } from '../../../runtime/renderPage/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/esm/client/runtime-client-routing/entry.js');
-        const serverRoutingEntry = requireResolveDistFile('dist/esm/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 ('
-    ];
-    addOnBeforeLogHook(() => {
-        // 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/esm/node/vite/plugins/build/pluginProdBuildEntry.js

@@ -1,106 +0,0 @@
-export { pluginProdBuildEntry };
-export { set_macro_ASSETS_MANIFEST };
-import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
-import { virtualFileIdGlobalEntryServer } from '../../../shared/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 '../../../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/esm/__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/esm/node/vite/plugins/non-runnable-dev/pluginViteRPC.d.ts

@@ -1,22 +0,0 @@
-export { pluginViteRPC };
-import type { Plugin, ViteDevServer } from 'vite';
-import type { ClientDependency } from '../../../../shared/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/esm/node/vite/plugins/non-runnable-dev/pluginViteRPC.js

@@ -1,30 +0,0 @@
-export { pluginViteRPC };
-import { createViteRPC, isDevCheck } from '../../utils.js';
-import { retrievePageAssetsDev } from '../../../runtime/renderPage/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/esm/node/vite/plugins/pluginBaseUrls.js

@@ -1,52 +0,0 @@
-export { pluginBaseUrls };
-import { resolveBase } from '../../shared/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);
-}