vike 0.4.217 → 0.4.218-commit-ed9b3d4

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.d.ts

@@ -5,7 +5,7 @@ export { getPageContextFromClientHooks };
 export { setPageContextInitIsPassedToClient };
 export type { PageContextFromServerHooks };
 export type { PageContextFromClientHooks };
-import type { PageContextExports, PageFile } from '../../shared/getPageFiles.js';
+import type { PageConfigUserFriendly, PageFile } from '../../shared/getPageFiles.js';
 import type { PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 type PageContext = {
     urlOriginal: string;
@@ -21,9 +21,9 @@ declare function getPageContextFromHooks_serialized(): PageContextSerialized & {
     routeParams: Record<string, string>;
     _hasPageContextFromServer: true;
 };
-declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageContextExports & {
+declare function getPageContextFromHooks_isHydration(pageContext: PageContextSerialized & PageContext & PageConfigUserFriendly & {
     _hasPageContextFromServer: true;
-}): Promise<PageContextSerialized & PageContext & PageContextExports & {
+}): Promise<PageContextSerialized & PageContext & PageConfigUserFriendly & {
     _hasPageContextFromServer: true;
 } & {
     _hasPageContextFromClient: boolean;
@@ -45,5 +45,5 @@ type PageContextFromClientHooks = {
 declare function getPageContextFromClientHooks(pageContext: {
     pageId: string;
     _hasPageContextFromServer: boolean;
-} & PageContext & PageContextExports, isErrorPage: boolean): Promise<PageContextFromClientHooks>;
+} & PageContext & PageConfigUserFriendly, isErrorPage: boolean): Promise<PageContextFromClientHooks>;
 declare function setPageContextInitIsPassedToClient(pageContext: Record<string, unknown>): void;

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.js

@@ -12,7 +12,7 @@ import { preparePageContextForUserConsumptionClientSide } from '../shared/prepar
 import { removeBuiltInOverrides } from './getPageContext/removeBuiltInOverrides.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getPageConfig } from '../../shared/page-configs/helpers.js';
-import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValueRuntime.js';
 import { assertOnBeforeRenderHookReturn } from '../../shared/assertOnBeforeRenderHookReturn.js';
 import { executeGuardHook } from '../../shared/route/executeGuardHook.js';
 import { AbortRender, isAbortPageContext } from '../../shared/route/abort.js';

package/dist/esm/client/client-routing-runtime/prefetch/getPrefetchSettings.d.ts

@@ -1,10 +1,10 @@
 export { getPrefetchSettings };
 export { PAGE_CONTEXT_MAX_AGE_DEFAULT };
 export type { PrefetchSettingResolved };
-import type { PageContextExports } from '../../../shared/getPageFiles.js';
+import type { PageConfigUserFriendly } from '../../../shared/getPageFiles.js';
 declare const PAGE_CONTEXT_MAX_AGE_DEFAULT = 5000;
 type PrefetchSettingResolved = {
     staticAssets: false | 'hover' | 'viewport';
     pageContext: false | number;
 };
-declare function getPrefetchSettings(pageContext: PageContextExports, linkTag: null | HTMLElement): PrefetchSettingResolved;
+declare function getPrefetchSettings(pageContext: PageConfigUserFriendly, linkTag: null | HTMLElement): PrefetchSettingResolved;

package/dist/esm/client/client-routing-runtime/prefetch.d.ts

@@ -6,7 +6,7 @@ export { addLinkPrefetchHandlers };
 export { addLinkPrefetchHandlers_watch };
 export { addLinkPrefetchHandlers_unwatch };
 import { type PageContextFromServerHooks, getPageContextFromServerHooks } from './getPageContextFromHooks.js';
-import type { PageContextExports, PageFile } from '../../shared/getPageFiles.js';
+import type { PageConfigUserFriendly, PageFile } from '../../shared/getPageFiles.js';
 import { type PageConfigRuntime } from '../../shared/page-configs/PageConfig.js';
 type ResultPageContextFromServer = Awaited<ReturnType<typeof getPageContextFromServerHooks>>;
 type PageContextForPrefetch = {
@@ -19,7 +19,7 @@ type PageContextForPrefetch = {
 };
 declare function getPageContextPrefetched(pageContext: {
     urlPathname: string;
-} & PageContextExports): null | PageContextFromServerHooks;
+} & PageConfigUserFriendly): null | PageContextFromServerHooks;
 declare function populatePageContextPrefetchCache(pageContext: PageContextForPrefetch, result: ResultPageContextFromServer): void;
 /**
  * Programmatically prefetch client assets.

package/dist/esm/client/client-routing-runtime/prefetch.js

@@ -60,8 +60,8 @@ async function prefetchPageContextFromServerHooks(pageContextLink, resultMaxAge)
     const result = await getPageContextFromServerHooks(pageContextLink, false);
     setPageContextPrefetchCache(pageContextLink, result, resultMaxAge);
 }
-function populatePageContextPrefetchCache(pageContext /*& PageContextExports*/, result) {
-    // TODO/pageContext-prefetch: replace with using pageContext.config.prerender instead. (For being able to do that: eager configs need to be accessible without have to use PageContextExports as it isn't available here.)
+function populatePageContextPrefetchCache(pageContext /*& PageConfigUserFriendly*/, result) {
+    // TODO/pageContext-prefetch: replace with using pageContext.config.prerender instead. (For being able to do that: eager configs need to be accessible without have to use PageConfigUserFriendly as it isn't available here.)
     if (!isBrilloutDocpress())
         return;
     setPageContextPrefetchCache(pageContext, result, null);

package/dist/esm/client/server-routing-runtime/entry.d.ts

@@ -1 +1 @@
-import './pageFiles';
+export {};

package/dist/esm/client/server-routing-runtime/entry.js

@@ -1,6 +1,5 @@
 import { assertServerRouting } from '../../utils/assertRoutingType.js';
 assertServerRouting();
-import './pageFiles';
 import { getPageContext } from './getPageContext.js';
 import { executeOnRenderClientHook } from '../shared/executeOnRenderClientHook.js';
 import { assertHook } from '../../shared/hooks/getHook.js';

package/dist/esm/client/server-routing-runtime/getPageContext.d.ts

@@ -10,6 +10,6 @@ declare function getPageContext(): Promise<{
 } & {
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
     _pageConfigs: import("../../__internal/index.js").PageConfig[];
-} & import("../../shared/getPageFiles.js").PageContextExports & {
+} & import("../../shared/getPageFiles.js").PageConfigUserFriendly & {
     _pageFilesLoaded: import("../../shared/getPageFiles.js").PageFile[];
 }>;

package/dist/esm/client/server-routing-runtime/getPageContext.js

@@ -1,10 +1,13 @@
+export { getPageContext };
 import { assertUsage, assertWarning, objectAssign } from './utils.js';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
-import { getPageFilesAll } from '../../shared/getPageFiles.js';
+import { getPageFilesAll, setPageFiles } from '../../shared/getPageFiles/getPageFiles.js';
 import { loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
-export { getPageContext };
+// @ts-ignore
+import * as pageFilesExports from 'virtual:vike:importUserCode:client:server-routing';
 const urlFirst = getCurrentUrl({ withoutHash: true });
+initDevEntry();
 async function getPageContext() {
     const pageContext = getPageContextSerializedInHtml();
     objectAssign(pageContext, {
@@ -36,3 +39,6 @@ async function loadPageUserFiles(pageId) {
     });
     return pageContextAddendum;
 }
+function initDevEntry() {
+    setPageFiles(pageFilesExports);
+}

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/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.js

@@ -1,6 +1,7 @@
 export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
 import { build as buildVite } from 'vite';
+import { isPrerenderEnabled } from '../prerender/isPrerenderEnabled.js';
 /**
  * Programmatically trigger `$ vike build`
  *
@@ -13,11 +14,9 @@ async function build(options = {}) {
     // Build server-side
     const outputServer = await buildVite(setSSR(viteConfigEnhanced));
     // Pre-render
-    if (vikeConfigGlobal.prerender &&
-        !vikeConfigGlobal.prerender.disableAutoRun &&
-        vikeConfigGlobal.disableAutoFullBuild !== 'prerender') {
+    if (isPrerenderEnabled(vikeConfigGlobal)) {
         const { runPrerenderFromAutoRun } = await import('../prerender/runPrerender.js');
-        await runPrerenderFromAutoRun(viteConfigEnhanced, true);
+        await runPrerenderFromAutoRun(viteConfigEnhanced);
     }
     return {
         /* We don't return `viteConfig` because `viteConfigEnhanced` is `InlineConfig` not `ResolvedConfig`
@@ -31,7 +30,7 @@ function setSSR(viteConfig) {
     return {
         ...viteConfig,
         build: {
-            ...viteConfig.build,
+            ...viteConfig?.build,
             ssr: true
         }
     };

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

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

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

@@ -1,6 +1,7 @@
-export { isVikeCliOrApi };
 // export { getOperation }
-export { setOperation as setOperation };
+export { setOperation };
+export { clearOperation };
+export { isVikeCliOrApi };
 import { assert, getGlobalObject } from './utils.js';
 const globalObject = getGlobalObject('context.ts', {
     apiOperation: undefined
@@ -17,3 +18,6 @@ function setOperation(operation) {
     assert(!globalObject.apiOperation);
     globalObject.apiOperation = operation;
 }
+function clearOperation() {
+    globalObject.apiOperation = undefined;
+}

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

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

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

@@ -1,38 +1,112 @@
 export { prepareViteApiCall };
-import { resolveConfig } from 'vite';
-import { pluginName } from '../plugin/plugins/commonConfig/pluginName.js';
-import { setOperation } from './context.js';
+export { getViteRoot };
+export { assertViteRoot };
+export { normalizeViteRoot };
+// TODO: enable Vike extensions to add Vite plugins
+import { loadConfigFromFile, mergeConfig, resolveConfig } from 'vite';
+import { clearOperation, setOperation } from './context.js';
 import { getVikeConfig2 } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
-async function prepareViteApiCall(viteConfig = {}, operation) {
+import path from 'path';
+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) {
+    clear();
     setOperation(operation);
     return enhanceViteConfig(viteConfig, operation);
 }
-async function enhanceViteConfig(viteConfig = {}, operation) {
-    let viteConfigResolved = await resolveViteConfig(viteConfig, operation);
+// For subsequent API calls, e.g. calling prerender() after build()
+function clear() {
+    clearOperation();
+    clearGlobalContext();
+}
+async function enhanceViteConfig(viteConfig, operation) {
+    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 = addViteSettingsSetByUser(viteInfo.viteConfigEnhanced, vikeConfig);
+    return {
+        viteConfigEnhanced,
+        vikeConfigGlobal: vikeConfig.vikeConfigGlobal
+    };
+}
+function addViteSettingsSetByUser(viteConfigEnhanced, vikeConfig) {
+    const { global } = vikeConfig.vikeConfigNew;
+    const viteConfigs = global.from.configsCumulative.vite;
+    if (!viteConfigs)
+        return viteConfigEnhanced;
+    viteConfigs.values.forEach((v) => {
+        assertUsage(isObject(v.value), `${v.definedAt} should be an object`);
+        viteConfigEnhanced = mergeConfig(v.value, viteConfigEnhanced ?? {});
+    });
+    return viteConfigEnhanced;
+}
+async function getViteRoot(operation) {
+    if (!globalObject.root)
+        await getInfoFromVite(undefined, operation);
+    assert(globalObject.root);
+    return globalObject.root;
+}
+async function getInfoFromVite(viteConfig, operation) {
+    const viteConfigFromFile = await loadViteConfigFile(viteConfig, operation);
+    const root = normalizeViteRoot(viteConfigFromFile?.root ?? viteConfig?.root ?? process.cwd());
+    globalObject.root = root;
+    let vikeVitePluginOptions;
     let viteConfigEnhanced = viteConfig;
-    // Add vike to plugins if not present
-    if (!viteConfigResolved.plugins.some((p) => p.name === pluginName)) {
-        // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus have vike/plugin may resolved to two different node_modules/vike directories
+    const found = findVikeVitePlugin([...(viteConfig?.plugins ?? []), ...(viteConfigFromFile?.plugins ?? [])]);
+    if (found) {
+        vikeVitePluginOptions = found.vikeVitePluginOptions;
+    }
+    else {
+        // Add Vike to plugins if not present.
+        // Using a dynamic import because the script calling the Vike API may not live in the same place as vite.config.js, thus vike/plugin may resolved to two different node_modules/vike directories.
         const { plugin: vikePlugin } = await import('../plugin/index.js');
         viteConfigEnhanced = {
             ...viteConfig,
-            plugins: [...(viteConfig.plugins ?? []), vikePlugin()]
+            plugins: [...(viteConfig?.plugins ?? []), vikePlugin()]
         };
-        viteConfigResolved = await resolveViteConfig(viteConfigEnhanced, operation);
+        const res = findVikeVitePlugin(viteConfigEnhanced.plugins);
+        assert(res);
+        vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
-    // TODO: use loadConfigFromFile() instead of viteConfigResolved
-    const { vikeConfigGlobal } = await getVikeConfig2(viteConfigResolved.root, operation === 'dev', viteConfigResolved._vikeVitePluginOptions);
-    // TODO: enable Vike extensions to add Vite plugins
-    return {
-        viteConfigEnhanced,
-        vikeConfigGlobal
-    };
+    assert(vikeVitePluginOptions);
+    return { root, vikeVitePluginOptions, viteConfigEnhanced };
 }
-async function resolveViteConfig(viteConfig, operation) {
-    const args = getResolveConfigArgs(viteConfig, operation);
-    return await resolveConfig(...args);
+function findVikeVitePlugin(plugins) {
+    let vikeVitePluginOptions;
+    let vikeVitePuginFound = false;
+    plugins.forEach((p) => {
+        if (p && '__vikeVitePluginOptions' in p) {
+            vikeVitePuginFound = true;
+            const options = p.__vikeVitePluginOptions;
+            vikeVitePluginOptions ?? (vikeVitePluginOptions = {});
+            Object.assign(vikeVitePluginOptions, options);
+        }
+    });
+    if (!vikeVitePuginFound)
+        return null;
+    return { vikeVitePluginOptions };
+}
+// Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
+async function loadViteConfigFile(viteConfig, operation) {
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfig, operation);
+    let config = inlineConfig;
+    let mode = inlineConfig.mode || defaultMode;
+    const configEnv = {
+        mode,
+        command,
+        isSsrBuild: command === 'build' && !!config.build?.ssr,
+        isPreview
+    };
+    let { configFile } = config;
+    if (configFile !== false) {
+        const loadResult = await loadConfigFromFile(configEnv, configFile, config.root, config.logLevel, config.customLogger);
+        return loadResult?.config;
+    }
+    return null;
 }
-function getResolveConfigArgs(viteConfig, operation) {
+function getResolveConfigArgs(viteConfig = {}, operation) {
     const inlineConfig = viteConfig;
     const command = operation === 'build' || operation === 'prerender' ? 'build' : 'serve';
     const defaultMode = operation === 'dev' ? 'development' : 'production';
@@ -40,3 +114,18 @@ function getResolveConfigArgs(viteConfig, operation) {
     const isPreview = operation === 'preview';
     return [inlineConfig, command, defaultMode, defaultNodeEnv, isPreview];
 }
+function normalizeViteRoot(root) {
+    return toPosixPath(path.resolve(root));
+}
+const errMsg = `A Vite plugin is modifying Vite's setting ${pc.cyan('root')} which is forbidden`;
+async function assertViteRoot2(root, viteConfigEnhanced, operation) {
+    const args = getResolveConfigArgs(viteConfigEnhanced, operation);
+    // We can eventually this resolveConfig() call (along with removing the whole assertViteRoot2() function which is redundant with the assertViteRoot() function) so that Vike doesn't make any resolveConfig() (except for pre-rendering which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
+    const viteConfigResolved = await resolveConfig(...args);
+    assertUsage(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);
+}
+function assertViteRoot(root, config) {
+    if (globalObject.root)
+        assert(normalizeViteRoot(globalObject.root) === normalizeViteRoot(root));
+    assertUsage(normalizeViteRoot(root) === normalizeViteRoot(config.root), errMsg);
+}

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

@@ -1,2 +1,4 @@
 export * from '../../utils/assert.js';
 export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/isObject.js';

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

@@ -4,3 +4,5 @@ import { onLoad } from './onLoad.js';
 onLoad();
 export * from '../../utils/assert.js';
 export * from '../../utils/getGlobalObject.js';
+export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/isObject.js';

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

@@ -49,6 +49,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,4 @@
 export { parseCli };
 declare function parseCli(): {
-    command: "dev" | "build" | "preview" | "prerender";
+    command: "build" | "dev" | "preview" | "prerender";
 };

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,12 +26,12 @@ 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);
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
-function plugin(vikeVitePluginOptions) {
+function plugin(vikeVitePluginOptions = {}) {
     const plugins = [
         ...commonConfig(vikeVitePluginOptions),
         importUserCode(),
@@ -46,13 +46,14 @@ function plugin(vikeVitePluginOptions) {
         extractExportNamesPlugin(),
         suppressRollupWarning(),
         ...setGlobalContext(),
-        ...importBuild(),
+        ...buildEntry(),
         baseUrls(vikeVitePluginOptions),
         envVarsPlugin(),
         fileEnv(),
         workaroundCssModuleHmr(),
-        vite6HmrRegressionWorkaround()
+        workaroundVite6HmrRegression()
     ];
+    Object.assign(plugins, { __vikeVitePluginOptions: vikeVitePluginOptions });
     return plugins;
 }
 // Error upon wrong usage

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

@@ -3,6 +3,7 @@ export { autoFullBuild };
 import { build } from 'vite';
 import { assertWarning } from '../utils.js';
 import { runPrerenderFromAutoRun, runPrerender_forceExit } from '../../prerender/runPrerender.js';
+import { isPrerenderEnabled } from '../../prerender/isPrerenderEnabled.js';
 import { isViteCliCall, getViteConfigFromCli } from '../shared/isViteCliCall.js';
 import pc from '@brillout/picocolors';
 import { logErrorHint } from '../../runtime/renderPage/logErrorHint.js';
@@ -90,10 +91,8 @@ async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
         logErrorHint(err);
         process.exit(1);
     }
-    if (vikeConfigGlobal.prerender &&
-        !vikeConfigGlobal.prerender.disableAutoRun &&
-        vikeConfigGlobal.disableAutoFullBuild !== 'prerender') {
-        await runPrerenderFromAutoRun(configInline, false);
+    if (isPrerenderEnabled(vikeConfigGlobal)) {
+        await runPrerenderFromAutoRun(configInline);
         forceExit = true;
     }
 }

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

@@ -1,4 +1,3 @@
 export { baseUrls };
 import type { Plugin } from 'vite';
-import type { VikeVitePluginOptions } from './importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
-declare function baseUrls(vikeVitePluginOptions?: VikeVitePluginOptions): Plugin;
+declare function baseUrls(vikeVitePluginOptions: unknown): Plugin;

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

@@ -1,36 +1,42 @@
 export { baseUrls };
 import { resolveBase, resolveBaseFromResolvedConfig } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
-import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+import { getVikeConfig, getVikeConfig2 } from './importUserCode/v1-design/getVikeConfig.js';
+import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/prepareViteApiCall.js';
 function baseUrls(vikeVitePluginOptions) {
-    let bases;
+    let basesResolved;
+    let root;
     return {
         name: 'vike:baseUrls',
         enforce: 'post',
-        async config(config) {
-            // TODO: fix bug: use getVikeConfig2() and udpate check below
-            bases = resolveBaseFromUserConfig(config, vikeVitePluginOptions);
-            const { baseServer, baseAssets } = bases;
+        async config(config, env) {
+            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);
             // We cannot define these in configResolved() because Vite picks up the env variables before any configResolved() hook is called
-            process.env.BASE_SERVER = baseServer;
-            process.env.BASE_ASSETS = baseAssets;
+            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: baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
-                _baseViteOriginal: config.base ?? '/__UNSET__' // Vite resolves `_baseViteOriginal: null` to `undefined`
+                base: basesResolved.baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
+                _baseViteOriginal: baseViteOriginal
             };
         },
         async configResolved(config) {
+            assertViteRoot(root, config);
             const vikeConfig = await getVikeConfig(config);
-            const { baseServer, baseAssets } = vikeConfig.vikeConfigGlobal;
-            const basesResolved = resolveBaseFromResolvedConfig(baseServer, baseAssets, config);
-            // Ensure that the premature base URL resolving we did in config() isn't erroneous
-            assert(basesResolved.baseServer === bases.baseServer);
-            assert(basesResolved.baseAssets === bases.baseAssets);
+            const basesResolved2 = resolveBaseFromResolvedConfig(vikeConfig.vikeConfigGlobal.baseServer, vikeConfig.vikeConfigGlobal.baseAssets, 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.
@@ -39,7 +45,3 @@ function baseUrls(vikeVitePluginOptions) {
         }
     };
 }
-function resolveBaseFromUserConfig(config, vikeVitePluginOptions) {
-    const baseViteOriginal = config.base ?? null;
-    return resolveBase(baseViteOriginal, vikeVitePluginOptions?.baseServer ?? null, vikeVitePluginOptions?.baseAssets ?? null);
-}

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;