vike 0.4.220 → 0.4.221-commit-8577456

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

@@ -6,6 +6,6 @@ import { type ScrollPosition } from './history.js';
 type ScrollTarget = undefined | {
     preserveScroll: boolean;
 } | ScrollPosition;
-declare function setScrollPosition(scrollTarget: ScrollTarget): void;
+declare function setScrollPosition(scrollTarget: ScrollTarget, url?: string): void;
 declare function scrollToHashOrTop(hash: null | string): void;
 declare function autoSaveScrollPosition(): void;

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

@@ -2,8 +2,12 @@ export { setScrollPosition };
 export { autoSaveScrollPosition };
 export { scrollToHashOrTop };
 import { assert, onPageHide, sleep, throttle } from './utils.js';
-import { saveScrollPosition } from './history.js';
-function setScrollPosition(scrollTarget) {
+import { replaceHistoryStateOriginal, saveScrollPosition } from './history.js';
+function setScrollPosition(scrollTarget, url) {
+    if (!scrollTarget && url && hasTextFragment(url)) {
+        scrollToTextFragment(url);
+        return;
+    }
     if (scrollTarget && 'x' in scrollTarget) {
         setScroll(scrollTarget);
         return;
@@ -14,6 +18,21 @@ function setScrollPosition(scrollTarget) {
     const hash = getUrlHash();
     scrollToHashOrTop(hash);
 }
+// https://github.com/vikejs/vike/issues/2114
+// https://github.com/WICG/scroll-to-text-fragment/issues/261
+function scrollToTextFragment(url) {
+    const stateOriginal = window.history.state;
+    replaceHistoryStateOriginal(null, url);
+    // We need `history.state===null` before location.replace() so that our 'popstate' handling is correct
+    assert(window.history.state === null);
+    // - Chrome's location.replace() keeps the current state (`history.state===stateOriginal`)
+    // - Firefox's location.replace() replaces the current state with `null` (`history.state===null`)
+    window.location.replace(url);
+    replaceHistoryStateOriginal(stateOriginal, url);
+}
+function hasTextFragment(url) {
+    return url.includes('#') && url.includes(':~:text');
+}
 // Replicates the browser's native behavior
 function scrollToHashOrTop(hash) {
     if (!hash) {
@@ -45,9 +64,14 @@ function scrollToTop() {
  * - Let's remove it and see if users complain?
  */
 function setScroll(scrollPosition) {
-    const scroll = () => window.scrollTo(scrollPosition.x, scrollPosition.y);
-    const done = () => window.scrollX === scrollPosition.x && window.scrollY === scrollPosition.y;
-    // In principle, this `done()` call should force the repaint to be finished. But that doesn't seem to be the case with `Firefox 97.0.1`.
+    const scroll = () => {
+        // `window.scrollTo()` respects the CSS `scroll-behavior: smooth` property
+        window.scrollTo(scrollPosition.x, scrollPosition.y);
+    };
+    const done = () => {
+        return window.scrollX === scrollPosition.x && window.scrollY === scrollPosition.y;
+    };
+    // In principle, this `done()` call should force the repaint to be finished, but that doesn't seem to be the case with `Firefox 97.0.1`.
     if (done())
         return;
     scroll();

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

@@ -1,6 +1,4 @@
 export { skipLink };
 export { isSameAsCurrentUrl };
-export { isSamePageHashLink };
 declare function skipLink(linkTag: HTMLElement): boolean;
-declare function isSamePageHashLink(href: string): boolean;
 declare function isSameAsCurrentUrl(href: string): boolean;

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

@@ -1,6 +1,5 @@
 export { skipLink };
 export { isSameAsCurrentUrl };
-export { isSamePageHashLink };
 import { normalizeClientSideUrl } from '../shared/normalizeClientSideUrl.js';
 import { getBaseServer } from './getBaseServer.js';
 import { assert, parseUrl, isBaseServer, isUrl, isUrlExternal } from './utils.js';

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

@@ -21,3 +21,4 @@ export * from '../../utils/onPageVisibilityChange.js';
 export * from '../../utils/augmentType.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/catchInfiniteLoop.js';

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

@@ -25,3 +25,4 @@ export * from '../../utils/onPageVisibilityChange.js';
 export * from '../../utils/augmentType.js';
 export * from '../../utils/PROJECT_VERSION.js';
 export * from '../../utils/genPromise.js';
+export * from '../../utils/catchInfiniteLoop.js';

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

@@ -1,13 +1,13 @@
 export { getPageContext };
 import { assertUsage, assertWarning, objectAssign } from './utils.js';
 import { getPageContextSerializedInHtml } from '../shared/getPageContextSerializedInHtml.js';
-import { getPageFilesAll, setPageFiles } from '../../shared/getPageFiles/getPageFiles.js';
 import { loadUserFilesClientSide } from '../shared/loadUserFilesClientSide.js';
 import { getCurrentUrl } from '../shared/getCurrentUrl.js';
+import { getPageConfigsRuntime } from '../../shared/getPageConfigsRuntime.js';
 // @ts-ignore
-import * as pageFilesExports from 'virtual:vike:importUserCode:client:server-routing';
+import * as virtualFileExports from 'virtual:vike:importUserCode:client:server-routing';
+const { pageFilesAll, pageConfigs } = getPageConfigsRuntime(virtualFileExports);
 const urlFirst = getCurrentUrl({ withoutHash: true });
-setPageFiles(pageFilesExports);
 async function getPageContext() {
     const pageContext = getPageContextSerializedInHtml();
     objectAssign(pageContext, {
@@ -26,7 +26,6 @@ function assertPristineUrl() {
 }
 async function loadPageUserFiles(pageId) {
     const pageContextAddendum = {};
-    const { pageFilesAll, pageConfigs } = await getPageFilesAll(true);
     objectAssign(pageContextAddendum, {
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs

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

@@ -1,6 +1,7 @@
 export { loadUserFilesClientSide };
 export { isErrorFetchingStaticAssets };
-import { getPageFilesClientSide, getPageConfigUserFriendly } from '../../shared/getPageFiles.js';
+import { getPageFilesClientSide } from '../../shared/getPageFiles.js';
+import { getPageConfigUserFriendlyOld } from '../../shared/page-configs/getPageConfigUserFriendly.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 +30,7 @@ async function loadUserFilesClientSide(pageId, pageFilesAll, pageConfigs) {
         }
         throw err;
     }
-    const pageContextExports = getPageConfigUserFriendly(pageFilesClientSide, pageConfigLoaded);
+    const pageContextExports = getPageConfigUserFriendlyOld(pageFilesClientSide, pageConfigLoaded);
     const pageContextAddendum = {};
     objectAssign(pageContextAddendum, pageContextExports);
     objectAssign(pageContextAddendum, { _pageFilesLoaded: pageFilesClientSide });

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,37 +1,43 @@
 export { build };
 import { prepareViteApiCall } from './prepareViteApiCall.js';
-import { build as buildVite } from 'vite';
-import { isPrerenderAutoRunEnabled } from '../prerender/isPrerenderAutoRunEnabled.js';
+import { build as buildVite, version } from 'vite';
+import assert from 'assert';
+import { isVikeCli } from '../cli/context.js';
+import { isPrerendering } from '../prerender/context.js';
+import { assertVersion } from './utils.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 (isPrerenderAutoRunEnabled(vikeConfigGlobal)) {
-        const { runPrerenderFromAutoRun } = await import('../prerender/runPrerender.js');
-        await runPrerenderFromAutoRun(viteConfigEnhanced);
+    const { viteConfigEnhanced, vikeConfig } = await prepareViteApiCall(options.viteConfig, 'build');
+    // Pass it to autoFullBuild()
+    if (viteConfigEnhanced)
+        viteConfigEnhanced._viteConfigEnhanced = viteConfigEnhanced;
+    if (vikeConfig.global.config.viteEnvironmentAPI) {
+        assertVersion('Vite', version, '6.0.0');
+        const { createBuilder } = await import('vite');
+        const builder = await createBuilder(viteConfigEnhanced);
+        await builder.buildApp();
+    }
+    else {
+        // This buildVite() call does everything:
+        // 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);
+        // After pre-rendering, when using the Vike CLI, the process is forcefully exited at the end of the buildVite() call above.
+        if (isVikeCli() && isPrerendering())
+            assert(false);
     }
     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,7 +1,7 @@
-export { setOperation };
-export { clearOperation };
 export { isVikeCliOrApi };
+export { setContextApiOperation };
+export { clearContextApiOperation };
 import type { Operation } from './types.js';
 declare function isVikeCliOrApi(): boolean;
-declare function setOperation(operation: Operation): void;
-declare function clearOperation(): void;
+declare function setContextApiOperation(operation: Operation): void;
+declare function clearContextApiOperation(): void;

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

@@ -1,12 +1,9 @@
-// export { getOperation }
-export { setOperation };
-export { clearOperation };
 export { isVikeCliOrApi };
+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;
 }
@@ -14,10 +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 clearOperation() {
+function clearContextApiOperation() {
     globalObject.apiOperation = undefined;
 }

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

@@ -4,10 +4,11 @@ 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<{
+import { type VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+declare function prepareViteApiCall(viteConfigFromOptions: InlineConfig | undefined, operation: Operation): Promise<{
+    vikeConfig: VikeConfigObject;
     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 getViteRoot(operation: Operation): Promise<string>;
 declare function normalizeViteRoot(root: string): string;
 declare function assertViteRoot(root: string, config: ResolvedConfig): void;

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

@@ -4,40 +4,41 @@ 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 { clearContextApiOperation, setContextApiOperation } from './context.js';
 import { getVikeConfig2 } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 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) {
+async function prepareViteApiCall(viteConfigFromOptions, operation) {
     clear();
-    setOperation(operation);
-    return enhanceViteConfig(viteConfig, operation);
+    setContextApiOperation(operation);
+    return enhanceViteConfig(viteConfigFromOptions, operation);
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {
-    clearOperation();
+    clearContextApiOperation();
     clearGlobalContext();
 }
-async function enhanceViteConfig(viteConfig, operation) {
-    const viteInfo = await getInfoFromVite(viteConfig, operation);
+async function enhanceViteConfig(viteConfigFromOptions, operation) {
+    const viteInfo = await getInfoFromVite(viteConfigFromOptions, 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: vikeConfig.vikeConfigGlobal
+        vikeConfig,
+        viteConfigEnhanced
     };
 }
 function addViteSettingsSetByVikeConfig(viteConfigEnhanced, vikeConfig) {
-    const viteConfigs = vikeConfig.global.from.configsCumulative.vite;
+    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);
+        assertUsage(findVikeVitePlugin(v.value), "Using the +vite setting to add Vike's Vite plugin is forbidden");
     });
     return viteConfigEnhanced;
 }
@@ -47,13 +48,14 @@ async function getViteRoot(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());
+async function getInfoFromVite(viteConfigFromOptions, operation) {
+    const viteConfigFromUserViteFile = await loadViteConfigFile(viteConfigFromOptions, operation);
+    const root = normalizeViteRoot(viteConfigFromUserViteFile?.root ?? viteConfigFromOptions?.root ?? process.cwd());
     globalObject.root = root;
     let vikeVitePluginOptions;
-    let viteConfigEnhanced = viteConfig;
-    const found = findVikeVitePlugin([...(viteConfig?.plugins ?? []), ...(viteConfigFromFile?.plugins ?? [])]);
+    let viteConfigEnhanced = viteConfigFromOptions;
+    // If Vike's Vite plugin is found in both viteConfigFromOptions and viteConfigFromUserViteFile then Vike will later throw an error
+    const found = findVikeVitePlugin(viteConfigFromOptions) || findVikeVitePlugin(viteConfigFromUserViteFile);
     if (found) {
         vikeVitePluginOptions = found.vikeVitePluginOptions;
     }
@@ -62,20 +64,20 @@ async function getInfoFromVite(viteConfig, operation) {
         // 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()]
+            ...viteConfigFromOptions,
+            plugins: [...(viteConfigFromOptions?.plugins ?? []), vikePlugin()]
         };
-        const res = findVikeVitePlugin(viteConfigEnhanced.plugins);
+        const res = findVikeVitePlugin(viteConfigEnhanced);
         assert(res);
         vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
     assert(vikeVitePluginOptions);
     return { root, vikeVitePluginOptions, viteConfigEnhanced };
 }
-function findVikeVitePlugin(plugins) {
+function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
     let vikeVitePuginFound = false;
-    plugins.forEach((p) => {
+    viteConfig?.plugins?.forEach((p) => {
         if (p && '__vikeVitePluginOptions' in p) {
             vikeVitePuginFound = true;
             const options = p.__vikeVitePluginOptions;
@@ -88,8 +90,8 @@ function findVikeVitePlugin(plugins) {
     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);
+async function loadViteConfigFile(viteConfigFromOptions, operation) {
+    const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = getResolveConfigArgs(viteConfigFromOptions, operation);
     let config = inlineConfig;
     let mode = inlineConfig.mode || defaultMode;
     const configEnv = {

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

@@ -1,6 +1,7 @@
 export { prerender };
 import { runPrerenderFromAPI } from '../prerender/runPrerender.js';
 import { prepareViteApiCall } from './prepareViteApiCall.js';
+// TODO/soon use importServerProductionIndex()
 /**
  * Programmatically trigger `$ vike prerender`
  *

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

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

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

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

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();
     }

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: "build" | "dev" | "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

@@ -2,6 +2,34 @@ export default plugin;
 export { plugin };
 export { plugin as ssr };
 export type { VikeVitePluginOptions as UserConfig };
+export type { VikeVitePluginOptions };
 export { PROJECT_VERSION as version } from './utils.js';
-import type { VikeVitePluginOptions } from './plugins/importUserCode/v1-design/getVikeConfig.js';
 declare function plugin(vikeVitePluginOptions?: VikeVitePluginOptions): any;
+/** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+type VikeVitePluginOptions = {
+    /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+    prerender?: boolean | {
+        /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+        noExtraDir?: boolean;
+        /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+        parallel?: boolean | number;
+        /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+        partial?: boolean;
+        /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+        disableAutoRun?: boolean;
+    };
+    /** @deprecated See https://vike.dev/disableAutoFullBuild */
+    disableAutoFullBuild?: boolean | 'prerender';
+    /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+    baseServer?: string;
+    /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+    baseAssets?: string;
+    /** @deprecated It's now `true` by default. You can remove this option. */
+    includeAssetsImportedByServer?: boolean;
+    /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+    redirects?: Record<string, string>;
+    /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+    trailingSlash?: boolean;
+    /** @deprecated Define Vike settings in +config.js instead of vite.config.js */
+    disableUrlNormalization?: boolean;
+};

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

@@ -3,8 +3,7 @@ export { plugin };
 // TODO/v1-release: remove
 export { plugin as ssr };
 export { PROJECT_VERSION as version } from './utils.js';
-import { version } from 'vite';
-import { assertUsage, assertVersion, markSetup_vikeVitePlugin } from './utils.js';
+import { assertUsage } from './utils.js';
 import { buildConfig } from './plugins/buildConfig.js';
 import { previewConfig } from './plugins/previewConfig.js';
 import { autoFullBuild } from './plugins/autoFullBuild.js';
@@ -24,11 +23,11 @@ import { envVarsPlugin } from './plugins/envVars.js';
 import pc from '@brillout/picocolors';
 import { fileEnv } from './plugins/fileEnv.js';
 import { setResolveClientEntriesDev } from '../runtime/renderPage/getPageAssets.js';
-import { resolveClientEntriesDev } from './resolveClientEntriesDev.js';
+import { resolveClientEntriesDev } from './shared/resolveClientEntriesDev.js';
 import { workaroundCssModuleHmr } from './plugins/workaroundCssModuleHmr.js';
 import { workaroundVite6HmrRegression } from './plugins/workaroundVite6HmrRegression.js';
-markSetup_vikeVitePlugin();
-assertViteVersion();
+import { buildApp } from './plugins/buildApp.js';
+// We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setResolveClientEntriesDev(resolveClientEntriesDev);
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
 function plugin(vikeVitePluginOptions = {}) {
@@ -37,6 +36,7 @@ function plugin(vikeVitePluginOptions = {}) {
         importUserCode(),
         ...devConfig(),
         ...buildConfig(),
+        ...buildApp(),
         previewConfig(),
         ...autoFullBuild(),
         packageJsonFile(),
@@ -63,10 +63,6 @@ Object.defineProperty(plugin, 'apply', {
         assertUsage(false, `Add ${pc.cyan('vike()')} instead of ${pc.cyan('vike')} to vite.config.js#plugins (i.e. call the function and add the return value instead of adding the function itself)`, { showStackTrace: true });
     }
 });
-// package.json#peerDependencies isn't enough as users can ignore it
-function assertViteVersion() {
-    assertVersion('Vite', version, '5.1.0');
-}
 // Ensures following works: `const vike = require('vike/plugin')` / `import vike from 'vike/plugin'`
 //  - It needs to live at the end of this file, in order to ensure we do it after all assignments to `exports`.
 try {

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

@@ -1,10 +1,15 @@
 export { onLoad };
 import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
-import { assertIsNotProductionRuntime } from '../../utils/assertSetup.js';
+import { assertIsNotProductionRuntime, markSetup_vikeVitePlugin } from '../../utils/assertSetup.js';
 import { assertNodeVersion } from '../../utils/assertNodeVersion.js';
+import { assertVersion } from '../../utils/assertVersion.js';
+import { version } from 'vite';
 function onLoad() {
+    markSetup_vikeVitePlugin();
     assertIsNotBrowser();
     assertNodeVersion();
-    // Ensure we don't bloat the server runtime with heavy plugin dependencies such as esbuild
+    // package.json#peerDependencies isn't enough as users often ignore it
+    assertVersion('Vite', version, '5.1.0');
+    // Ensure we don't bloat the server runtime with heavy dependencies such Vite and esbuild
     assertIsNotProductionRuntime();
 }