vike 0.4.216 → 0.4.217-commit-99ea561

package/dist/cjs/node/runtime/globalContext.js

@@ -14,16 +14,17 @@ exports.initGlobalContext_runPrerender = initGlobalContext_runPrerender;
 exports.initGlobalContext_getGlobalContextAsync = initGlobalContext_getGlobalContextAsync;
 exports.setGlobalContext_viteDevServer = setGlobalContext_viteDevServer;
 exports.setGlobalContext_viteConfig = setGlobalContext_viteConfig;
+exports.setGlobalContext_vikeConfig = setGlobalContext_vikeConfig;
 exports.setGlobalContext_isViteDev = setGlobalContext_isViteDev;
 exports.setGlobalContext_isPrerendering = setGlobalContext_isPrerendering;
 const utils_js_1 = require("./utils.js");
 const loadImportBuild_js_1 = require("./globalContext/loadImportBuild.js");
 const getPageFiles_js_1 = require("../../shared/getPageFiles.js");
 const assertPluginManifest_js_1 = require("../shared/assertPluginManifest.js");
-const getConfigVike_js_1 = require("../shared/getConfigVike.js");
 const assertRuntimeManifest_js_1 = require("../shared/assertRuntimeManifest.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getPageFilesExports_js_1 = require("./page-files/getPageFilesExports.js");
+const resolveBase_js_1 = require("../shared/resolveBase.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('globalContext.ts', (() => {
     const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = (0, utils_js_1.genPromise)();
     return {
@@ -88,6 +89,12 @@ function setGlobalContext_viteConfig(viteConfig, outDirRoot) {
     globalObject.viteConfig = viteConfig;
     globalObject.outDirRoot = outDirRoot;
 }
+function setGlobalContext_vikeConfig(vikeConfig) {
+    if (globalObject.vikeConfig)
+        return;
+    assertIsNotInitilizedYet();
+    globalObject.vikeConfig = vikeConfig;
+}
 function assertIsNotInitilizedYet() {
     // In develpoment, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
     (0, utils_js_1.assert)(!globalObject.globalContext);
@@ -141,14 +148,15 @@ async function initGlobalContext(isProduction) {
         (0, utils_js_1.assert)(globalObject.globalContext.isPrerendering === (globalObject.isPrerendering ?? false));
         return;
     }
-    const { viteDevServer, viteConfig, isPrerendering } = globalObject;
+    const { viteDevServer, viteConfig, vikeConfig, isPrerendering } = globalObject;
     (0, utils_js_1.onSetupRuntime)();
     if (!isProduction) {
         (0, utils_js_1.assert)(viteConfig);
+        (0, utils_js_1.assert)(vikeConfig);
         (0, utils_js_1.assert)(viteDevServer);
         (0, utils_js_1.assert)(!isPrerendering);
-        const configVike = await (0, getConfigVike_js_1.getConfigVike)(viteConfig);
-        const pluginManifest = getRuntimeManifest(configVike);
+        const vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
+        const pluginManifest = getRuntimeManifest(vikeConfigGlobal, viteConfig);
         globalObject.globalContext = {
             isProduction: false,
             isPrerendering: false,
@@ -156,6 +164,7 @@ async function initGlobalContext(isProduction) {
             pluginManifest: null,
             viteDevServer,
             viteConfig,
+            vikeConfig,
             baseServer: pluginManifest.baseServer,
             baseAssets: pluginManifest.baseAssets,
             includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
@@ -185,8 +194,6 @@ async function initGlobalContext(isProduction) {
         };
         if (isPrerendering) {
             (0, utils_js_1.assert)(viteConfig);
-            const configVike = await (0, getConfigVike_js_1.getConfigVike)(viteConfig);
-            (0, utils_js_1.assert)(configVike);
             (0, utils_js_1.objectAssign)(globalContext, {
                 isPrerendering: true,
                 viteConfig
@@ -202,8 +209,9 @@ async function initGlobalContext(isProduction) {
         }
     }
 }
-function getRuntimeManifest(configVike) {
-    const { includeAssetsImportedByServer, baseServer, baseAssets, redirects, trailingSlash, disableUrlNormalization } = configVike;
+function getRuntimeManifest(vikeConfigGlobal, viteConfig) {
+    const { includeAssetsImportedByServer, redirects, trailingSlash, disableUrlNormalization } = vikeConfigGlobal;
+    const { baseServer, baseAssets } = (0, resolveBase_js_1.resolveBaseFromResolvedConfig)(vikeConfigGlobal.baseServer, vikeConfigGlobal.baseAssets, viteConfig);
     const manifest = {
         baseServer,
         baseAssets,

package/dist/cjs/node/runtime/renderPage/renderPageAlreadyRouted.js

@@ -126,7 +126,7 @@ function getPageContextInitEnhanced(pageContextInit, renderContext, { ssr: { url
     (0, utils_js_1.objectAssign)(pageContextInitEnhanced, pageContextInit);
     (0, utils_js_1.objectAssign)(pageContextInitEnhanced, {
         _objectCreatedByVike: true,
-        // The following is defined on `pageContext` because we can eventually make these non-global (e.g. sot that two pages can have different includeAssetsImportedByServer settings)
+        // The following is defined on `pageContext` because we can eventually make these non-global
         _baseServer: globalContext.baseServer,
         _baseAssets: globalContext.baseAssets,
         _includeAssetsImportedByServer: globalContext.includeAssetsImportedByServer,

package/dist/cjs/node/shared/resolveBase.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBase = resolveBase;
+exports.resolveBaseFromResolvedConfig = resolveBaseFromResolvedConfig;
+const utils_js_1 = require("./utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
+    let baseViteOriginal = config._baseViteOriginal;
+    if (baseViteOriginal === '/__UNSET__')
+        baseViteOriginal = null;
+    (0, utils_js_1.assert)(baseViteOriginal === null || typeof baseViteOriginal == 'string');
+    return resolveBase(baseViteOriginal, baseServer, baseAssets);
+}
+function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved) {
+    {
+        const wrongBase = (val) => `should start with ${picocolors_1.default.cyan('/')}, ${picocolors_1.default.cyan('http://')}, or ${picocolors_1.default.cyan('https://')} (it's ${picocolors_1.default.cyan(val)} instead)`;
+        (0, utils_js_1.assertUsage)(baseViteOriginal === null || (0, utils_js_1.isBaseAssets)(baseViteOriginal), `vite.config.js#base ${wrongBase(baseViteOriginal)}`);
+        (0, utils_js_1.assertUsage)(baseAssetsUnresolved === null || (0, utils_js_1.isBaseAssets)(baseAssetsUnresolved), `Config ${picocolors_1.default.cyan('baseAssets')} ${wrongBase(baseAssetsUnresolved)}`);
+        (0, utils_js_1.assertUsage)(baseServerUnresolved === null || baseServerUnresolved.startsWith('/'), `Config ${picocolors_1.default.cyan('baseServer')} should start with a leading slash ${picocolors_1.default.cyan('/')} (it's ${picocolors_1.default.cyan(String(baseServerUnresolved))} instead)`);
+    }
+    if (baseViteOriginal) {
+        if (baseViteOriginal.startsWith('http')) {
+            baseAssetsUnresolved = baseAssetsUnresolved ?? baseViteOriginal;
+        }
+        else {
+            baseAssetsUnresolved = baseAssetsUnresolved ?? baseViteOriginal;
+            baseServerUnresolved = baseServerUnresolved ?? baseViteOriginal;
+        }
+    }
+    const baseServer = baseServerUnresolved ?? '/';
+    const baseAssets = baseAssetsUnresolved ?? '/';
+    (0, utils_js_1.assert)((0, utils_js_1.isBaseAssets)(baseAssets));
+    (0, utils_js_1.assert)((0, utils_js_1.isBaseServer)(baseServer));
+    return {
+        baseServer,
+        baseAssets
+    };
+}

package/dist/cjs/utils/PROJECT_VERSION.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.216';
+exports.PROJECT_VERSION = '0.4.217-commit-99ea561';

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

@@ -7,13 +7,15 @@ import { build as buildVite } from 'vite';
  * https://vike.dev/api#build
  */
 async function build(options = {}) {
-    const { viteConfigEnhanced, configVike } = await prepareViteApiCall(options.viteConfig, 'build');
+    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 (configVike.prerender && !configVike.prerender.disableAutoRun && configVike.disableAutoFullBuild !== 'prerender') {
+    if (vikeConfigGlobal.prerender &&
+        !vikeConfigGlobal.prerender.disableAutoRun &&
+        vikeConfigGlobal.disableAutoFullBuild !== 'prerender') {
         const { runPrerenderFromAutoRun } = await import('../prerender/runPrerender.js');
         await runPrerenderFromAutoRun(viteConfigEnhanced, true);
     }

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

@@ -3,5 +3,5 @@ import type { InlineConfig } from 'vite';
 import type { Operation } from './types.js';
 declare function prepareViteApiCall(viteConfig: InlineConfig | undefined, operation: Operation): Promise<{
     viteConfigEnhanced: InlineConfig;
-    configVike: import("../../shared/ConfigVike.js").ConfigVikeResolved;
+    vikeConfigGlobal: import("../plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js").VikeConfigGlobal;
 }>;

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

@@ -1,8 +1,8 @@
 export { prepareViteApiCall };
 import { resolveConfig } from 'vite';
-import { getConfigVike } from '../shared/getConfigVike.js';
 import { pluginName } from '../plugin/plugins/commonConfig/pluginName.js';
 import { setOperation } from './context.js';
+import { getVikeConfig2 } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 async function prepareViteApiCall(viteConfig = {}, operation) {
     setOperation(operation);
     return enhanceViteConfig(viteConfig, operation);
@@ -20,13 +20,23 @@ async function enhanceViteConfig(viteConfig = {}, operation) {
         };
         viteConfigResolved = await resolveViteConfig(viteConfigEnhanced, operation);
     }
-    const configVike = await getConfigVike(viteConfigResolved);
+    // 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,
-        configVike
+        vikeConfigGlobal
     };
 }
 async function resolveViteConfig(viteConfig, operation) {
-    return await resolveConfig(viteConfig, operation === 'build' || operation === 'prerender' ? 'build' : 'serve', 'custom', operation === 'dev' ? 'development' : 'production', operation === 'preview');
+    const args = getResolveConfigArgs(viteConfig, operation);
+    return await resolveConfig(...args);
+}
+function getResolveConfigArgs(viteConfig, operation) {
+    const inlineConfig = viteConfig;
+    const command = operation === 'build' || operation === 'prerender' ? 'build' : 'serve';
+    const defaultMode = operation === 'dev' ? 'development' : 'production';
+    const defaultNodeEnv = defaultMode;
+    const isPreview = operation === 'preview';
+    return [inlineConfig, command, defaultMode, defaultNodeEnv, isPreview];
 }

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

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

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

@@ -12,7 +12,6 @@ import { devConfig } from './plugins/devConfig/index.js';
 import { packageJsonFile } from './plugins/packageJsonFile.js';
 import { removeRequireHookPlugin } from './plugins/removeRequireHookPlugin.js';
 import { importUserCode } from './plugins/importUserCode/index.js';
-import { resolveVikeConfig } from './plugins/config/index.js';
 import { distFileNames } from './plugins/distFileNames.js';
 import { extractAssetsPlugin } from './plugins/extractAssetsPlugin.js';
 import { extractExportNamesPlugin } from './plugins/extractExportNamesPlugin.js';
@@ -32,10 +31,9 @@ markSetup_vikeVitePlugin();
 assertViteVersion();
 setResolveClientEntriesDev(resolveClientEntriesDev);
 // Return as `any` to avoid Plugin type mismatches when there are multiple Vite versions installed
-function plugin(vikeConfig) {
+function plugin(vikeVitePluginOptions) {
     const plugins = [
-        resolveVikeConfig(vikeConfig), // The configResolved() hook of resolveVikeConfig() should be the first called
-        ...commonConfig(),
+        ...commonConfig(vikeVitePluginOptions),
         importUserCode(),
         ...devConfig(),
         ...buildConfig(),
@@ -49,7 +47,7 @@ function plugin(vikeConfig) {
         suppressRollupWarning(),
         ...setGlobalContext(),
         ...importBuild(),
-        baseUrls(vikeConfig),
+        baseUrls(vikeVitePluginOptions),
         envVarsPlugin(),
         fileEnv(),
         workaroundCssModuleHmr(),

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

@@ -3,24 +3,25 @@ export { autoFullBuild };
 import { build } from 'vite';
 import { assertWarning } from '../utils.js';
 import { runPrerenderFromAutoRun, runPrerender_forceExit } from '../../prerender/runPrerender.js';
-import { getConfigVike } from '../../shared/getConfigVike.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';
 let forceExit = false;
 function autoFullBuild() {
     let config;
-    let configVike;
+    let vikeConfigGlobal;
     return [
         {
             name: 'vike:autoFullBuild',
             apply: 'build',
             enforce: 'pre',
             async configResolved(config_) {
-                configVike = await getConfigVike(config_);
+                const vikeConfig = await getVikeConfig(config_);
+                vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
                 config = config_;
-                abortViteBuildSsr(configVike);
+                abortViteBuildSsr(vikeConfigGlobal);
             },
             writeBundle: {
                 /* We can't use this because it breaks Vite's logging. TODO: try again with latest Vite version.
@@ -29,7 +30,7 @@ function autoFullBuild() {
                 */
                 async handler(_options, bundle) {
                     try {
-                        await triggerFullBuild(config, configVike, bundle);
+                        await triggerFullBuild(config, vikeConfigGlobal, bundle);
                     }
                     catch (err) {
                         // Avoid Rollup prefixing the error with [vike:autoFullBuild], for example see https://github.com/vikejs/vike/issues/472#issuecomment-1276274203
@@ -55,10 +56,10 @@ function autoFullBuild() {
         }
     ];
 }
-async function triggerFullBuild(config, configVike, bundle) {
+async function triggerFullBuild(config, vikeConfigGlobal, bundle) {
     if (config.build.ssr)
         return; // already triggered
-    if (isDisabled(configVike))
+    if (isDisabled(vikeConfigGlobal))
         return;
     // Workaround for @vitejs/plugin-legacy
     //  - The legacy plugin triggers its own Rollup build for the client-side.
@@ -89,19 +90,21 @@ async function triggerFullBuild(config, configVike, bundle) {
         logErrorHint(err);
         process.exit(1);
     }
-    if (configVike.prerender && !configVike.prerender.disableAutoRun && configVike.disableAutoFullBuild !== 'prerender') {
+    if (vikeConfigGlobal.prerender &&
+        !vikeConfigGlobal.prerender.disableAutoRun &&
+        vikeConfigGlobal.disableAutoFullBuild !== 'prerender') {
         await runPrerenderFromAutoRun(configInline, false);
         forceExit = true;
     }
 }
-function abortViteBuildSsr(configVike) {
-    if (configVike.disableAutoFullBuild !== true && isViteCliCall() && getViteConfigFromCli()?.build.ssr) {
+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 });
         process.exit(0);
     }
 }
-function isDisabled(configVike) {
-    const { disableAutoFullBuild } = configVike;
+function isDisabled(vikeConfigGlobal) {
+    const { disableAutoFullBuild } = vikeConfigGlobal;
     if (disableAutoFullBuild === null || disableAutoFullBuild === 'prerender') {
         return !isViteCliCall();
     }

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

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

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

@@ -1,17 +1,16 @@
 export { baseUrls };
-import { resolveBaseFromUserConfig } from '../plugins/config/resolveBase.js';
+import { resolveBase, resolveBaseFromResolvedConfig } from '../../shared/resolveBase.js';
 import { assert } from '../utils.js';
-import { getConfigVike } from '../../shared/getConfigVike.js';
-function baseUrls(configVike) {
-    let baseServer;
-    let baseAssets;
+import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
+function baseUrls(vikeVitePluginOptions) {
+    let bases;
     return {
         name: 'vike:baseUrls',
         enforce: 'post',
         async config(config) {
-            const bases = resolveBaseFromUserConfig(config, configVike);
-            baseServer = bases.baseServer;
-            baseAssets = bases.baseAssets;
+            // TODO: fix bug: use getVikeConfig2() and udpate check below
+            bases = resolveBaseFromUserConfig(config, vikeVitePluginOptions);
+            const { baseServer, baseAssets } = bases;
             // 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;
@@ -22,14 +21,16 @@ function baseUrls(configVike) {
                     'BASE_ASSETS'
                 ],
                 base: baseAssets, // Make Vite inject baseAssets to imports e.g. `import logoUrl from './logo.svg.js'`
-                _baseOriginal: config.base ?? '/__UNSET__' // Vite resolves `_baseOriginal: null` to `undefined`
+                _baseViteOriginal: config.base ?? '/__UNSET__' // Vite resolves `_baseViteOriginal: null` to `undefined`
             };
         },
         async configResolved(config) {
-            const configVike = await getConfigVike(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(configVike.baseServer === baseServer);
-            assert(configVike.baseAssets === baseAssets);
+            assert(basesResolved.baseServer === bases.baseServer);
+            assert(basesResolved.baseAssets === bases.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.
@@ -38,3 +39,7 @@ function baseUrls(configVike) {
         }
     };
 }
+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/fixServerAssets.js

@@ -202,7 +202,7 @@ function fixServerAssets_assertCssTarget_populate(config) {
 async function fixServerAssets_assertCssTarget(config) {
     if (!fixServerAssets_isEnabled())
         return;
-    if (!(await isV1Design(config, false)))
+    if (!(await isV1Design(config)))
         return;
     const targetsServer = targets.filter((t) => t.isServerSide);
     const targetsClient = targets.filter((t) => !t.isServerSide);

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

@@ -5,7 +5,6 @@ export { manifestTempFile };
 import { assert, resolveOutDir, viteIsSSR, addOnBeforeLogHook, removeFileExtention, unique, assertUsage, injectRollupInputs, normalizeRollupInput, getOutDirs, onSetupBuild, assertIsNpmPackageImport } from '../utils.js';
 import { getVikeConfig, isV1Design } from './importUserCode/v1-design/getVikeConfig.js';
 import { findPageFiles } from '../shared/findPageFiles.js';
-import { getConfigVike } from '../../shared/getConfigVike.js';
 import { getVirtualFileIdPageConfigValuesAll } from '../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
 import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
 import { createRequire } from 'module';
@@ -42,7 +41,7 @@ function buildConfig() {
                     addLogHook();
                     outDirs = getOutDirs(config);
                     {
-                        isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
+                        isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config));
                         if (isServerAssetsFixEnabled) {
                             // https://github.com/vikejs/vike/issues/1339
                             config.build.ssrEmitAssets = true;
@@ -111,9 +110,9 @@ function buildConfig() {
     ];
 }
 async function getEntries(config) {
-    const configVike = await getConfigVike(config);
-    const pageFileEntries = await getPageFileEntries(config, configVike.includeAssetsImportedByServer); // TODO/v1-release: remove
-    const { pageConfigs } = await getVikeConfig(config, false);
+    const vikeConfig = await getVikeConfig(config);
+    const { pageConfigs } = vikeConfig;
+    const pageFileEntries = await getPageFileEntries(config, vikeConfig.vikeConfigGlobal.includeAssetsImportedByServer); // TODO/v1-release: remove
     assertUsage(Object.keys(pageFileEntries).length !== 0 || pageConfigs.length !== 0, 'At least one page should be defined, see https://vike.dev/add');
     if (viteIsSSR(config)) {
         const pageEntries = getPageEntries(pageConfigs);

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

@@ -1,3 +1,9 @@
 export { commonConfig };
 import { type Plugin } from 'vite';
-declare function commonConfig(): Plugin[];
+declare module 'vite' {
+    interface UserConfig {
+        _isDev?: boolean;
+        _vikeVitePluginOptions?: unknown;
+    }
+}
+declare function commonConfig(vikeVitePluginOptions?: unknown): Plugin[];

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

@@ -1,6 +1,6 @@
 export { commonConfig };
 import { mergeConfig } from 'vite';
-import { assert, assertUsage, assertWarning, findPackageJson, isDocker } from '../utils.js';
+import { assert, assertUsage, assertWarning, findPackageJson, isDevCheck, isDocker } from '../utils.js';
 import { assertRollupInput } from './buildConfig.js';
 import { installRequireShim_setUserRootDir } from '@brillout/require-shim';
 import pc from '@brillout/picocolors';
@@ -10,8 +10,21 @@ import { pluginName } from './commonConfig/pluginName.js';
 import { getEnvVarObject } from '../shared/getEnvVarObject.js';
 import { isViteCliCall } from '../shared/isViteCliCall.js';
 import { isVikeCliOrApi } from '../../api/context.js';
-function commonConfig() {
+function commonConfig(vikeVitePluginOptions = {}) {
     return [
+        {
+            name: `${pluginName}:pre`,
+            enforce: 'pre',
+            config: {
+                order: 'pre',
+                handler(_config, env) {
+                    return {
+                        _isDev: isDevCheck(env),
+                        _vikeVitePluginOptions: vikeVitePluginOptions
+                    };
+                }
+            }
+        },
         {
             name: pluginName,
             configResolved(config) {

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.d.ts

@@ -1,3 +1,3 @@
 export { determineOptimizeDeps };
 import type { ResolvedConfig } from 'vite';
-declare function determineOptimizeDeps(config: ResolvedConfig, isDev: true): Promise<void>;
+declare function determineOptimizeDeps(config: ResolvedConfig): Promise<void>;

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -6,9 +6,9 @@ import { analyzeClientEntries } from '../buildConfig.js';
 import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 import { getFilePathResolved } from '../../shared/getFilePath.js';
 const debug = createDebugger('vike:optimizeDeps');
-async function determineOptimizeDeps(config, isDev) {
-    const { pageConfigs } = await getVikeConfig(config, isDev);
-    const { entries, include } = await getPageDeps(config, pageConfigs, isDev);
+async function determineOptimizeDeps(config) {
+    const { pageConfigs } = await getVikeConfig(config);
+    const { entries, include } = await getPageDeps(config, pageConfigs);
     {
         // This actually doesn't work: Vite's dep optimizer doesn't seem to be able to crawl virtual files.
         //  - Should we make it work? E.g. by creating a temporary file at node_modules/.vike/virtualFiles.js
@@ -28,7 +28,7 @@ async function determineOptimizeDeps(config, isDev) {
             'config.optimizeDeps.include': config.optimizeDeps.include
         });
 }
-async function getPageDeps(config, pageConfigs, isDev) {
+async function getPageDeps(config, pageConfigs) {
     let entries = [];
     let include = [];
     const addEntry = (e) => {
@@ -67,7 +67,7 @@ async function getPageDeps(config, pageConfigs, isDev) {
     }
     // V0.4 design
     {
-        const pageFiles = await findPageFiles(config, ['.page', '.page.client'], isDev);
+        const pageFiles = await findPageFiles(config, ['.page', '.page.client'], true);
         const userRootDir = config.root;
         pageFiles.forEach((filePathAbsoluteUserRootDir) => {
             const entry = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });

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

@@ -58,7 +58,7 @@ function devConfig() {
             },
             async configResolved(config_) {
                 config = config_;
-                await determineOptimizeDeps(config, true);
+                await determineOptimizeDeps(config);
                 await determineFsAllowList(config);
                 if (!isErrorDebug()) {
                     await installHttpRequestAsyncStore();

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

@@ -9,7 +9,6 @@ export { extractAssetsRE };
 import { viteIsSSR_options, assert, assertPosixPath, styleFileRE, createDebugger, isScriptFile, assertUsage } from '../utils.js';
 import { resolveVirtualFileId, isVirtualFileId, getVirtualFileId } from '../../shared/virtual-files.js';
 import { extractAssetsAddQuery } from '../../shared/extractAssetsQuery.js';
-import { getConfigVike } from '../../shared/getConfigVike.js';
 import { isAsset } from '../shared/isAsset.js';
 import { getImportStatements } from '../shared/parseEsModule.js';
 import { sourceMapRemove } from '../shared/rollupSourceMap.js';
@@ -25,7 +24,6 @@ const EMPTY_MODULE_ID = 'virtual:vike:empty-module';
 const debug = createDebugger('vike:extractAssets');
 function extractAssetsPlugin() {
     let config;
-    let configVike;
     let vikeConfig;
     let isServerAssetsFixEnabled;
     return [
@@ -45,7 +43,7 @@ function extractAssetsPlugin() {
                     assertV1Design(vikeConfig.pageConfigs, true);
                     assert(false);
                 }
-                assert(configVike.includeAssetsImportedByServer);
+                assert(vikeConfig.vikeConfigGlobal.includeAssetsImportedByServer);
                 assert(!viteIsSSR_options(options));
                 const importStatements = await getImportStatements(src);
                 const moduleNames = getImportedModules(importStatements);
@@ -78,7 +76,7 @@ function extractAssetsPlugin() {
                 if (!extractAssetsRE.test(importer)) {
                     return;
                 }
-                assert(configVike.includeAssetsImportedByServer);
+                assert(vikeConfig.vikeConfigGlobal.includeAssetsImportedByServer);
                 let resolution = null;
                 try {
                     resolution = await this.resolve(source, importer, { skipSelf: true, ...options });
@@ -137,10 +135,9 @@ function extractAssetsPlugin() {
         {
             name: 'vike:extractAssets-4',
             async configResolved(config_) {
-                configVike = await getConfigVike(config_);
                 config = config_;
-                vikeConfig = await getVikeConfig(config, false);
-                isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config, false));
+                vikeConfig = await getVikeConfig(config);
+                isServerAssetsFixEnabled = fixServerAssets_isEnabled() && (await isV1Design(config));
                 if (!isServerAssetsFixEnabled) {
                     // https://github.com/vikejs/vike/issues/1060
                     assertUsage(!config.plugins.find((p) => p.name === 'vite-tsconfig-paths'), 'vite-tsconfig-paths not supported, remove it and use vite.config.js#resolve.alias instead');

package/dist/esm/node/plugin/plugins/importBuild/getVikeManifest.d.ts

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

package/dist/esm/node/plugin/plugins/importBuild/getVikeManifest.js

@@ -3,8 +3,8 @@ import { projectInfo } from '../../utils.js';
 import { assertPluginManifest } from '../../../shared/assertPluginManifest.js';
 import { isUsingClientRouter } from '../extractExportNamesPlugin.js';
 import { getRuntimeManifest } from '../../../runtime/globalContext.js';
-function getVikeManifest(configVike) {
-    const runtimeManifest = getRuntimeManifest(configVike);
+function getVikeManifest(vikeConfigGlobal, viteConfig) {
+    const runtimeManifest = getRuntimeManifest(vikeConfigGlobal, viteConfig);
     const manifest = {
         version: projectInfo.projectVersion,
         usesClientRouter: isUsingClientRouter(), // TODO/v1-release: remove

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

@@ -4,37 +4,39 @@ import { serverProductionEntryPlugin } from '@brillout/vite-plugin-server-entry/
 import { assert, getOutDirs, toPosixPath } from '../../utils.js';
 import path from 'path';
 import { createRequire } from 'module';
-import { getConfigVike } from '../../../shared/getConfigVike.js';
 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() {
     let config;
-    let configVike;
+    let vikeConfigGlobal;
     return [
         {
             name: 'vike:importBuild:config',
             enforce: 'post',
             async configResolved(config_) {
                 config = config_;
-                configVike = await getConfigVike(config);
+                const vikeConfig = await getVikeConfig(config);
+                vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
             }
         },
         ...serverProductionEntryPlugin({
             getServerProductionEntry: () => {
-                return getServerProductionEntryCode(config, configVike);
+                return getServerProductionEntryCode(config, vikeConfigGlobal);
             },
             libraryName: 'Vike'
         })
     ];
 }
-function getServerProductionEntryCode(config, configVike) {
+function getServerProductionEntryCode(config, vikeConfigGlobal) {
     const importPath = getImportPath(config);
-    const vikeManifest = getVikeManifest(configVike);
+    const vikeManifest = getVikeManifest(vikeConfigGlobal, config);
+    // Let's eventually simplify and move everything to a single virtual module
     const importerCode = [
         `  import { setImportBuildGetters } from '${importPath}';`,
         `  import * as pageFiles from '${virtualFileIdImportUserCodeServer}';`,