vike 0.4.259-commit-dcc116b → 0.4.259-commit-286bd57

package/dist/node/api/build.js

@@ -8,16 +8,16 @@ import './assertEnvApiDev.js';
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'build');
+    const { viteConfigUser } = await prepareViteApiCall(options, 'build');
     // Pass it to vike:build:pluginBuildApp
-    if (viteConfigFromUserResolved)
-        viteConfigFromUserResolved._viteConfigFromUserResolved = viteConfigFromUserResolved;
-    const builder = await createBuilder(viteConfigFromUserResolved);
+    if (viteConfigUser)
+        viteConfigUser._viteConfigUser = viteConfigUser;
+    const builder = await createBuilder(viteConfigUser);
     // buildApp() is implemented by vike:build:pluginBuildApp
     await builder.buildApp();
     return {
-    /* We don't return `viteConfig` because `viteConfigFromUserResolved` is `InlineConfig` not `ResolvedConfig`
-    viteConfig: viteConfigFromUserResolved,
+    /* We don't return `viteConfig` because `viteConfigUser` is `InlineConfig` not `ResolvedConfig`
+    viteConfig: viteConfigUser,
     */
     };
 }

package/dist/node/api/dev.js

@@ -15,8 +15,8 @@ assertIsNotProductionRuntime();
  * https://vike.dev/api#dev
  */
 async function dev(options = {}) {
-    const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'dev');
-    const server = await createServer(viteConfigFromUserResolved);
+    const { viteConfigUser } = await prepareViteApiCall(options, 'dev');
+    const server = await createServer(viteConfigUser);
     const viteServer = server;
     const viteConfig = server.config;
     const viteVersion = viteConfig._viteVersionResolved;

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

@@ -3,5 +3,5 @@ import type { ApiOptions, ApiOperation } from './types.js';
 import './assertEnvApiDevAndProd.js';
 declare function prepareViteApiCall(options: ApiOptions, operation: ApiOperation): Promise<{
     viteConfigResolved: import("vite").ResolvedConfig;
-    viteConfigFromUserResolved: import("vite").UserConfig;
+    viteConfigUser: import("vite").UserConfig;
 }>;

package/dist/node/api/prepareViteApiCall.js

@@ -1,12 +1,12 @@
 export { prepareViteApiCall };
 import { clearContextVikeApiOperation, setContextVikeApiOperation } from '../../shared-server-node/api-context.js';
 import { clearGlobalContext } from '../../server/runtime/globalContext.js';
-import { resolveViteConfigFromUser } from './resolveViteConfigFromUser.js';
+import { resolveViteConfigUser } from './resolveViteConfigUser.js';
 import './assertEnvApiDevAndProd.js';
 async function prepareViteApiCall(options, operation) {
     clear();
     setContextVikeApiOperation(operation, options);
-    return resolveViteConfigFromUser();
+    return resolveViteConfigUser();
 }
 // For subsequent API calls, e.g. calling prerender() after build()
 function clear() {

package/dist/node/api/prerender.js

@@ -8,8 +8,8 @@ import './assertEnvApiDevAndProd.js';
  * https://vike.dev/api#prerender
  */
 async function prerender(options = {}) {
-    const { viteConfigFromUserResolved } = await prepareViteApiCall(options, 'prerender');
-    options.viteConfig = viteConfigFromUserResolved;
+    const { viteConfigUser } = await prepareViteApiCall(options, 'prerender');
+    options.viteConfig = viteConfigUser;
     const { viteConfig } = await runPrerenderFromAPI(options);
     return {
         viteConfig,

package/dist/node/api/preview.js

@@ -19,7 +19,7 @@ import { getStartupLogFirstLine } from './getStartupLogFirstLine.js';
  */
 async function preview(options = {}) {
     onSetupPreview();
-    const { viteConfigFromUserResolved, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
+    const { viteConfigUser, viteConfigResolved } = await prepareViteApiCall(options, 'preview');
     const vikeConfig = await getVikeConfigInternal();
     const cliPreviewConfig = await resolveCliPreviewConfig(vikeConfig);
     assertUsage(cliPreviewConfig !== false, `${pc.cyan('$ vike preview')} isn't supported`);
@@ -53,7 +53,7 @@ async function preview(options = {}) {
     }
     else {
         // Use Vite's preview server
-        const server = await previewVite(viteConfigFromUserResolved);
+        const server = await previewVite(viteConfigUser);
         logHint(vikeConfig.prerenderContext.isPrerenderingEnabledForAllPages
             ? ' — your app is fully pre-rendered and can be statically deployed.'
             : '', isStartupLogCompact);

package/dist/node/api/{resolveViteConfigFromUser.d.ts → resolveViteConfigUser.d.ts}

@@ -1,17 +1,17 @@
-export { resolveViteConfigFromUser };
-export { isOnlyResolvingUserConfig };
+export { resolveViteConfigUser };
+export { isResolvingViteConfigUser };
 export { getVikeConfigInternalEarly };
 export { getViteRoot };
 export { assertViteRoot };
 export { normalizeViteRoot };
 import type { ResolvedConfig, UserConfig } from 'vite';
 import './assertEnvApiDevAndProd.js';
-declare function resolveViteConfigFromUser(): Promise<{
+declare function resolveViteConfigUser(): Promise<{
     viteConfigResolved: ResolvedConfig;
-    viteConfigFromUserResolved: UserConfig;
+    viteConfigUser: UserConfig;
 }>;
 declare function getVikeConfigInternalEarly(): Promise<import("../vite/shared/resolveVikeConfigInternal.js").VikeConfigInternal>;
-declare function isOnlyResolvingUserConfig(): boolean | undefined;
+declare function isResolvingViteConfigUser(): boolean | undefined;
 declare function getViteRoot(viteContext: ViteContext): Promise<string>;
 type ViteContext = 'build' | 'preview' | 'dev';
 declare function normalizeViteRoot(root: string): string;

package/dist/node/api/{resolveViteConfigFromUser.js → resolveViteConfigUser.js}

@@ -1,5 +1,5 @@
-export { resolveViteConfigFromUser };
-export { isOnlyResolvingUserConfig };
+export { resolveViteConfigUser };
+export { isResolvingViteConfigUser };
 export { getVikeConfigInternalEarly };
 export { getViteRoot };
 export { assertViteRoot };
@@ -16,96 +16,95 @@ import { getEnvVarObject } from '../vite/shared/getEnvVarObject.js';
 import { getVikeApiOperation, isVikeCliOrApi } from '../../shared-server-node/api-context.js';
 import { getViteCliCommand, getViteCliArgs } from '../vite/shared/isViteCli.js';
 import './assertEnvApiDevAndProd.js';
-const globalObject = getGlobalObject('api/prepareViteApiCall.ts', {});
-async function resolveViteConfigFromUser() {
+const globalObject = getGlobalObject('resolveViteConfigUser.ts', {});
+async function resolveViteConfigUser() {
     const { viteContext } = getVikeApiContext();
     assert(viteContext);
-    const viteInfo = await getViteInfo(viteContext);
-    const { viteConfigFromUserResolved } = viteInfo;
-    const { viteConfigResolved } = await assertViteRoot2(viteInfo.root, viteConfigFromUserResolved, viteContext);
+    const { viteConfigUser, root } = await resolve(viteContext);
+    const { viteConfigResolved } = await assertViteRoot2(root, viteConfigUser, viteContext);
     return {
         viteConfigResolved, // ONLY USE if strictly necessary. (We plan to remove assertViteRoot2() as explained in the comments of that function.)
-        viteConfigFromUserResolved,
+        viteConfigUser,
     };
 }
 async function getVikeConfigInternalEarly() {
-    assert(!globalObject.isOnlyResolvingUserConfig); // ensure no infinite loop
+    assert(!globalObject.isResolvingViteConfigUser); // ensure no infinite loop
     if (!isVikeConfigContextSet()) {
         const viteContext = getViteContext();
-        const viteInfo = await getViteInfo(viteContext);
-        setVikeConfigContext_(viteInfo, viteContext);
+        const resolved = await resolve(viteContext);
+        setVikeConfigContext_(resolved, viteContext);
     }
     return await getVikeConfigInternal();
 }
-function setVikeConfigContext_(viteInfo, viteContext) {
+function setVikeConfigContext_(resolved, viteContext) {
     setVikeConfigContext({
-        userRootDir: viteInfo.root,
+        userRootDir: resolved.root,
         isDev: viteContext === 'dev',
-        vikeVitePluginOptions: viteInfo.vikeVitePluginOptions,
+        vikeVitePluginOptions: resolved.vikeVitePluginOptions,
     });
 }
-function isOnlyResolvingUserConfig() {
-    return globalObject.isOnlyResolvingUserConfig;
+function isResolvingViteConfigUser() {
+    return globalObject.isResolvingViteConfigUser;
 }
 async function getViteRoot(viteContext) {
     if (!globalObject.root)
-        await getViteInfo(viteContext);
+        await resolve(viteContext);
     assert(globalObject.root);
     return globalObject.root;
 }
-// TODO rename to resolveViteConfig
-// TODO rename_all viteConfigFromUser viteConfigFrom
-// TODO rename_all vikeConfigFromUser vikeConfigFrom
-async function getViteInfo(viteContext) {
+async function resolve(viteContext) {
     // Precedence:
-    // 1. (highest precedence)  |  viteConfigFromUserEnvVar          |  VITE_CONFIG
-    // 2.                       |  viteConfigFromVikeCliOrEnv        |  VIKE_CONFIG & Vike CLI options — `+mode` & `+root`
-    // 3.                       |  viteConfigFromUserViteCli         |  Vite CLI args — `[root]` & `-c/--config`
-    // 4.                       |  viteConfigFromUserVikeApiOptions  |  Vike API options — `viteConfig`, and `+mode` & `+root` from `vikeConfig`
-    // 5. (lowest precedence)   |  viteConfigFromUserViteConfigFile  |  vite.config.js
-    let viteConfigFromUserResolved = {};
+    // 1. (highest precedence)  |  viteConfigFromViteEnv       |  VITE_CONFIG
+    // 2.                       |  viteConfigFromVikeCliOrEnv  |  VIKE_CONFIG & Vike CLI options — `+mode` & `+root`
+    // 3.                       |  viteConfigFromViteCli       |  Vite CLI args — `[root]` & `-c/--config`
+    // 4.                       |  viteConfigFromVikeApi       |  Vike API options — `viteConfig`, and `+mode` & `+root` from `vikeConfig`
+    // 5. (lowest precedence)   |  viteConfigFromViteFile      |  vite.config.js
+    let viteConfigUser = {};
+    const addConfig = (c) => {
+        // Merge `c` overriding viteConfigUser (`c` wins — higher precedence)
+        viteConfigUser = mergeConfig(viteConfigUser, c ?? {});
+    };
+    const underride = (c) => {
+        // Merge `c` underiding viteConfigUser (`c` loses — lower precedence)
+        return mergeConfig(c ?? {}, viteConfigUser);
+    };
     // Vike API args
-    const { viteConfigFromUserVikeApiOptions, vikeConfigFromUserVikeApiOptions } = getVikeApiContext();
-    // - Resolve `viteConfig` set over Vike's API
-    viteConfigFromUserResolved = merge(viteConfigFromUserResolved, viteConfigFromUserVikeApiOptions ?? {});
-    // - Resolve +mode/+root set over Vike's API
     {
-        const viteConfigFromVikeApi2 = pick(vikeConfigFromUserVikeApiOptions ?? {}, EARLY_SETTINGS);
-        viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromVikeApi2);
+        const { viteConfigFromVikeApi, vikeConfigFromApi } = getVikeApiContext();
+        addConfig(viteConfigFromVikeApi); // `viteConfig`
+        addConfig(pick(vikeConfigFromApi ?? {}, EARLY_SETTINGS)); // `+mode` & `+root`
     }
     // Vite CLI args (when invoked via Vite's CLI rather than Vike's API).
     // - Without this, Vike loads vite.config.js blind to `vite [root]` / `-c <file>` and ends up with the wrong root when those Vite CLI args are used.
-    const viteConfigFromUserViteCli = getViteCliArgs();
-    if (viteConfigFromUserViteCli) {
-        viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromUserViteCli);
+    {
+        const viteConfigFromViteCli = getViteCliArgs();
+        addConfig(viteConfigFromViteCli);
     }
-    // Vike's CLI and VIKE_CONFIG
-    // - Resolve +mode/+root set over Vike's CLI or VIKE_CONFIG
+    // Vike's CLI and VIKE_CONFIG — `+mode` & `+root`
     {
         const viteConfigFromVikeCliOrEnv = pick(getVikeConfigFromCliOrEnv().vikeConfigFromCliOrEnv, EARLY_SETTINGS);
-        if (Object.keys(viteConfigFromVikeCliOrEnv).length > 0) {
-            viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromVikeCliOrEnv);
-        }
+        addConfig(viteConfigFromVikeCliOrEnv);
     }
-    // Resolve VITE_CONFIG
-    const viteConfigFromUserEnvVar = getEnvVarObject('VITE_CONFIG');
-    if (viteConfigFromUserEnvVar) {
-        viteConfigFromUserResolved = merge(viteConfigFromUserResolved ?? {}, viteConfigFromUserEnvVar);
+    // VITE_CONFIG
+    {
+        const viteConfigFromViteEnv = getEnvVarObject('VITE_CONFIG');
+        addConfig(viteConfigFromViteEnv);
     }
-    // Resolve vite.config.js
-    globalObject.isOnlyResolvingUserConfig = true;
-    const viteConfigFromUserViteConfigFile = await loadViteConfigFile(viteConfigFromUserResolved, viteContext);
-    globalObject.isOnlyResolvingUserConfig = false;
-    // Lowest precedence. The `merge()` applies the correct precedence and replicates Vite:
-    // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
-    const viteConfigResolved = merge(viteConfigFromUserViteConfigFile ?? {}, viteConfigFromUserResolved ?? {});
-    const root = normalizeViteRoot(viteConfigResolved.root ?? process.cwd());
+    // vite.config.js — lowest precedence. Merged into a *separate* result (used only to compute `root` and to
+    // find the Vike plugin): it must not flow back into `viteConfigUser`, which is handed to Vite —
+    // Vite loads vite.config.js itself, so merging it here would add the Vike plugin twice.
+    // Replicates Vite: https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1001
+    globalObject.isResolvingViteConfigUser = true;
+    const viteConfigFromViteFile = await loadViteConfigFile(viteConfigUser, viteContext);
+    globalObject.isResolvingViteConfigUser = false;
+    const viteConfigAll = underride(viteConfigFromViteFile ?? {});
+    const root = normalizeViteRoot(viteConfigAll.root ?? process.cwd());
     globalObject.root = root;
     // - Find options `vike(options)` set in vite.config.js
     //   - TO-DO/next-major-release: remove
     // - Add Vike's Vite plugin if missing
     let vikeVitePluginOptions;
-    const found = findVikeVitePlugin(viteConfigResolved);
+    const found = findVikeVitePlugin(viteConfigAll);
     if (found) {
         vikeVitePluginOptions = found.vikeVitePluginOptions;
     }
@@ -113,25 +112,21 @@ async function getViteInfo(viteContext) {
         // Show a warning because Vike supports Vite's CLI (as well as third-party CLIs).
         // - Encourage users to define a vite.config.js file that also works with Vite's CLI (and potentially other third-party CLIs).
         // - Vike-based frameworks, such as DocPress, allow their users to omit defining a vite.config.js file.
-        assertWarning(!viteConfigFromUserViteConfigFile, // Only show the warning if the user defined a vite.config.js file
+        assertWarning(!viteConfigFromViteFile, // Only show the warning if the user defined a vite.config.js file
         "Omitting Vike's Vite plugin (inside your vite.config.js) is deprecated — make sure to always add Vike's Vite plugin https://vike.dev/vite-plugin", { onlyOnce: true });
         // 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('../vite/index.js');
-        viteConfigFromUserResolved = {
-            ...viteConfigFromUserResolved,
-            plugins: [...(viteConfigFromUserResolved?.plugins ?? []), vikePlugin()],
+        viteConfigUser = {
+            ...viteConfigUser,
+            plugins: [...(viteConfigUser?.plugins ?? []), vikePlugin()],
         };
-        const res = findVikeVitePlugin(viteConfigFromUserResolved);
+        const res = findVikeVitePlugin(viteConfigUser);
         assert(res);
         vikeVitePluginOptions = res.vikeVitePluginOptions;
     }
     assert(vikeVitePluginOptions);
-    return { root, vikeVitePluginOptions, viteConfigFromUserResolved };
-}
-/** `c2` overrides `c1` */
-function merge(c1, c2) {
-    return mergeConfig(c1, c2);
+    return { viteConfigUser, root, vikeVitePluginOptions };
 }
 function findVikeVitePlugin(viteConfig) {
     let vikeVitePluginOptions;
@@ -149,8 +144,8 @@ function findVikeVitePlugin(viteConfig) {
     return { vikeVitePluginOptions };
 }
 // Copied from https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L961-L1005
-async function loadViteConfigFile(viteConfigFromUserResolved, viteContext) {
-    const viteContextResolved = resolveViteContext(viteConfigFromUserResolved, viteContext);
+async function loadViteConfigFile(viteConfigUser, viteContext) {
+    const viteContextResolved = resolveViteContext(viteConfigUser, viteContext);
     const [inlineConfig, command, defaultMode, _defaultNodeEnv, isPreview] = viteContextResolved;
     let config = inlineConfig;
     let mode = inlineConfig.mode || defaultMode;
@@ -206,12 +201,12 @@ function getViteContextWithOperation(operation) {
 function getVikeApiContext() {
     const vikeApiOperation = getVikeApiOperation();
     if (!vikeApiOperation)
-        return { viteConfigFromUserVikeApiOptions: null, vikeConfigFromUserVikeApiOptions: null, viteContext: null };
+        return { viteConfigFromVikeApi: null, vikeConfigFromApi: null, viteContext: null };
     const { options, operation } = vikeApiOperation;
-    const viteConfigFromUserVikeApiOptions = options.viteConfig;
-    const vikeConfigFromUserVikeApiOptions = options.vikeConfig;
+    const viteConfigFromVikeApi = options.viteConfig;
+    const vikeConfigFromApi = options.vikeConfig;
     const viteContext = getViteContextWithOperation(operation);
-    return { viteConfigFromUserVikeApiOptions, vikeConfigFromUserVikeApiOptions, viteContext };
+    return { viteConfigFromVikeApi, vikeConfigFromApi, viteContext };
 }
 function resolveViteContext(inlineConfig = {}, viteContext) {
     const isBuild = viteContext === 'build';
@@ -224,15 +219,15 @@ function resolveViteContext(inlineConfig = {}, viteContext) {
     return viteContextResolved;
 }
 function normalizeViteRoot(root) {
-    // `path.resolve(viteConfigFromUserViteFile.configFile, root)` could be more intuitive than `path.resolve(process.cwd(), root)` but we replicate Vite's behavior (`vite.config.js` should follow Vite's API), see:
+    // `path.resolve(viteConfigUserViteFile.configFile, root)` could be more intuitive than `path.resolve(process.cwd(), root)` but we replicate Vite's behavior (`vite.config.js` should follow Vite's API), see:
     // https://github.com/vitejs/vite/blob/4f5845a3182fc950eb9cd76d7161698383113b18/packages/vite/src/node/config.ts#L1063
     return toPosixPath(
     // Equivalent to `path.resolve(process.cwd(), root)`
     path.resolve(root));
 }
 const errMsg = `A Vite plugin is modifying the Vite setting ${pc.cyan('root')} which is forbidden`;
-async function assertViteRoot2(root, viteConfigFromUserResolved, viteContext) {
-    const viteContextResolved = resolveViteContext(viteConfigFromUserResolved, viteContext);
+async function assertViteRoot2(root, viteConfigUser, viteContext) {
+    const viteContextResolved = resolveViteContext(viteConfigUser, viteContext);
     // We can eventually remove 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 and preview which is required). But let's keep it for now, just to see whether calling resolveConfig() can be problematic.
     const viteConfigResolved = await resolveConfig(...viteContextResolved);
     assertUsage(normalizeViteRoot(viteConfigResolved.root) === normalizeViteRoot(root), errMsg);

package/dist/node/createDevMiddleware.js

@@ -18,8 +18,8 @@ async function createDevMiddleware(options = {}) {
             },
         },
     };
-    const { viteConfigFromUserResolved } = await prepareViteApiCall(optionsMod, 'dev');
-    const server = await createServer(viteConfigFromUserResolved);
+    const { viteConfigUser } = await prepareViteApiCall(optionsMod, 'dev');
+    const server = await createServer(viteConfigUser);
     const devMiddleware = server.middlewares;
     return { devMiddleware, viteServer: server, viteConfig: server.config };
 }

package/dist/node/prerender/runPrerenderEntry.js

@@ -19,8 +19,8 @@ async function runPrerenderFromAPI(options = {}) {
 }
 async function runPrerenderFromCLIPrerenderCommand() {
     try {
-        const { viteConfigFromUserResolved } = await prepareViteApiCall({}, 'prerender');
-        await runPrerender({ viteConfig: viteConfigFromUserResolved }, '$ vike prerender');
+        const { viteConfigUser } = await prepareViteApiCall({}, 'prerender');
+        await runPrerender({ viteConfig: viteConfigUser }, '$ vike prerender');
     }
     catch (err) {
         // Error may come from user-land

package/dist/node/vite/index.js

@@ -37,7 +37,7 @@ import { pluginReplaceConstantsNonRunnableDev } from './plugins/non-runnable-dev
 import { isVikeCliOrApi } from '../../shared-server-node/api-context.js';
 import { pluginViteConfigVikeExtensions } from './plugins/pluginViteConfigVikeExtensions.js';
 import { pluginStripPointerImportAttribute } from './plugins/pluginStripPointerImportAttribute.js';
-import { getVikeConfigInternalEarly, isOnlyResolvingUserConfig } from '../api/resolveViteConfigFromUser.js';
+import { getVikeConfigInternalEarly, isResolvingViteConfigUser } from '../api/resolveViteConfigUser.js';
 import './assertEnvVite.js';
 import { isStorybook } from '../../utils/isStorybook.js';
 import { pluginUniversalDeploy } from './plugins/pluginUniversalDeploy.js';
@@ -96,7 +96,7 @@ function pluginNonRunnabeDev() {
 }
 function removeVitePlugin() {
     // Early resolving of user Vite configs
-    if (isOnlyResolvingUserConfig()) {
+    if (isResolvingViteConfigUser()) {
         return true;
     }
     // *****************/

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

@@ -166,8 +166,8 @@ function isPrerenderForceExit() {
 }
 function getFullBuildInlineConfig(config) {
     const configFromCli = !isViteCli() ? null : getViteBuildCliArgs();
-    if (config._viteConfigFromUserResolved) {
-        return config._viteConfigFromUserResolved;
+    if (config._viteConfigUser) {
+        return config._viteConfigUser;
     }
     else {
         return {

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

@@ -8,7 +8,7 @@ declare module 'vite' {
         _isDev?: boolean;
         _rootResolvedEarly?: string;
         _baseViteOriginal?: string;
-        _viteConfigFromUserResolved?: InlineConfig;
+        _viteConfigUser?: InlineConfig;
         _viteVersionResolved?: string;
     }
 }

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

@@ -9,7 +9,7 @@ import { assertRollupInput } from './build/pluginBuildConfig.js';
 import pc from '@brillout/picocolors';
 import { assertResolveAlias } from './pluginCommon/assertResolveAlias.js';
 import { getVikeConfigInternal, setVikeConfigContext } from '../shared/resolveVikeConfigInternal.js';
-import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/resolveViteConfigFromUser.js';
+import { assertViteRoot, getViteRoot, normalizeViteRoot } from '../../api/resolveViteConfigUser.js';
 import { temp_disablePrerenderAutoRun } from '../../prerender/context.js';
 import { version as viteVersionVike } from 'vite';
 import '../assertEnvVite.js';

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.259-commit-dcc116b";
+export declare const PROJECT_VERSION: "0.4.259-commit-286bd57";

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.259-commit-dcc116b';
+export const PROJECT_VERSION = '0.4.259-commit-286bd57';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.259-commit-dcc116b",
+  "version": "0.4.259-commit-286bd57",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {