vike 0.4.218 → 0.4.220-commit-a9f46b8

package/dist/esm/client/shared/executeOnRenderClientHook.d.ts

@@ -1,6 +1,6 @@
 export { executeOnRenderClientHook };
 export type { PageContextBeforeRenderClient };
-import type { PageFile, PageContextExports } from '../../shared/getPageFiles.js';
+import type { PageFile, PageConfigUserFriendly } from '../../shared/getPageFiles.js';
 import { type PageContextForUserConsumptionClientSide } from './preparePageContextForUserConsumptionClientSide.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 type PageContextBeforeRenderClient = {
@@ -9,5 +9,5 @@ type PageContextBeforeRenderClient = {
     urlPathname?: string;
     pageId: string;
     _pageConfigs: PageConfigRuntime[];
-} & PageContextExports & PageContextForUserConsumptionClientSide;
+} & PageConfigUserFriendly & PageContextForUserConsumptionClientSide;
 declare function executeOnRenderClientHook<PC extends PageContextBeforeRenderClient>(pageContext: PC, isClientRouting: boolean): Promise<void>;

package/dist/esm/client/shared/loadUserFilesClientSide.d.ts

@@ -1,9 +1,9 @@
 export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
 export type { PageContextUserFiles };
-import { type PageFile, type PageContextExports } from '../../shared/getPageFiles.js';
+import { type PageFile, type PageConfigUserFriendly } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
-type PageContextUserFilesLoaded = PageContextExports & {
+type PageContextUserFilesLoaded = PageConfigUserFriendly & {
     _pageFilesLoaded: PageFile[];
 };
 type PageContextUserFiles = {

package/dist/esm/client/shared/loadUserFilesClientSide.js

@@ -1,6 +1,6 @@
 export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
-import { getPageFilesClientSide, getPageContextExports } from '../../shared/getPageFiles.js';
+import { getPageFilesClientSide, getPageConfigUserFriendly } from '../../shared/getPageFiles.js';
 import { findPageConfig } from '../../shared/page-configs/findPageConfig.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { objectAssign } from '../server-routing-runtime/utils.js';
@@ -29,7 +29,7 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
         }
         throw err;
     }
-    const pageContextExports = getPageContextExports(pageFilesClientSide, pageConfigLoaded);
+    const pageContextExports = getPageConfigUserFriendly(pageFilesClientSide, pageConfigLoaded);
     const pageContextAddendum = {};
     objectAssign(pageContextAddendum, pageContextExports);
     objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });

package/dist/esm/client/shared/normalizeClientSideUrl.js

@@ -2,9 +2,8 @@ export { normalizeClientSideUrl };
 import { assert, parseUrl } from './utils.js';
 /** Resolves relative URLs */
 function normalizeClientSideUrl(url, options) {
-    // This function doesn't work for `url === '#some-hash'` because `searchOriginal` is `null` even if window.location.href has a search string.
-    // - Thus the resolved absolute URL would be missing the search string.
-    // - It makes sense that `parseUrl()` returns `searchOriginal === null` since there isn't any search string in `url`.
+    // This function doesn't work for `url === '#some-hash'` because `searchOriginal` will be missing: if window.location.href has a search string then it's going to be missing in the returned `urlCurrent` value because `parseUrl(url)` returns `searchOriginal: null` since there isn't any search string in `url`.
+    // - Maybe `const { searchOriginal } = parseUrl(window.location.href)` can be a fix. (Let's check how `normalizeClientSideUrl()` is being used.)
     assert(!url.startsWith('#'));
     const { searchOriginal, hashOriginal, pathname } = parseUrl(url, '/');
     let urlCurrent = `${pathname}${searchOriginal || ''}`;

package/dist/esm/client/shared/preparePageContextForUserConsumptionClientSide.d.ts

@@ -1,9 +1,9 @@
 export { preparePageContextForUserConsumptionClientSide };
 export type { PageContextForUserConsumptionClientSide };
-import type { PageContextExports } from '../../shared/getPageFiles.js';
+import type { PageConfigUserFriendly } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 import { PageContextForPassToClientWarning } from './getPageContextProxyForUser.js';
-type PageContextForUserConsumptionClientSide = PageContextExports & PageContextForPassToClientWarning & {
+type PageContextForUserConsumptionClientSide = PageConfigUserFriendly & PageContextForPassToClientWarning & {
     pageId: string;
     _pageConfigs: PageConfigRuntime[];
 };

package/dist/esm/node/api/build.d.ts

@@ -1,13 +1,8 @@
 export { build };
-import { type Rollup } from 'vite';
 import type { APIOptions } from './types.js';
-type RollupOutput = Rollup.RollupOutput | Rollup.RollupOutput[] | Rollup.RollupWatcher;
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
-declare function build(options?: APIOptions): Promise<{
-    rollupOutputClient: RollupOutput;
-    rollupOutputServer: RollupOutput;
-}>;
+declare function build(options?: APIOptions): Promise<{}>;

package/dist/esm/node/api/build.js

@@ -1,38 +1,32 @@
 export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { build as buildVite } from 'vite';
+import assert from 'assert';
+import { isVikeCli } from '../cli/context.js';
+import { isPrerendering } from '../prerender/context.js';
 /**
  * Programmatically trigger `$ vike build`
  *
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigEnhanced, vikeConfigGlobal } = await prepareViteApiCall(options.viteConfig, 'build');
-    // Build client-side
-    const outputClient = await buildVite(viteConfigEnhanced);
-    // Build server-side
-    const outputServer = await buildVite(setSSR(viteConfigEnhanced));
-    // Pre-render
-    if (vikeConfigGlobal.prerender &&
-        !vikeConfigGlobal.prerender.disableAutoRun &&
-        vikeConfigGlobal.disableAutoFullBuild !== 'prerender') {
-        const { runPrerenderFromAutoRun } = await import('../prerender/runPrerender.js');
-        await runPrerenderFromAutoRun(viteConfigEnhanced, true);
-    }
+    const { viteConfigEnhanced } = await prepareViteApiCall(options.viteConfig, 'build');
+    // Pass it to autoFullBuild()
+    if (viteConfigEnhanced)
+        viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;
+    // 1. Build client-side
+    // 2. Build server-side
+    //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L90
+    // 3. Pre-render (if enabled)
+    //    > See: https://github.com/vikejs/vike/blob/c6c7533a56b3a16fc43ed644fc5c10c02d0ff375/vike/node/plugin/plugins/autoFullBuild.ts#L98
+    //    > We purposely don't start the pre-rendering in this `build()` function but in a Rollup hook instead.
+    //    > Rationale: https://github.com/vikejs/vike/issues/2123
+    await buildVite(viteConfigEnhanced);
+    // When using the Vike CLI with pre-rendering the process is forcefully exited at the end of the buildVite() call above
+    assert(!(isVikeCli() && isPrerendering()));
     return {
-        /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
-        viteConfig: viteConfigEnhanced,
-        */
-        rollupOutputClient: outputClient,
-        rollupOutputServer: outputServer
-    };
-}
-function setSSR(viteConfig) {
-    return {
-        ...viteConfig,
-        build: {
-            ...viteConfig?.build,
-            ssr: true
-        }
+    /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
+    viteConfig: viteConfigEnhanced,
+    */
     };
 }

package/dist/esm/node/api/context.d.ts

@@ -1,5 +1,7 @@
 export { isVikeCliOrApi };
-export { setOperation as setOperation };
+export { setContextApiOperation };
+export { clearContextApiOperation };
 import type { Operation } from './types.js';
 declare function isVikeCliOrApi(): boolean;
-declare function setOperation(operation: Operation): void;
+declare function setContextApiOperation(operation: Operation): void;
+declare function clearContextApiOperation(): void;

package/dist/esm/node/api/context.js

@@ -1,11 +1,9 @@
 export { isVikeCliOrApi };
-// export { getOperation }
-export { setOperation as setOperation };
+export { setContextApiOperation };
+export { clearContextApiOperation };
 import { assert, getGlobalObject } from './utils.js';
-const globalObject = getGlobalObject('context.ts', {
-    apiOperation: undefined
-});
-function getOperation() {
+const globalObject = getGlobalObject('api/context.ts', {});
+function getApiOperation() {
     assert(globalObject.apiOperation);
     return globalObject.apiOperation;
 }
@@ -13,7 +11,10 @@ function isVikeCliOrApi() {
     // The CLI uses the API
     return !!globalObject.apiOperation;
 }
-function setOperation(operation) {
+function setContextApiOperation(operation) {
     assert(!globalObject.apiOperation);
     globalObject.apiOperation = operation;
 }
+function clearContextApiOperation() {
+    globalObject.apiOperation = undefined;
+}

package/dist/esm/node/api/prepareViteApiCall.d.ts

@@ -6,7 +6,6 @@ import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { Operation } from './types.js';
 declare function prepareViteApiCall(viteConfig: InlineConfig | undefined, operation: Operation): Promise<{
     viteConfigEnhanced: InlineConfig | undefined;
-    vikeConfigGlobal: import("../plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js").VikeConfigGlobal;
 }>;
 declare function getViteRoot(operation: 'build' | 'dev' | 'preview' | 'prerender'): Promise<string>;
 declare function normalizeViteRoot(root: string): string;

package/dist/esm/node/api/prepareViteApiCall.js

@@ -3,26 +3,43 @@ export { getViteRoot };
 export { assertViteRoot };
 export { normalizeViteRoot };
 // TODO: enable Vike extensions to add Vite plugins
-import { loadConfigFromFile, resolveConfig } from 'vite';
-import { setOperation } from './context.js';
+import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
+import { clearContextApiOperation, setContextApiOperation } from './context.js';
 import { getVikeConfig2 } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import path from 'path';
-import { assert, assertUsage, getGlobalObject, toPosixPath } from './utils.js';
+import { assert, assertUsage, getGlobalObject, isObject, toPosixPath } from './utils.js';
 import pc from '@brillout/picocolors';
+import { clearGlobalContext } from '../runtime/globalContext.js';
 const globalObject = getGlobalObject('prepareViteApiCall.ts', {});
 async function prepareViteApiCall(viteConfig, operation) {
-    setOperation(operation);
+    clear();
+    setContextApiOperation(operation);
     return enhanceViteConfig(viteConfig, operation);
 }
+// For subsequent API calls, e.g. calling prerender() after build()
+function clear() {
+    clearContextApiOperation();
+    clearGlobalContext();
+}
 async function enhanceViteConfig(viteConfig, operation) {
-    const { root, vikeVitePluginOptions, viteConfigEnhanced } = await getInfoFromVite(viteConfig, operation);
-    await assertViteRoot2(root, viteConfigEnhanced, operation);
-    const { vikeConfigGlobal } = await getVikeConfig2(root, operation === 'dev', vikeVitePluginOptions);
+    const viteInfo = await getInfoFromVite(viteConfig, operation);
+    await assertViteRoot2(viteInfo.root, viteInfo.viteConfigEnhanced, operation);
+    const vikeConfig = await getVikeConfig2(viteInfo.root, operation === 'dev', viteInfo.vikeVitePluginOptions);
+    const viteConfigEnhanced = addViteSettingsSetByVikeConfig(viteInfo.viteConfigEnhanced, vikeConfig);
     return {
-        viteConfigEnhanced,
-        vikeConfigGlobal
+        viteConfigEnhanced
     };
 }
+function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
+    const viteConfigs = vikeConfig.global.from.configsCumulative.vite;
+    if (!viteConfigs)
+        return viteConfigEnhanced;
+    viteConfigs.values.forEach((v) => {
+        assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
+        viteConfigEnhanced = mergeConfig(viteConfigEnhanced ?? {}, v.value);
+    });
+    return viteConfigEnhanced;
+}
 async function getViteRoot(operation) {
     if (!globalObject.root)
         await getInfoFromVite(undefined, operation);

package/dist/esm/node/cli/context.d.ts

@@ -0,0 +1,5 @@
+export { isVikeCli };
+export { setContextCliCommand };
+import type { Command } from './parseCli.js';
+declare function isVikeCli(): boolean;
+declare function setContextCliCommand(command: Command): void;

package/dist/esm/node/cli/context.js

@@ -0,0 +1,14 @@
+export { isVikeCli };
+export { setContextCliCommand };
+import { assert, getGlobalObject } from './utils.js';
+const globalObject = getGlobalObject('cli/context.ts', {});
+function getCliCommand() {
+    return globalObject.cliCommand;
+}
+function isVikeCli() {
+    return !!globalObject.cliCommand;
+}
+function setContextCliCommand(command) {
+    assert(!globalObject.cliCommand);
+    globalObject.cliCommand = command;
+}

package/dist/esm/node/cli/entry.js

@@ -2,9 +2,11 @@ import { projectInfo } from './utils.js';
 import { dev, build, preview } from '../api/index.js';
 import pc from '@brillout/picocolors';
 import { parseCli } from './parseCli.js';
+import { setContextCliCommand } from './context.js';
 cli();
 async function cli() {
     const { command } = parseCli();
+    setContextCliCommand(command);
     if (command === 'dev') {
         await cmdDev();
     }
@@ -49,6 +51,8 @@ async function cmdBuild() {
         console.error(err);
         process.exit(1);
     }
+    // See comments at runPrerender_forceExit()
+    process.exit(0);
 }
 async function cmdPreview() {
     try {

package/dist/esm/node/cli/parseCli.d.ts

@@ -1,4 +1,6 @@
 export { parseCli };
+export type { Command };
+type Command = 'dev' | 'build' | 'preview' | 'prerender';
 declare function parseCli(): {
-    command: "dev" | "build" | "preview" | "prerender";
+    command: Command;
 };

package/dist/esm/node/cli/utils.d.ts

@@ -1,3 +1,4 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/includes.js';
+export * from '../../utils/getGlobalObject.js';

package/dist/esm/node/cli/utils.js

@@ -5,3 +5,4 @@ onLoad();
 export * from '../../utils/assert.js';
 export * from '../../utils/projectInfo.js';
 export * from '../../utils/includes.js';
+export * from '../../utils/getGlobalObject.js';

package/dist/esm/node/plugin/index.d.ts

@@ -3,5 +3,5 @@ export { plugin };
 export { plugin as ssr };
 export type { VikeVitePluginOptions as UserConfig };
 export { PROJECT_VERSION as version } from './utils.js';
-import type { VikeVitePluginOptions } from './plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
+import type { VikeVitePluginOptions } from './plugins/importUserCode/v1-design/getVikeConfig.js';
 declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): any;

package/dist/esm/node/plugin/index.js

@@ -17,7 +17,7 @@ import { extractAssetsPlugin } from './plugins/extractAssetsPlugin.js';
 import { extractExportNamesPlugin } from './plugins/extractExportNamesPlugin.js';
 import { suppressRollupWarning } from './plugins/suppressRollupWarning.js';
 import { setGlobalContext } from './plugins/setGlobalContext.js';
-import { importBuild } from './plugins/importBuild/index.js';
+import { buildEntry } from './plugins/buildEntry/index.js';
 import { commonConfig } from './plugins/commonConfig.js';
 import { baseUrls } from './plugins/baseUrls.js';
 import { envVarsPlugin } from './plugins/envVars.js';
@@ -26,7 +26,7 @@ import { fileEnv } from './plugins/fileEnv.js';
 import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.js';
 import { resolveClientEntriesDev } from './resolveClientEntriesDev.js';
 import { workaroundCssModuleHmr } from './plugins/workaroundCssModuleHmr.js';
-import { vite6HmrRegressionWorkaround } from './plugins/vite6HmrRegressionWorkaround.js';
+import { workaroundVite6HmrRegression } from './plugins/workaroundVite6HmrRegression.js';
 markSetup_vikeVitePlugin();
 assertViteVersion();
 setResolveClientEntriesDev(resolveClientEntriesDev);
@@ -46,12 +46,12 @@ function plugin(vikeVitePluginOptions = {}) {
         extractExportNamesPlugin(),
         suppressRollupWarning(),
         ...setGlobalContext(),
-        ...importBuild(),
-        baseUrls(vikeVitePluginOptions),
+        ...buildEntry(),
+        baseUrls(),
         envVarsPlugin(),
         fileEnv(),
         workaroundCssModuleHmr(),
-        vite6HmrRegressionWorkaround()
+        workaroundVite6HmrRegression()
     ];
     Object.assign(plugins, { __vikeVitePluginOptions: vikeVitePluginOptions });
     return plugins;

package/dist/esm/node/plugin/plugins/autoFullBuild.js

@@ -3,11 +3,14 @@ export { autoFullBuild };
 import { build } from 'vite';
 import { assertWarning } from '../utils.js';
 import { runPrerenderFromAutoRun, runPrerender_forceExit } from '../../prerender/runPrerender.js';
+import { isPrerenderAutoRunEnabled } from '../../prerender/context.js';
 import { isViteCliCall, getViteConfigFromCli } from '../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
 import { logErrorHint } from '../../runtime/renderPage/logErrorHint.js';
 import { manifestTempFile } from './buildConfig.js';
 import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+import { isVikeCliOrApi } from '../../api/context.js';
+import { isVikeCli } from '../../cli/context.js';
 let forceExit = false;
 function autoFullBuild() {
     let config;
@@ -68,35 +71,43 @@ async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
     if (!bundle[manifestTempFile])
         return;
     const configFromCli = !isViteCliCall() ? null : getViteConfigFromCli();
-    const configInline = {
-        ...configFromCli,
-        configFile: configFromCli?.configFile || config.configFile,
-        root: config.root,
-        build: {
-            ...configFromCli?.build
-        }
-    };
-    try {
-        await build({
-            ...configInline,
+    let configInline;
+    if (config._viteConfigEnhanced) {
+        configInline = config._viteConfigEnhanced;
+    }
+    else {
+        configInline = {
+            ...configFromCli,
+            configFile: configFromCli?.configFile || config.configFile,
+            root: config.root,
             build: {
-                ...configInline.build,
-                ssr: true
+                ...configFromCli?.build
             }
-        });
+        };
+    }
+    try {
+        await build(setSSR(configInline));
     }
     catch (err) {
         console.error(err);
         logErrorHint(err);
         process.exit(1);
     }
-    if (vikeConfigGlobal.prerender &&
-        !vikeConfigGlobal.prerender.disableAutoRun &&
-        vikeConfigGlobal.disableAutoFullBuild !== 'prerender') {
-        await runPrerenderFromAutoRun(configInline, false);
-        forceExit = true;
+    if (isPrerenderAutoRunEnabled(vikeConfigGlobal)) {
+        const { prerenderContextPublic } = await runPrerenderFromAutoRun(configInline);
+        config.vike.prerenderContext = prerenderContextPublic;
+        forceExit = isVikeCli() || isViteCliCall();
     }
 }
+function setSSR(configInline) {
+    return {
+        ...configInline,
+        build: {
+            ...configInline.build,
+            ssr: true
+        }
+    };
+}
 function abortViteBuildSsr(vikeConfigGlobal) {
     if (vikeConfigGlobal.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.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 });
@@ -106,7 +117,8 @@ function abortViteBuildSsr(vikeConfigGlobal) {
 function isDisabled(vikeConfigGlobal) {
     const { disableAutoFullBuild } = vikeConfigGlobal;
     if (disableAutoFullBuild === null || disableAutoFullBuild === 'prerender') {
-        return !isViteCliCall();
+        const isViteApi = !isViteCliCall() && !isVikeCliOrApi();
+        return isViteApi;
     }
     else {
         return disableAutoFullBuild;

package/dist/esm/node/plugin/plugins/baseUrls.d.ts

@@ -1,3 +1,3 @@
 export { baseUrls };
 import type { Plugin } from 'vite';
-declare function baseUrls(vikeVitePluginOptions: unknown): Plugin;
+declare function baseUrls(): Plugin;

package/dist/esm/node/plugin/plugins/baseUrls.js

@@ -1,23 +1,17 @@
 export { baseUrls };
 import { resolveBase, resolveBaseFromResolvedConfig } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
-import { getVikeConfig, getVikeConfig2 } from './importUserCode/v1-design/getVikeConfig.js';
-import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
-function baseUrls(vikeVitePluginOptions) {
+import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+function baseUrls() {
     let basesResolved;
-    let root;
     return {
         name: 'vike:baseUrls',
         enforce: 'post',
-        async config(config, env) {
+        async config(config) {
             const isDev = config._isDev;
             assert(typeof isDev === 'boolean');
-            const operation = env.command === 'build' ? 'build' : env.isPreview ? 'preview' : 'dev';
-            root = config.root ? normalizeViteRoot(config.root) : await getViteRoot(operation);
-            assert(root);
             const baseViteOriginal = config.base ?? '/__UNSET__'; // '/__UNSET__' because Vite resolves `_baseViteOriginal: null` to `undefined`
-            const vikeConfig = await getVikeConfig2(root, isDev, vikeVitePluginOptions);
-            basesResolved = resolveBase(baseViteOriginal, vikeConfig.vikeConfigGlobal.baseServer, vikeConfig.vikeConfigGlobal.baseAssets);
+            basesResolved = resolveBase(baseViteOriginal, config._vikeConfigGlobal.baseServer, config._vikeConfigGlobal.baseAssets);
             // 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;
@@ -32,7 +26,6 @@ function baseUrls(vikeVitePluginOptions) {
             };
         },
         async configResolved(config) {
-            assertViteRoot(root, config);
             const vikeConfig = await getVikeConfig(config);
             const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.vikeConfigGlobal.baseServer, vikeConfig.vikeConfigGlobal.baseAssets, config);
             assert(basesResolved2.baseServer === basesResolved.baseServer);

package/dist/esm/node/plugin/plugins/buildConfig.js

@@ -11,7 +11,7 @@ import { createRequire } from 'module';
 import fs from 'fs/promises';
 import path from 'path';
 import { fixServerAssets, fixServerAssets_assertCssCodeSplit, fixServerAssets_assertCssTarget, fixServerAssets_assertCssTarget_populate, fixServerAssets_isEnabled } from './buildConfig/fixServerAssets.js';
-import { set_ASSETS_MAP } from './importBuild/index.js';
+import { set_ASSETS_MAP } from './buildEntry/index.js';
 import { prependEntriesDir } from '../../shared/prependEntriesDir.js';
 import { getFilePathResolved } from '../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
@@ -117,7 +117,7 @@ async function getEntries(config) {
     if (viteIsSSR(config)) {
         const pageEntries = getPageEntries(pageConfigs);
         const entries = {
-            // importBuild: resolve('dist/esm/node/importBuild.js'), // TODO/next-major-release: remove
+            // buildEntry: resolve('dist/esm/node/buildEntry.js'), // TODO/next-major-release: remove
             ...pageFileEntries,
             // Ensure Rollup generates a bundle per page: https://github.com/vikejs/vike/issues/349#issuecomment-1166247275
             ...pageEntries

package/dist/esm/node/plugin/plugins/{importBuild → buildEntry}/getVikeManifest.d.ts

@@ -1,5 +1,5 @@
 export { getVikeManifest };
 import { type PluginManifest } from '../../../shared/assertPluginManifest.js';
-import type { VikeConfigGlobal } from '../importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
+import type { VikeConfigGlobal } from '../importUserCode/v1-design/getVikeConfig.js';
 import type { ResolvedConfig } from 'vite';
 declare function getVikeManifest(vikeConfigGlobal: VikeConfigGlobal, viteConfig: ResolvedConfig): PluginManifest;

package/dist/esm/node/plugin/plugins/{importBuild → buildEntry}/index.d.ts

@@ -1,8 +1,8 @@
-export { importBuild };
+export { buildEntry };
 export { set_ASSETS_MAP };
 import type { Plugin, Rollup } from 'vite';
 type Bundle = Rollup.OutputBundle;
 type Options = Rollup.NormalizedOutputOptions;
-declare function importBuild(): Plugin[];
+declare function buildEntry(): Plugin[];
 /** Set the value of the ASSETS_MAP constant inside dist/server/entry.js (or dist/server/index.js) */
 declare function set_ASSETS_MAP(options: Options, bundle: Bundle): Promise<void>;

package/dist/esm/node/plugin/plugins/{importBuild → buildEntry}/index.js

@@ -1,23 +1,23 @@
-export { importBuild };
+export { buildEntry };
 export { set_ASSETS_MAP };
 import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/plugin';
+import { virtualFileIdImportUserCodeServer } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
+import { getVikeManifest } from './getVikeManifest.js';
+import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 import { assert, getOutDirs, toPosixPath } from '../../utils.js';
+import fs from 'fs/promises';
 import path from 'path';
 import { createRequire } from 'module';
-import { getVikeManifest } from './getVikeManifest.js';
-import fs from 'fs/promises';
-import { virtualFileIdImportUserCodeServer } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
-import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
 // @ts-ignore Shimmed by dist-cjs-fixup.js for CJS build.
 const importMetaUrl = import.meta.url;
 const require_ = createRequire(importMetaUrl);
 const ASSETS_MAP = '__VITE_ASSETS_MAP__';
-function importBuild() {
+function buildEntry() {
     let config;
     let vikeConfigGlobal;
     return [
         {
-            name: 'vike:importBuild:config',
+            name: 'vike:buildEntry',
             enforce: 'post',
             async configResolved(config_) {
                 config = config_;
@@ -38,17 +38,16 @@ function getServerProductionEntryCode(config, vikeConfigGlobal) {
     const vikeManifest = getVikeManifest(vikeConfigGlobal, config);
     // Let's eventually simplify and move everything to a single virtual module
     const importerCode = [
-        `  import { setImportBuildGetters } from '${importPath}';`,
+        `  import { setGlobalContext_buildEntry } from '${importPath}';`,
         `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,
         `  {`,
         // We first set the values to a variable because of a Rollup bug, and this workaround doesn't work: https://github.com/vikejs/vike/commit/d5f3a4f7aae5a8bc44192e6cbb2bcb9007be188d
         `    const assetsManifest = ${ASSETS_MAP};`,
         `    const pluginManifest = ${JSON.stringify(vikeManifest, null, 2)};`,
-        '    setImportBuildGetters({',
-        `      pageFiles: () => pageFiles,`,
-        `      getAssetsManifest: () => assetsManifest,`,
-        // TODO: rename pluginManifest -> vikeManifest
-        `      pluginManifest: () => pluginManifest,`,
+        '    setGlobalContext_buildEntry({',
+        `      pageFiles,`,
+        `      assetsManifest,`,
+        `      pluginManifest,`,
         '    });',
         `  }`,
         ''
@@ -85,12 +84,12 @@ function find_ASSETS_MAP(bundle) {
 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 = toPosixPath(
-    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/importBuild/index.js
-    require_.resolve(`../../../../../../dist/esm/node/runtime/globalContext/loadImportBuild.js`));
+    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/esm/node/plugin/plugins/buildEntry/index.js
+    require_.resolve(`../../../../../../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/loadImportBuild' (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)
+    // 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/loadImportBuild';
+        return 'vike/__internal';
     }
     else {
         const { outDirServer } = getOutDirs(config);

package/dist/esm/node/plugin/plugins/commonConfig.d.ts

@@ -1,9 +1,18 @@
 export { commonConfig };
-import { type Plugin } from 'vite';
+import { type InlineConfig, type Plugin } from 'vite';
+import { type VikeConfigObject } from './importUserCode/v1-design/getVikeConfig.js';
+import type { PrerenderContextPublic } from '../../prerender/runPrerender.js';
 declare module 'vite' {
     interface UserConfig {
         _isDev?: boolean;
         _vikeVitePluginOptions?: unknown;
+        _root?: string;
+        _viteConfigEnhanced?: InlineConfig;
+        vike?: {
+            global: VikeConfigObject['global'];
+            prerenderContext?: PrerenderContextPublic;
+        };
+        _vikeConfigGlobal?: VikeConfigObject['vikeConfigGlobal'];
     }
 }
 declare function commonConfig(vikeVitePluginOptions: unknown): Plugin[];