vike 0.4.217 → 0.4.218-commit-ed9b3d4

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

@@ -23,7 +23,8 @@ import { clearFilesEnvMap, resolveConfigEnvWithFileName, resolvePointerImportOfC
 import { getFilePathResolved } from '../../../shared/getFilePath.js';
 import { getConfigValueBuildTime } from '../../../../../shared/page-configs/getConfigValueBuildTime.js';
 import { assertExtensionsPeerDependencies, assertExtensionsConventions } from './assertExtensions.js';
-import { resolveVikeConfigGlobal } from './getVikeConfig/resolveVikeConfigGlobal.js';
+import { getPageConfigUserFriendlyNew } from '../../../../../shared/page-configs/getPageConfigUserFriendly.js';
+import { getConfigValuesBase } from '../../../../../shared/page-configs/serialize/serializeConfigValues.js';
 assertIsNotProductionRuntime();
 let restartVite = false;
 let wasConfigInvalid = null;
@@ -78,6 +79,7 @@ async function getVikeConfig(config, { doNotRestartViteOnError } = {}) {
     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) {
@@ -92,8 +94,8 @@ async function isV1Design(config) {
     const isV1Design = pageConfigs.length > 0;
     return isV1Design;
 }
-async function loadInterfaceFiles(userRootDir, crawlWithGit) {
-    const plusFiles = await findPlusFiles(userRootDir, null, crawlWithGit);
+async function loadInterfaceFiles(userRootDir) {
+    const plusFiles = await findPlusFiles(userRootDir, null);
     const configFiles = [];
     const valueFiles = [];
     plusFiles.forEach((f) => {
@@ -238,18 +240,19 @@ async function loadVikeConfig_withErrorHandling(userRootDir, isDev, vikeVitePlug
                     configDefinitions: {},
                     configValueSources: {}
                 },
-                vikeConfigGlobal: resolveVikeConfigGlobal({}, {})
+                vikeConfigGlobal: resolveVikeConfigGlobal({}, {}),
+                vikeConfigNew: {
+                    global: getPageConfigUserFriendlyNew({ configValues: {} })
+                }
             };
             return dummyData;
         }
     }
 }
 async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
-    const crawlWithGit = resolveVikeConfigGlobal(vikeVitePluginOptions, {}).crawl.git ?? null;
-    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir, crawlWithGit);
+    const interfaceFilesByLocationId = await loadInterfaceFiles(userRootDir);
     const importedFilesLoaded = {};
-    const { pageConfigGlobal, pageConfigGlobalValues } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded);
-    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
+    const { pageConfigGlobal, vikeConfigGlobal } = await getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions);
     const pageConfigs = await Promise.all(objectEntries(interfaceFilesByLocationId)
         .filter(([_pageId, interfaceFiles]) => isDefiningPage(interfaceFiles))
         .map(async ([locationId]) => {
@@ -299,7 +302,37 @@ async function loadVikeConfig(userRootDir, vikeVitePluginOptions) {
         return pageConfig;
     }));
     assertPageConfigs(pageConfigs);
-    return { pageConfigs, pageConfigGlobal, vikeConfigGlobal };
+    const configValues = getConfigValues(pageConfigGlobal);
+    const global = getPageConfigUserFriendlyNew({ configValues });
+    return { pageConfigs, pageConfigGlobal, vikeConfigGlobal, vikeConfigNew: { global } };
+}
+function getConfigValues(pageConfig) {
+    const configValues = {};
+    getConfigValuesBase(pageConfig, (configEnv) => !!configEnv.config).forEach((entry) => {
+        if (entry.configValueBase.type === 'computed') {
+            assert('value' in entry); // Help TS
+            const { configValueBase, value, configName } = entry;
+            configValues[configName] = { ...configValueBase, value };
+        }
+        if (entry.configValueBase.type === 'standard') {
+            assert('sourceRelevant' in entry); // Help TS
+            const { configValueBase, sourceRelevant, configName } = entry;
+            assert('value' in sourceRelevant);
+            const { value } = sourceRelevant;
+            configValues[configName] = { ...configValueBase, value };
+        }
+        if (entry.configValueBase.type === 'cumulative') {
+            assert('sourcesRelevant' in entry); // Help TS
+            const { configValueBase, sourcesRelevant, configName } = entry;
+            const values = [];
+            sourcesRelevant.forEach((source) => {
+                assert('value' in source);
+                values.push(source.value);
+            });
+            configValues[configName] = { ...configValueBase, value: values };
+        }
+    });
+    return configValues;
 }
 // TODO/soon: refactor
 //  - Dedupe: most of the assertUsageGlobalConfigs() code below is a copy-paste of the assertUsage() logic inside getGlobalConfigs()
@@ -377,7 +410,7 @@ function getInterfaceFilesRelevant(interfaceFilesByLocationId, locationIdPage) {
         .sort(([locationId1], [locationId2]) => sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage)));
     return interfaceFilesRelevant;
 }
-async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded) {
+async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importedFilesLoaded, vikeVitePluginOptions) {
     const locationIds = objectKeys(interfaceFilesByLocationId);
     const interfaceFilesGlobal = objectFromEntries(objectEntries(interfaceFilesByLocationId).filter(([locationId]) => {
         return isGlobalLocation(locationId, locationIds);
@@ -419,20 +452,42 @@ async function getGlobalConfigs(interfaceFilesByLocationId, userRootDir, importe
         const configValueSource = sources[0];
         if (!configValueSource)
             return;
+        pageConfigGlobal.configValueSources[configName] = sources;
         if (configName === 'onBeforeRoute' || configName === 'onPrerenderStart') {
             assert(!('value' in configValueSource));
-            pageConfigGlobal.configValueSources[configName] = [configValueSource];
         }
         else {
             assert('value' in configValueSource);
             if (configName === 'prerender' && typeof configValueSource.value === 'boolean')
                 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 });
             pageConfigGlobalValues[configName] = configValueSource.value;
         }
     }));
-    return { pageConfigGlobal, pageConfigGlobalValues };
+    const vikeConfigGlobal = resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues);
+    {
+        assert(isObject(vikeVitePluginOptions));
+        Object.entries(vikeVitePluginOptions).forEach(([configName, value]) => {
+            if (pageConfigGlobal.configValueSources[configName])
+                return;
+            pageConfigGlobal.configValueSources[configName] = [];
+            pageConfigGlobal.configValueSources[configName].push({
+                value,
+                configEnv: { config: true },
+                definedAtFilePath: {
+                    ...getFilePathResolved({
+                        userRootDir,
+                        filePathAbsoluteUserRootDir: '/vite.config.js'
+                    }),
+                    fileExportPathToShowToUser: null
+                },
+                locationId: '/',
+                isOverriden: false,
+                valueIsImportedAtRuntime: false,
+                valueIsDefinedByPlusFile: false
+            });
+        });
+    }
+    return { pageConfigGlobal, pageConfigGlobalValues, vikeConfigGlobal };
 }
 async function resolveConfigValueSources(configName, configDef, interfaceFilesRelevant, userRootDir, importedFilesLoaded) {
     const sourcesInfo = [];
@@ -793,8 +848,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;
 }
@@ -1010,3 +1065,121 @@ function sortConfigValueSources(configValueSources, locationIdPage) {
 function getConfigValueInterfaceFile(interfaceFile, configName) {
     return interfaceFile.fileExportsByConfigName[configName]?.configValue;
 }
+// TODO: refactor code below
+function resolveVikeConfigGlobal(vikeVitePluginOptions, pageConfigGlobalValues) {
+    // TODO/v1-release: remove
+    assertVikeConfigGlobal(vikeVitePluginOptions, ({ prop, errMsg }) => `vite.config.js > vike option ${prop} ${errMsg}`);
+    const configs = [vikeVitePluginOptions];
+    assertVikeConfigGlobal(pageConfigGlobalValues, ({ prop, errMsg }) => {
+        // Can we add the config file path ?
+        return `config ${pc.cyan(prop)} ${errMsg}`;
+    });
+    configs.push(pageConfigGlobalValues);
+    const vikeConfigGlobal = {
+        disableAutoFullBuild: pickFirst(configs.map((c) => c.disableAutoFullBuild)) ?? null,
+        prerender: resolvePrerenderOptions(configs),
+        includeAssetsImportedByServer: pickFirst(configs.map((c) => c.includeAssetsImportedByServer)) ?? true,
+        baseServer: pickFirst(configs.map((c) => c.baseServer)) ?? null,
+        baseAssets: pickFirst(configs.map((c) => c.baseAssets)) ?? null,
+        redirects: merge(configs.map((c) => c.redirects)) ?? {},
+        disableUrlNormalization: pickFirst(configs.map((c) => c.disableUrlNormalization)) ?? false,
+        trailingSlash: pickFirst(configs.map((c) => c.trailingSlash)) ?? false
+    };
+    return vikeConfigGlobal;
+}
+function resolvePrerenderOptions(configs) {
+    if (!configs.some((c) => c.prerender)) {
+        return false;
+    }
+    const configsPrerender = configs.map((c) => c.prerender).filter(isObject2);
+    return {
+        partial: pickFirst(configsPrerender.map((c) => c.partial)) ?? false,
+        noExtraDir: pickFirst(configsPrerender.map((c) => c.noExtraDir)) ?? false,
+        parallel: pickFirst(configsPrerender.map((c) => c.parallel)) ?? true,
+        disableAutoRun: pickFirst(configsPrerender.map((c) => c.disableAutoRun)) ?? false
+    };
+}
+function isObject2(p) {
+    return typeof p === 'object';
+}
+function merge(objs) {
+    const obj = {};
+    objs.forEach((e) => {
+        Object.assign(obj, e);
+    });
+    return obj;
+}
+function pickFirst(arr) {
+    return arr.filter((v) => v !== undefined)[0];
+}
+function assertVikeConfigGlobal(vikeConfigGlobal, wrongUsageMsg) {
+    const wrongUsageError = check(vikeConfigGlobal);
+    if (wrongUsageError) {
+        assertUsage(false, wrongUsageMsg(wrongUsageError));
+    }
+}
+function check(vikeConfigGlobal) {
+    assert(isObject(vikeConfigGlobal));
+    {
+        const prop = 'disableUrlNormalization';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') && !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'trailingSlash';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') && !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'redirects';
+        const { redirects } = vikeConfigGlobal;
+        if (!(redirects === undefined ||
+            (isObject(redirects) && Object.values(redirects).every((v) => typeof v === 'string'))))
+            return { prop, errMsg: 'should be an object of strings' };
+    }
+    {
+        const prop = 'disableAutoFullBuild';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') &&
+            !hasProp(vikeConfigGlobal, prop, 'undefined') &&
+            !(vikeConfigGlobal[prop] === 'prerender'))
+            return { prop, errMsg: "should be a boolean or 'prerender'" };
+    }
+    {
+        const prop = 'includeAssetsImportedByServer';
+        if (!hasProp(vikeConfigGlobal, prop, 'boolean') && !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be a boolean' };
+    }
+    {
+        const prop = 'prerender';
+        if (!hasProp(vikeConfigGlobal, prop, 'object') &&
+            !hasProp(vikeConfigGlobal, prop, 'boolean') &&
+            !hasProp(vikeConfigGlobal, prop, 'undefined'))
+            return { prop, errMsg: 'should be an object or a boolean' };
+    }
+    const configVikePrerender = vikeConfigGlobal.prerender;
+    if (typeof configVikePrerender === 'object') {
+        {
+            const p = 'partial';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'noExtraDir';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'disableAutoRun';
+            if (!hasProp(configVikePrerender, p, 'boolean') && !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'parallel';
+            if (!hasProp(configVikePrerender, p, 'boolean') &&
+                !hasProp(configVikePrerender, p, 'number') &&
+                !hasProp(configVikePrerender, p, 'undefined'))
+                return { prop: `prerender.${p}`, errMsg: 'should be a boolean or a number' };
+        }
+    }
+    return null;
+}

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

@@ -5,7 +5,8 @@ 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, { doNotRestartViteOnError: true });
+    const vikeConfig = await getVikeConfig(config, { doNotRestartViteOnError: true });
+    const { pageConfigs, pageConfigGlobal } = vikeConfig;
     return getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting);
 }
 function getCode(pageConfigs, pageConfigGlobal, isForClientSide, isDev, id, isClientRouting) {

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

@@ -33,7 +33,7 @@ function setGlobalContext() {
                 order: 'post',
                 async handler(config) {
                     const { outDirRoot } = getOutDirs(config);
-                    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for loadImportBuild(outDir) of @brillout/vite-plugin-server-entry
+                    assertFilePathAbsoluteFilesystem(outDirRoot); // Needed for `importServerProductionEntry({ outDir })` of @brillout/vite-plugin-server-entry
                     setGlobalContext_viteConfig(config, outDirRoot);
                     const vikeConfig = await getVikeConfig(config);
                     setGlobalContext_vikeConfig(vikeConfig);

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

@@ -0,0 +1,3 @@
+export { workaroundVite6HmrRegression };
+import type { Plugin } from 'vite';
+declare function workaroundVite6HmrRegression(): Plugin;

package/dist/esm/node/plugin/plugins/{vite6HmrRegressionWorkaround.js → workaroundVite6HmrRegression.js}

@@ -1,11 +1,11 @@
-export { vite6HmrRegressionWorkaround };
+export { workaroundVite6HmrRegression };
 // https://vite.dev/guide/migration (will be 404 after vite@7 release) > search for `hmrReload()`
 // https://v6.vite.dev/guide/migration (will exist after vite@7 release) > search for `hmrReload()`
 // Workaround seems to work for docs page /banner (which is HTML-only)
 // But doesn't seem to work for /examples/render-modes/ (see https://github.com/vikejs/vike/pull/2069 commit `renable HMR test for HTML-only`)
-function vite6HmrRegressionWorkaround() {
+function workaroundVite6HmrRegression() {
     return {
-        name: 'vike:vite6HmrRegressionWorkaround',
+        name: 'vike:workaroundVite6HmrRegression',
         enforce: 'post',
         hotUpdate: {
             order: 'post',

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/isPrerenderEnabled.d.ts

@@ -0,0 +1,3 @@
+export { isPrerenderEnabled };
+import type { VikeConfigGlobal } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
+declare function isPrerenderEnabled(vikeConfigGlobal: VikeConfigGlobal): boolean;

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

@@ -0,0 +1,6 @@
+export { isPrerenderEnabled };
+function isPrerenderEnabled(vikeConfigGlobal) {
+    return (vikeConfigGlobal.prerender &&
+        !vikeConfigGlobal.prerender.disableAutoRun &&
+        vikeConfigGlobal.disableAutoFullBuild !== 'prerender');
+}

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -3,7 +3,6 @@ export { runPrerenderFromCLIPrerenderCommand };
 export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
 export type { PrerenderOptions };
-import '../runtime/page-files/setup.js';
 import type { InlineConfig, ResolvedConfig } from 'vite';
 import type { APIOptions } from '../api/types.js';
 type PrerenderOptions = APIOptions & {
@@ -30,5 +29,5 @@ declare function runPrerenderFromAPI(options?: PrerenderOptions): Promise<{
     viteConfig: ResolvedConfig;
 }>;
 declare function runPrerenderFromCLIPrerenderCommand(): Promise<void>;
-declare function runPrerenderFromAutoRun(viteConfig: InlineConfig, forceExit: boolean): Promise<void>;
+declare function runPrerenderFromAutoRun(viteConfig: InlineConfig | undefined): Promise<void>;
 declare function runPrerender_forceExit(): void;

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

@@ -2,7 +2,6 @@ export { runPrerenderFromAPI };
 export { runPrerenderFromCLIPrerenderCommand };
 export { runPrerenderFromAutoRun };
 export { runPrerender_forceExit };
-import '../runtime/page-files/setup.js';
 import path from 'path';
 import { route } from '../../shared/route/index.js';
 import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender } from './utils.js';
@@ -15,7 +14,7 @@ import { getPageFilesServerSide } from '../../shared/getPageFiles.js';
 import { getPageContextRequestUrl } from '../../shared/getPageContextRequestUrl.js';
 import { getUrlFromRouteString } from '../../shared/route/resolveRouteString.js';
 import { getConfigValueFilePathToShowToUser } from '../../shared/page-configs/helpers.js';
-import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../shared/page-configs/getConfigValueRuntime.js';
 import { loadConfigValues } from '../../shared/page-configs/loadConfigValues.js';
 import { isErrorPage } from '../../shared/error-page.js';
 import { getPageContextUrlComputed } from '../../shared/getPageContextUrlComputed.js';
@@ -46,7 +45,7 @@ async function runPrerenderFromCLIPrerenderCommand() {
     }
     runPrerender_forceExit();
 }
-async function runPrerenderFromAutoRun(viteConfig, forceExit) {
+async function runPrerenderFromAutoRun(viteConfig) {
     try {
         await runPrerender({ viteConfig });
     }
@@ -55,8 +54,6 @@ async function runPrerenderFromAutoRun(viteConfig, forceExit) {
         logErrorHint(err);
         process.exit(1);
     }
-    if (forceExit)
-        runPrerender_forceExit();
 }
 async function runPrerender(options = {}, standaloneTrigger) {
     checkOutdatedOptions(options);
@@ -68,8 +65,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
         console.log(`${pc.cyan(`vike v${projectInfo.projectVersion}`)} ${pc.green('pre-rendering HTML...')}`);
     }
     await disableReactStreaming();
-    const viteConfig = await resolveConfig(options.viteConfig || {}, 'vike pre-rendering', 'production');
-    assertLoadedConfig(viteConfig, options);
+    const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');
     const vikeConfig = await getVikeConfig(viteConfig);
     const { outDirClient } = getOutDirs(viteConfig);
     const { root } = viteConfig;
@@ -481,7 +477,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
                 usesClientRouter = getConfigValueRuntime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
             }
             else {
-                usesClientRouter = globalContext.pluginManifest.usesClientRouter;
+                usesClientRouter = globalContext.usesClientRouter;
             }
         }
         objectAssign(pageContext, {
@@ -672,25 +668,6 @@ async function disableReactStreaming() {
     const { disable } = mod;
     disable();
 }
-function assertLoadedConfig(viteConfig, options) {
-    if (viteConfig.plugins.some((p) => p.name.startsWith('vike'))) {
-        return;
-    }
-    const { configFile } = viteConfig;
-    if (configFile) {
-        assertUsage(false, `${configFile} doesn't install the vike plugin`);
-    }
-    else {
-        if (!options.viteConfig) {
-            assertUsage(false, `[prerender()] No vite.config.js file found at ${process.cwd()}. Use the option ${pc.cyan('prerender({ viteConfig })')}.`, { showStackTrace: true });
-        }
-        else {
-            assertUsage(false, `[prerender()] The Vite config ${pc.cyan('prerender({ viteConfig })')} is missing the vike plugin.`, {
-                showStackTrace: true
-            });
-        }
-    }
-}
 function isSameUrl(url1, url2) {
     return normalizeUrl(url1) === normalizeUrl(url2);
 }

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

@@ -12,10 +12,11 @@ export { setGlobalContext_viteConfig };
 export { setGlobalContext_vikeConfig };
 export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
+export { setGlobalContext_buildEntry };
+export { clearGlobalContext };
 import type { ViteManifest } from '../shared/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
-import { PluginManifest } from '../shared/assertPluginManifest.js';
-import type { VikeConfigGlobal } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig/resolveVikeConfigGlobal.js';
+import type { VikeConfigGlobal } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 import { type RuntimeManifest } from '../shared/assertRuntimeManifest.js';
 import type { VikeConfigObject } from '../plugin/plugins/importUserCode/v1-design/getVikeConfig.js';
 type GlobalContextPublic = {
@@ -35,17 +36,16 @@ type GlobalContext = {
     vikeConfig: VikeConfigObject;
     viteDevServer: ViteDevServer;
     assetsManifest: null;
-    pluginManifest: null;
 } | ({
     isProduction: true;
     assetsManifest: ViteManifest;
-    pluginManifest: PluginManifest;
     viteDevServer: null;
 } & ({
     isPrerendering: false;
     viteConfig: null;
 } | {
     isPrerendering: true;
+    usesClientRouter: boolean;
     viteConfig: ResolvedConfig;
 })));
 declare function getGlobalContext(): GlobalContext;
@@ -64,3 +64,5 @@ declare function initGlobalContext_renderPage(): Promise<void>;
 declare function initGlobalContext_runPrerender(): Promise<void>;
 declare function initGlobalContext_getGlobalContextAsync(isProduction: boolean): Promise<void>;
 declare function getRuntimeManifest(vikeConfigGlobal: VikeConfigGlobal, viteConfig: ResolvedConfig): RuntimeManifest;
+declare function setGlobalContext_buildEntry(buildEntry: unknown): void;
+declare function clearGlobalContext(): void;

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

@@ -14,23 +14,24 @@ 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';
+export { setGlobalContext_buildEntry };
+export { clearGlobalContext };
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, objectKeys, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger } from './utils.js';
+import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
+import { virtualFileIdImportUserCodeServer } from '../shared/virtual-files/virtualFileImportUserCode.js';
+import { setPageFiles, setPageFilesAsync } from '../../shared/getPageFiles/getPageFiles.js';
 import { assertPluginManifest } from '../shared/assertPluginManifest.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 {
-        viteDevServerPromise,
-        viteDevServerPromiseResolve
-    };
-})());
+const debug = createDebugger('vike:globalContext');
+const globalObject = getGlobalObject('globalContext.ts', getInitialGlobalContext());
+initDevEntry();
 function getGlobalContext() {
-    assert(globalObject.globalContext);
+    if (!globalObject.globalContext) {
+        debug('getGlobalContext()', new Error().stack);
+        assert(false);
+    }
     return globalObject.globalContext;
 }
 /** @experimental https://vike.dev/getGlobalContext */
@@ -109,9 +110,11 @@ function getViteConfig() {
     return globalObject.viteConfig ?? null;
 }
 async function initGlobalContext_renderPage() {
+    debug('initGlobalContext_renderPage()');
     await initGlobalContext(!globalObject.isViteDev);
 }
 async function initGlobalContext_runPrerender() {
+    debug('initGlobalContext_runPrerender()');
     if (globalObject.initGlobalContext_runPrerender_alreadyCalled)
         return;
     globalObject.initGlobalContext_runPrerender_alreadyCalled = true;
@@ -125,6 +128,7 @@ async function initGlobalContext_runPrerender() {
     await initGlobalContext(true);
 }
 async function initGlobalContext_getGlobalContextAsync(isProduction) {
+    debug('initGlobalContext_getGlobalContextAsync()');
     if (!isProduction) {
         const waitFor = 20;
         const timeout = setTimeout(() => {
@@ -152,13 +156,11 @@ async function initGlobalContext(isProduction) {
         assert(vikeConfig);
         assert(viteDevServer);
         assert(!isPrerendering);
-        const vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
-        const pluginManifest = getRuntimeManifest(vikeConfigGlobal, viteConfig);
+        const pluginManifest = getRuntimeManifest(vikeConfig.vikeConfigGlobal, viteConfig);
         globalObject.globalContext = {
             isProduction: false,
             isPrerendering: false,
             assetsManifest: null,
-            pluginManifest: null,
             viteDevServer,
             viteConfig,
             vikeConfig,
@@ -171,22 +173,21 @@ async function initGlobalContext(isProduction) {
         };
     }
     else {
-        const buildEntries = await loadImportBuild(globalObject.outDirRoot);
-        assertBuildEntries(buildEntries, isPrerendering ?? false);
-        const { pageFiles, assetsManifest, pluginManifest } = buildEntries;
-        setPageFiles(pageFiles);
+        const buildEntry = await getBuildEntry(globalObject.outDirRoot);
+        const { assetsManifest, pluginManifest } = buildEntry;
+        setPageFiles(buildEntry.pageFiles);
         assertViteManifest(assetsManifest);
         assertPluginManifest(pluginManifest);
         const globalContext = {
             isProduction: true,
             assetsManifest,
-            pluginManifest,
             viteDevServer: null,
             baseServer: pluginManifest.baseServer,
             baseAssets: pluginManifest.baseAssets,
             includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
             redirects: pluginManifest.redirects,
             trailingSlash: pluginManifest.trailingSlash,
+            usesClientRouter: pluginManifest.usesClientRouter,
             disableUrlNormalization: pluginManifest.disableUrlNormalization
         };
         if (isPrerendering) {
@@ -220,15 +221,6 @@ function getRuntimeManifest(vikeConfigGlobal, viteConfig) {
     assertRuntimeManifest(manifest);
     return manifest;
 }
-function assertBuildEntries(buildEntries, isPreRendering) {
-    const errMsg = [
-        `You are tyring to run`,
-        isPreRendering ? 'pre-rendering' : 'the server for production',
-        `but your app isn't built yet. Run ${pc.cyan('$ vike build')} before `,
-        isPreRendering ? 'pre-rendering.' : 'running the server.'
-    ].join(' ');
-    assertUsage(buildEntries, errMsg);
-}
 function assertViteManifest(manifest) {
     assert(isPlainObject(manifest));
     /* We should include these assertions but we don't as a workaround for PWA manifests: https://github.com/vikejs/vike/issues/769
@@ -247,3 +239,58 @@ function eagerlyLoadUserFiles() {
     // We call it as early as possible here for better performance.
     getPageFilesExports();
 }
+async function getBuildEntry(outDir) {
+    debug('getBuildEntry()');
+    if (!globalObject.buildEntry) {
+        debug('importServerProductionEntry()');
+        await importServerProductionEntry({ outDir });
+        if (!globalObject.buildEntry) {
+            debug('globalObject.buildEntryPrevious');
+            // Needed, for example, when calling the API prerender() then preview() because both trigger a importServerProductionEntry() call but only the first only is applied because of the import() cache. (A proper implementation would be to clear the import() cache, but it probably isn't possible on platforms such as Cloudflare Workers.)
+            globalObject.buildEntry = globalObject.buildEntryPrevious;
+        }
+        assert(globalObject.buildEntry);
+    }
+    const { buildEntry } = globalObject;
+    assert(isObject(buildEntry));
+    assert(hasProp(buildEntry, 'pageFiles', 'object'));
+    assert(hasProp(buildEntry, 'assetsManifest', 'object'));
+    assert(hasProp(buildEntry, 'pluginManifest', 'object'));
+    return buildEntry;
+}
+function setGlobalContext_buildEntry(buildEntry) {
+    debug('setGlobalContext_buildEntry()');
+    globalObject.buildEntry = buildEntry;
+    globalObject.buildEntryPrevious = buildEntry;
+}
+function initDevEntry() {
+    setPageFilesAsync(getPageFilesExports);
+}
+async function getPageFilesExports() {
+    const viteDevServer = getViteDevServer();
+    assert(viteDevServer);
+    let moduleExports;
+    try {
+        moduleExports = await viteDevServer.ssrLoadModule(virtualFileIdImportUserCodeServer);
+    }
+    catch (err) {
+        debugGlob(`Glob error: ${virtualFileIdImportUserCodeServer} transpile error: `, err);
+        throw err;
+    }
+    moduleExports = moduleExports.default || moduleExports;
+    debugGlob('Glob result: ', moduleExports);
+    assert(isObject(moduleExports));
+    return moduleExports;
+}
+function clearGlobalContext() {
+    debug('clearGlobalContext()');
+    objectReplace(globalObject, getInitialGlobalContext(), ['buildEntryPrevious']);
+}
+function getInitialGlobalContext() {
+    debug('getInitialGlobalContext()');
+    const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = genPromise();
+    return {
+        viteDevServerPromise,
+        viteDevServerPromiseResolve
+    };
+}

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -5,7 +5,7 @@ import { sanitizeJson } from './sanitizeJson.js';
 import { inferAssetTag, inferPreloadTag } from './inferHtmlTags.js';
 import { mergeScriptTags } from './mergeScriptTags.js';
 import { getPageConfig } from '../../../../shared/page-configs/helpers.js';
-import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValue.js';
+import { getConfigValueRuntime } from '../../../../shared/page-configs/getConfigValueRuntime.js';
 import { getGlobalContext } from '../../globalContext.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';