vike 0.4.216 → 0.4.217-commit-99ea561

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig.js

@@ -1,10 +1,11 @@
 export { getVikeConfig };
+export { getVikeConfig2 };
 export { reloadVikeConfig };
 export { vikeConfigDependencies };
 export { isVikeConfigFile };
 export { isV1Design };
 export { getConfigValueInterfaceFile };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, getOutDirs, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, lowerFirst, assertKeys, objectKeys, objectFromEntries, makeFirst, isNpmPackageImport, reverse } from '../../../utils.js';
 import path from 'path';
 import { configDefinitionsBuiltIn, configDefinitionsBuiltInGlobal } from './getVikeConfig/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, isGlobalLocation, applyFilesystemRoutingRootEffect } from './getVikeConfig/filesystemRouting.js';
@@ -21,17 +22,20 @@ import { loadConfigFile, loadImportedFile, loadValueFile } from './getVikeConfig
 import { clearFilesEnvMap, resolveConfigEnvWithFileName, resolvePointerImportOfConfig } from './getVikeConfig/resolvePointerImport.js';
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
-import { getConfigVike } from '../../../../shared/getConfigVike.js';
 import { assertExtensionsPeerDependencies, assertExtensionsConventions } from './assertExtensions.js';
+import { resolveVikeConfigGlobal } from './getVikeConfig/resolveVikeConfigGlobal.js';
 assertIsNotProductionRuntime();
-let devServerIsCorrupt = false;
+let restartVite = false;
 let wasConfigInvalid = null;
 let vikeConfigPromise = null;
 const vikeConfigDependencies = new Set();
-function reloadVikeConfig(userRootDir, outDirRoot) {
+function reloadVikeConfig(config) {
+    const userRootDir = config.root;
+    const vikeVitePluginOptions = config._vikeVitePluginOptions;
+    assert(vikeVitePluginOptions);
     vikeConfigDependencies.clear();
     clearFilesEnvMap();
-    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, true, true);
+    vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
     handleReloadSideEffects();
 }
 async function handleReloadSideEffects() {
@@ -55,8 +59,8 @@ async function handleReloadSideEffects() {
             wasConfigInvalid = false;
             logConfigErrorRecover();
         }
-        if (devServerIsCorrupt) {
-            devServerIsCorrupt = false;
+        if (restartVite) {
+            restartVite = false;
             const viteDevServer = getViteDevServer();
             assert(viteDevServer);
             removeSuperfluousViteLog_enable();
@@ -65,23 +69,32 @@ async function handleReloadSideEffects() {
         }
     }
 }
-async function getVikeConfig(config, isDev, { crawlWithGit, tolerateInvalidConfig } = {}) {
-    const { outDirRoot } = getOutDirs(config);
+async function getVikeConfig(config, { doNotRestartViteOnError } = {}) {
     const userRootDir = config.root;
+    const vikeVitePluginOptions = config._vikeVitePluginOptions;
+    assert(vikeVitePluginOptions);
+    const isDev = config._isDev;
+    assert(typeof isDev === 'boolean');
+    return await getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError ?? false);
+}
+async function getVikeConfig2(userRootDir, isDev, vikeVitePluginOptions) {
+    assert(vikeVitePluginOptions);
+    return await getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, false);
+}
+async function getVikeConfigEntry(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     if (!vikeConfigPromise) {
-        const crawlWithGit_ = crawlWithGit !== undefined ? crawlWithGit : (await getConfigVike(config)).crawl.git;
-        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, crawlWithGit_, tolerateInvalidConfig);
+        vikeConfigPromise = loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
     }
     return await vikeConfigPromise;
 }
-async function isV1Design(config, isDev) {
-    const vikeConfig = await getVikeConfig(config, isDev);
+async function isV1Design(config) {
+    const vikeConfig = await getVikeConfig(config);
     const { pageConfigs } = vikeConfig;
     const isV1Design = pageConfigs.length > 0;
     return isV1Design;
 }
-async function loadInterfaceFiles(userRootDir, outDirRoot, crawlWithGit) {
-    const plusFiles = await findPlusFiles(userRootDir, outDirRoot, crawlWithGit);
+async function loadInterfaceFiles(userRootDir) {
+    const plusFiles = await findPlusFiles(userRootDir, null);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -190,12 +203,12 @@ function assertAllConfigsAreKnown(interfaceFilesByLocationId) {
         });
     });
 }
-async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev, crawlWithGit, tolerateInvalidConfig) {
+async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     let hasError = false;
     let ret;
     let err;
     try {
-        ret = await loadVikeConfig(userRootDir, outDirRoot, crawlWithGit);
+        ret = await loadVikeConfig(userRootDir, vikeVitePluginOptions);
     }
     catch (err_) {
         hasError = true;
@@ -217,8 +230,8 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
         }
         else {
             logConfigError(err);
-            if (!tolerateInvalidConfig) {
-                devServerIsCorrupt = true;
+            if (!doNotRestartViteOnError) {
+                restartVite = true;
             }
             const dummyData = {
                 pageConfigs: [],
@@ -226,16 +239,17 @@ async function loadVikeConfig_withErrorHandling(userRootDir, outDirRoot, isDev,
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                globalVikeConfig: {}
+                vikeConfigGlobal: resolveVikeConfigGlobal({}, {})
             };
             return dummyData;
         }
     }
 }
-async function loadVikeConfig(userRootDir, outDirRoot, crawlWithGit) {
-    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, outDirRoot, crawlWithGit);
+async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
+    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir);
     const importedFilesLoaded = {};
-    const { globalVikeConfig, pageConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
+    const { pageConfigGlobal, pageConfigGlobalValues } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
+    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
@@ -285,7 +299,7 @@ async function loadVikeConfig(userRootDir, outDirRoot, crawlWithGit) {
         return pageConfig;
     }));
     assertPageConfigs(pageConfigs);
-    return { pageConfigs, pageConfigGlobal, globalVikeConfig };
+    return { pageConfigs, pageConfigGlobal, vikeConfigGlobal };
 }
 // TODO/soon: refactor
 //  - Dedupe: most of the assertUsageGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
@@ -395,7 +409,7 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
             });
         });
     }
-    const globalVikeConfig = {};
+    const pageConfigGlobalValues = {};
     const pageConfigGlobal = {
         configDefinitions: configDefinitionsBuiltInGlobal,
         configValueSources: {}
@@ -415,10 +429,10 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
                 return;
             const { filePathToShowToUser } = configValueSource.definedAtFilePath;
             assertWarning(false, `Being able to define config ${pc.cyan(configName)} in ${filePathToShowToUser} is experimental and will likely be removed. Define the config ${pc.cyan(configName)} in Vike's Vite plugin options instead.`, { onlyOnce: true });
-            globalVikeConfig[configName] = configValueSource.value;
+            pageConfigGlobalValues[configName] = configValueSource.value;
         }
     }));
-    return { pageConfigGlobal, globalVikeConfig };
+    return { pageConfigGlobal, pageConfigGlobalValues };
 }
 async function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded) {
     const sourcesInfo = [];
@@ -779,8 +793,8 @@ function getComputed(configValueSources, configDefinitions) {
     });
     return configValuesComputed;
 }
-async function findPlusFiles(userRootDir, outDirRoot, crawlWithGit) {
-    const files = await crawlPlusFiles(userRootDir, outDirRoot, crawlWithGit);
+async function findPlusFiles(userRootDir, outDirRoot) {
+    const files = await crawlPlusFiles(userRootDir, outDirRoot);
     const plusFiles = files.map(({ filePathAbsoluteUserRootDir }) => getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir }));
     return plusFiles;
 }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigValuesAll.js

@@ -6,7 +6,6 @@ import { extractAssetsAddQuery } from '../../../../shared/extractAssetsQuery.js'
 import { debug } from './debug.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
-import { getConfigVike } from '../../../../shared/getConfigVike.js';
 import { fixServerAssets_isEnabled } from '../../buildConfig/fixServerAssets.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
@@ -19,11 +18,11 @@ async function getVirtualFilePageConfigValuesAll(id, isDev, config) {
     }
     */
     const { pageId, isForClientSide } = result;
-    const { pageConfigs } = await getVikeConfig(config, isDev, { tolerateInvalidConfig: true });
+    const vikeConfig = await getVikeConfig(config, { doNotRestartViteOnError: true });
+    const { pageConfigs } = vikeConfig;
     const pageConfig = pageConfigs.find((pageConfig) => pageConfig.pageId === pageId);
     assert(pageConfig, { id, pageId });
-    const configVike = await getConfigVike(config);
-    const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, configVike.includeAssetsImportedByServer, isDev);
+    const code = getLoadConfigValuesAll(pageConfig, isForClientSide, pageId, vikeConfig.vikeConfigGlobal.includeAssetsImportedByServer, isDev);
     debug(id, isForClientSide ? 'CLIENT-SIDE' : 'SERVER-SIDE', code);
     return code;
 }

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVirtualFilePageConfigs.js

@@ -5,7 +5,7 @@ import { getVikeConfig } from './getVikeConfig.js';
 import { isRuntimeEnvMatch } from './isRuntimeEnvMatch.js';
 import { serializeConfigValues } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 async function getVirtualFilePageConfigs(isForClientSide, isDev, id, isClientRouting, config) {
-    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, isDev, { tolerateInvalidConfig: true });
+    const { pageConfigs, pageConfigGlobal } = await getVikeConfig(config, { doNotRestartViteOnError: true });
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {

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

@@ -7,7 +7,7 @@ import pc from '@brillout/picocolors';
 import { logDockerHint } from './devConfig/index.js';
 function previewConfig() {
     let config;
-    // let configVike: ConfigVikeResolved
+    // let vikeConfigGlobal: VikeConfigGlobal
     return {
         name: 'vike:previewConfig',
         apply: applyPreview,
@@ -22,7 +22,8 @@ function previewConfig() {
         async configResolved(config_) {
             config = config_;
             logDockerHint(config.preview.host);
-            // configVike = await getConfigVike(config)
+            // const vikeConfig = await getVikeConfig(config)
+            // vikeConfigGlobal = vikeConfig.vikeConfigGlobal
         },
         configurePreviewServer(server) {
             /* - Couldn't make `appType: 'mpa'` work as of npm:@brillout/vite@5.0.0-beta.14.0426910c
@@ -32,7 +33,7 @@ function previewConfig() {
             return () => {
                 assertDist();
                 /* We don't use this condition (we wrongfully always use the SSR middleware) because of the regression introduced by https://github.com/vitejs/vite/pull/14756 which stops servering .html files when `appType: 'custom'`.
-                if (!configVike.prerender || configVike.prerender.partial) {
+                if (!vikeConfigGlobal.prerender || vikeConfigGlobal.prerender.partial) {
                   addSsrMiddleware(server.middlewares, config, true)
                 }
                 /*/

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

@@ -1,6 +1,7 @@
 export { setGlobalContext };
-import { setGlobalContext_isViteDev, setGlobalContext_viteDevServer, setGlobalContext_viteConfig } from '../../runtime/globalContext.js';
+import { setGlobalContext_isViteDev, setGlobalContext_viteDevServer, setGlobalContext_viteConfig, setGlobalContext_vikeConfig } from '../../runtime/globalContext.js';
 import { assertFilePathAbsoluteFilesystem, getOutDirs, isDevCheck, markSetup_isViteDev, markSetup_viteDevServer, markSetup_vitePreviewServer } from '../utils.js';
+import { getVikeConfig } from './importUserCode/v1-design/getVikeConfig.js';
 function setGlobalContext() {
     return [
         {
@@ -30,10 +31,12 @@ function setGlobalContext() {
             enforce: 'post',
             configResolved: {
                 order: 'post',
-                handler(config) {
+                async handler(config) {
                     const { outDirRoot } = getOutDirs(config);
                     assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
                     setGlobalContext_viteConfig(config, outDirRoot);
+                    const vikeConfig = await getVikeConfig(config);
+                    setGlobalContext_vikeConfig(vikeConfig);
                 }
             }
         }

package/dist/esm/node/plugin/shared/getEnvVarObject.d.ts

@@ -1,2 +1,2 @@
 export { getEnvVarObject };
-declare function getEnvVarObject(envVarName: 'VITE_CONFIG'): null | Record<string, unknown>;
+declare function getEnvVarObject(envVarName: 'VITE_CONFIG' | 'VIKE_CRAWL'): null | Record<string, unknown>;

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

@@ -11,7 +11,6 @@ import pc from '@brillout/picocolors';
 import { cpus } from 'os';
 import { getGlobalContext, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.js';
 import { resolveConfig } from 'vite';
-import { getConfigVike } from '../shared/getConfigVike.js';
 import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
@@ -71,10 +70,10 @@ async function runPrerender(options = {}, standaloneTrigger) {
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
     assertLoadedConfig(viteConfig, options);
-    const configVike = await getConfigVike(viteConfig);
+    const vikeConfig = await getVikeConfig(viteConfig);
     const { outDirClient } = getOutDirs(viteConfig);
     const { root } = viteConfig;
-    const prerenderConfig = configVike.prerender;
+    const prerenderConfig = vikeConfig.vikeConfigGlobal.prerender;
     if (!prerenderConfig) {
         assert(standaloneTrigger);
         assertWarning(prerenderConfig, `You're executing ${pc.cyan(standaloneTrigger)} but the config ${pc.cyan('prerender')} isn't set to true`, {
@@ -94,7 +93,6 @@ async function runPrerender(options = {}, standaloneTrigger) {
         pageContextInit: options.pageContextInit ?? null
     });
     const doNotPrerenderList = [];
-    const vikeConfig = await getVikeConfig(viteConfig, false);
     await collectDoNoPrerenderList(renderContext, vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
     await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList);
     await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);

package/dist/esm/node/runtime/globalContext.d.ts

@@ -9,13 +9,15 @@ export { initGlobalContext_runPrerender };
 export { initGlobalContext_getGlobalContextAsync };
 export { setGlobalContext_viteDevServer };
 export { setGlobalContext_viteConfig };
+export { setGlobalContext_vikeConfig };
 export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
 import { PluginManifest } from '../shared/assertPluginManifest.js';
-import type { ConfigVikeResolved } from '../../shared/ConfigVike.js';
+import type { VikeConfigGlobal } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
 import { type RuntimeManifest } from '../shared/assertRuntimeManifest.js';
+import type { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 type GlobalContextPublic = {
     assetsManifest: null | ViteManifest;
 };
@@ -30,6 +32,7 @@ type GlobalContext = {
     isProduction: false;
     isPrerendering: false;
     viteConfig: ResolvedConfig;
+    vikeConfig: VikeConfigObject;
     viteDevServer: ViteDevServer;
     assetsManifest: null;
     pluginManifest: null;
@@ -52,6 +55,7 @@ declare function getGlobalContextSync(): GlobalContextPublic;
 declare function getGlobalContextAsync(isProduction: boolean): Promise<GlobalContextPublic>;
 declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): void;
 declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig, outDirRoot: string): void;
+declare function setGlobalContext_vikeConfig(vikeConfig: VikeConfigObject): void;
 declare function setGlobalContext_isViteDev(isViteDev: boolean): void;
 declare function setGlobalContext_isPrerendering(): void;
 declare function getViteDevServer(): ViteDevServer | null;
@@ -59,4 +63,4 @@ declare function getViteConfig(): ResolvedConfig | null;
 declare function initGlobalContext_renderPage(): Promise<void>;
 declare function initGlobalContext_runPrerender(): Promise<void>;
 declare function initGlobalContext_getGlobalContextAsync(isProduction: boolean): Promise<void>;
-declare function getRuntimeManifest(configVike: ConfigVikeResolved): RuntimeManifest;
+declare function getRuntimeManifest(vikeConfigGlobal: VikeConfigGlobal, viteConfig: ResolvedConfig): RuntimeManifest;

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

@@ -11,16 +11,17 @@ export { initGlobalContext_runPrerender };
 export { initGlobalContext_getGlobalContextAsync };
 export { setGlobalContext_viteDevServer };
 export { setGlobalContext_viteConfig };
+export { setGlobalContext_vikeConfig };
 export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
 import { assert, onSetupRuntime, assertUsage, assertWarning, getGlobalObject, isPlainObject, objectAssign, objectKeys, genPromise } from './utils.js';
 import { loadImportBuild } from './globalContext/loadImportBuild.js';
 import { setPageFiles } from '../../shared/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.js';
-import { getConfigVike } from '../shared/getConfigVike.js';
 import { assertRuntimeManifest } from '../shared/assertRuntimeManifest.js';
 import pc from '@brillout/picocolors';
 import { getPageFilesExports } from './page-files/getPageFilesExports.js';
+import { resolveBaseFromResolvedConfig } from '../shared/resolveBase.js';
 const globalObject = getGlobalObject('globalContext.ts', (() => {
     const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = genPromise();
     return {
@@ -85,6 +86,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
     assert(!globalObject.globalContext);
@@ -138,14 +145,15 @@ async function initGlobalContext(isProduction) {
         assert(globalObject.globalContext.isPrerendering === (globalObject.isPrerendering ?? false));
         return;
     }
-    const { viteDevServer, viteConfig, isPrerendering } = globalObject;
+    const { viteDevServer, viteConfig, vikeConfig, isPrerendering } = globalObject;
     onSetupRuntime();
     if (!isProduction) {
         assert(viteConfig);
+        assert(vikeConfig);
         assert(viteDevServer);
         assert(!isPrerendering);
-        const configVike = await getConfigVike(viteConfig);
-        const pluginManifest = getRuntimeManifest(configVike);
+        const vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
+        const pluginManifest = getRuntimeManifest(vikeConfigGlobal, viteConfig);
         globalObject.globalContext = {
             isProduction: false,
             isPrerendering: false,
@@ -153,6 +161,7 @@ async function initGlobalContext(isProduction) {
             pluginManifest: null,
             viteDevServer,
             viteConfig,
+            vikeConfig,
             baseServer: pluginManifest.baseServer,
             baseAssets: pluginManifest.baseAssets,
             includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
@@ -182,8 +191,6 @@ async function initGlobalContext(isProduction) {
         };
         if (isPrerendering) {
             assert(viteConfig);
-            const configVike = await getConfigVike(viteConfig);
-            assert(configVike);
             objectAssign(globalContext, {
                 isPrerendering: true,
                 viteConfig
@@ -199,8 +206,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 } = resolveBaseFromResolvedConfig(vikeConfigGlobal.baseServer, vikeConfigGlobal.baseAssets, viteConfig);
     const manifest = {
         baseServer,
         baseAssets,

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

@@ -121,7 +121,7 @@ function getPageContextInitEnhanced(pageContextInit, renderContext, { ssr: { url
     objectAssign(pageContextInitEnhanced, pageContextInit);
     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/esm/node/shared/resolveBase.d.ts

@@ -0,0 +1,11 @@
+export { resolveBase };
+export { resolveBaseFromResolvedConfig };
+import type { ResolvedConfig } from 'vite';
+declare function resolveBaseFromResolvedConfig(baseServer: string | null, baseAssets: string | null, config: ResolvedConfig): {
+    baseServer: string;
+    baseAssets: string;
+};
+declare function resolveBase(baseViteOriginal: string | null, baseServerUnresolved: string | null, baseAssetsUnresolved: string | null): {
+    baseServer: string;
+    baseAssets: string;
+};

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

@@ -0,0 +1,36 @@
+export { resolveBase };
+export { resolveBaseFromResolvedConfig };
+import { assert, assertUsage, isBaseServer, isBaseAssets } from './utils.js';
+import pc from '@brillout/picocolors';
+function resolveBaseFromResolvedConfig(baseServer, baseAssets, config) {
+    let baseViteOriginal = config._baseViteOriginal;
+    if (baseViteOriginal === '/__UNSET__')
+        baseViteOriginal = null;
+    assert(baseViteOriginal === null || typeof baseViteOriginal == 'string');
+    return resolveBase(baseViteOriginal, baseServer, baseAssets);
+}
+function resolveBase(baseViteOriginal, baseServerUnresolved, baseAssetsUnresolved) {
+    {
+        const wrongBase = (val) => `should start with ${pc.cyan('/')}, ${pc.cyan('http://')}, or ${pc.cyan('https://')} (it's ${pc.cyan(val)} instead)`;
+        assertUsage(baseViteOriginal === null || isBaseAssets(baseViteOriginal), `vite.config.js#base ${wrongBase(baseViteOriginal)}`);
+        assertUsage(baseAssetsUnresolved === null || isBaseAssets(baseAssetsUnresolved), `Config ${pc.cyan('baseAssets')} ${wrongBase(baseAssetsUnresolved)}`);
+        assertUsage(baseServerUnresolved === null || baseServerUnresolved.startsWith('/'), `Config ${pc.cyan('baseServer')} should start with a leading slash ${pc.cyan('/')} (it's ${pc.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 ?? '/';
+    assert(isBaseAssets(baseAssets));
+    assert(isBaseServer(baseServer));
+    return {
+        baseServer,
+        baseAssets
+    };
+}

package/dist/esm/shared/page-configs/Config.d.ts

@@ -35,7 +35,7 @@ import type { PrefetchSetting, PrefetchStaticAssets } from '../../client/client-
 import type { ConfigDefinition } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
 import type { DocumentHtml } from '../../node/runtime/html/renderHtml.js';
 import type { InjectFilterEntry } from '../../types/index.js';
-import type { ConfigVikeUserProvided } from '../ConfigVike.js';
+import type { VikeVitePluginOptions } from '../../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
 import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { PageContextClient, PageContextServer } from '../types.js';
@@ -43,7 +43,7 @@ type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data';
 type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart';
 type HookNameOldDesign = 'render' | 'prerender';
-type ConfigNameBuiltIn = Exclude<keyof Config, keyof ConfigVikeUserProvided | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
+type ConfigNameBuiltIn = Exclude<keyof Config, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte | VikePackages.ConfigVikeAngular);
 /** Hook for fetching data.
  *

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.216";
+export declare const PROJECT_VERSION: "0.4.217-commit-99ea561";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.216';
+export const PROJECT_VERSION = '0.4.217-commit-99ea561';

package/dist/esm/utils/projectInfo.d.ts

@@ -1,4 +1,4 @@
 export declare const projectInfo: {
     projectName: "Vike";
-    projectVersion: "0.4.216";
+    projectVersion: "0.4.217-commit-99ea561";
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.216",
+  "version": "0.4.217-commit-99ea561",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

package/dist/cjs/node/plugin/plugins/config/assertVikeConfig.js

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertVikeConfig = assertVikeConfig;
-const utils_js_1 = require("../../utils.js");
-function assertVikeConfig(vikeConfig, wrongUsageMsg) {
-    const wrongUsageError = checkConfigVike(vikeConfig);
-    if (wrongUsageError) {
-        (0, utils_js_1.assertUsage)(false, wrongUsageMsg(wrongUsageError));
-    }
-}
-function checkConfigVike(configVike) {
-    (0, utils_js_1.assert)((0, utils_js_1.isObject)(configVike));
-    {
-        const prop = 'disableUrlNormalization';
-        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') && !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be a boolean' };
-    }
-    {
-        const prop = 'trailingSlash';
-        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') && !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be a boolean' };
-    }
-    {
-        const prop = 'redirects';
-        const { redirects } = configVike;
-        if (!(redirects === undefined ||
-            ((0, utils_js_1.isObject)(redirects) && Object.values(redirects).every((v) => typeof v === 'string'))))
-            return { prop, errMsg: 'should be an object of strings' };
-    }
-    {
-        const prop = 'disableAutoFullBuild';
-        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') &&
-            !(0, utils_js_1.hasProp)(configVike, prop, 'undefined') &&
-            !(configVike[prop] === 'prerender'))
-            return { prop, errMsg: "should be a boolean or 'prerender'" };
-    }
-    {
-        const prop = 'includeAssetsImportedByServer';
-        if (!(0, utils_js_1.hasProp)(configVike, prop, 'boolean') && !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be a boolean' };
-    }
-    {
-        const prop = 'prerender';
-        if (!(0, utils_js_1.hasProp)(configVike, prop, 'object') &&
-            !(0, utils_js_1.hasProp)(configVike, prop, 'boolean') &&
-            !(0, utils_js_1.hasProp)(configVike, prop, 'undefined'))
-            return { prop, errMsg: 'should be an object or a boolean' };
-    }
-    const configVikePrerender = configVike.prerender;
-    if (typeof configVikePrerender === 'object') {
-        {
-            const p = 'partial';
-            if (!(0, utils_js_1.hasProp)(configVikePrerender, p, 'boolean') && !(0, utils_js_1.hasProp)(configVikePrerender, p, 'undefined'))
-                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'noExtraDir';
-            if (!(0, utils_js_1.hasProp)(configVikePrerender, p, 'boolean') && !(0, utils_js_1.hasProp)(configVikePrerender, p, 'undefined'))
-                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'disableAutoRun';
-            if (!(0, utils_js_1.hasProp)(configVikePrerender, p, 'boolean') && !(0, utils_js_1.hasProp)(configVikePrerender, p, 'undefined'))
-                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
-        }
-        {
-            const p = 'parallel';
-            if (!(0, utils_js_1.hasProp)(configVikePrerender, p, 'boolean') &&
-                !(0, utils_js_1.hasProp)(configVikePrerender, p, 'number') &&
-                !(0, utils_js_1.hasProp)(configVikePrerender, p, 'undefined'))
-                return { prop: `prerender.${p}`, errMsg: 'should be a boolean or a number' };
-        }
-    }
-    return null;
-}