vike 0.4.218 → 0.4.220

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

@@ -2,11 +2,10 @@ 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';
-import { prerenderPage, prerender404Page, getRenderContext, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
+import { assert, assertUsage, assertWarning, hasProp, projectInfo, objectAssign, isObjectWithKeys, isCallable, getOutDirs, isPropertyGetter, assertPosixPath, urlToFile, isPlainObject, pLimit, isArray, changeEnumerable, onSetupPrerender, isObject } from './utils.js';
+import { prerenderPage, prerender404Page, getPageContextInitEnhanced } from '../runtime/renderPage/renderPageAlreadyRouted.js';
 import pc from '@brillout/picocolors';
 import { cpus } from 'os';
 import { getGlobalContext, initGlobalContext_runPrerender, setGlobalContext_isPrerendering } from '../runtime/globalContext.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);
@@ -69,11 +66,11 @@ async function runPrerender(options = {}, standaloneTrigger) {
     }
     await disableReactStreaming();
     const viteConfig = await resolveConfig(options.viteConfig || {}, 'build', 'production');
-    assertLoadedConfig(viteConfig, options);
     const vikeConfig = await getVikeConfig(viteConfig);
     const { outDirClient } = getOutDirs(viteConfig);
     const { root } = viteConfig;
     const prerenderConfig = vikeConfig.vikeConfigGlobal.prerender;
+    validatePrerenderConfig(prerenderConfig);
     if (!prerenderConfig) {
         assert(standaloneTrigger);
         assertWarning(prerenderConfig, `You're executing ${pc.cyan(standaloneTrigger)} but the config ${pc.cyan('prerender')} isn't set to true`, {
@@ -83,8 +80,8 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = pLimit(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? cpus().length : parallel);
     await initGlobalContext_runPrerender();
-    const renderContext = await getRenderContext();
-    renderContext.pageFilesAll.forEach(assertExportNames);
+    const globalContext = getGlobalContext();
+    globalContext.pageFilesAll.forEach(assertExportNames);
     const prerenderContext = {};
     objectAssign(prerenderContext, {
         _urlHandler: null,
@@ -93,10 +90,10 @@ async function runPrerender(options = {}, standaloneTrigger) {
         pageContextInit: options.pageContextInit ?? null
     });
     const doNotPrerenderList = [];
-    await collectDoNoPrerenderList(renderContext, vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
-    await callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList);
-    await handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit);
-    await callOnPrerenderStartHook(prerenderContext, renderContext);
+    await collectDoNoPrerenderList(vikeConfig.pageConfigs, doNotPrerenderList, concurrencyLimit);
+    await callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList);
+    await handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit);
+    await callOnPrerenderStartHook(prerenderContext);
     const prerenderedPageContexts = {};
     let prerenderedCount = 0;
     const onComplete = async (htmlFile) => {
@@ -108,14 +105,14 @@ async function runPrerender(options = {}, standaloneTrigger) {
     };
     await routeAndPrerender(prerenderContext, concurrencyLimit, onComplete);
     warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerenderList);
-    await prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete);
+    await prerender404(prerenderedPageContexts, prerenderContext, onComplete);
     if (logLevel === 'info') {
         console.log(`${pc.green(`✓`)} ${prerenderedCount} HTML documents pre-rendered.`);
     }
-    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial);
+    warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial);
     return { viteConfig };
 }
-async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerenderList, concurrencyLimit) {
+async function collectDoNoPrerenderList(pageConfigs, doNotPrerenderList, concurrencyLimit) {
     // V1 design
     pageConfigs.forEach((pageConfig) => {
         const configName = 'prerender';
@@ -133,7 +130,8 @@ async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerend
     });
     // Old design
     // TODO/v1-release: remove
-    await Promise.all(renderContext.pageFilesAll
+    const globalContext = getGlobalContext();
+    await Promise.all(globalContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
         if (!p.exportNames?.includes('doNotPrerender'))
@@ -145,8 +143,8 @@ async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerend
         assert(p.loadFile);
         await p.loadFile();
     })));
-    renderContext.allPageIds.forEach((pageId) => {
-        const pageFilesServerSide = getPageFilesServerSide(renderContext.pageFilesAll, pageId);
+    globalContext.allPageIds.forEach((pageId) => {
+        const pageFilesServerSide = getPageFilesServerSide(globalContext.pageFilesAll, pageId);
         for (const p of pageFilesServerSide) {
             if (!p.exportNames?.includes('doNotPrerender'))
                 continue;
@@ -175,10 +173,11 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     assert(exportNames || fileType === '.page.route' || fileType === '.css', pageFile.filePath);
 }
-async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext, concurrencyLimit, doNotPrerenderList) {
+async function callOnBeforePrerenderStartHooks(prerenderContext, concurrencyLimit, doNotPrerenderList) {
     const onBeforePrerenderStartHooks = [];
+    const globalContext = getGlobalContext();
     // V1 design
-    await Promise.all(renderContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
+    await Promise.all(globalContext.pageConfigs.map((pageConfig) => concurrencyLimit(async () => {
         const hookName = 'onBeforePrerenderStart';
         const pageConfigLoaded = await loadConfigValues(pageConfig, false);
         const hook = getHookFromPageConfig(pageConfigLoaded, hookName);
@@ -194,7 +193,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         });
     })));
     // 0.4 design
-    await Promise.all(renderContext.pageFilesAll
+    await Promise.all(globalContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
         if (!p.exportNames?.includes('prerender'))
@@ -235,7 +234,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
                     assertUsage(false, `URL ${pc.cyan(url)} provided ${providedTwice}. Make sure to provide the URL only once instead.`);
                 }
             }
-            const pageContextNew = createPageContext(url, renderContext, prerenderContext);
+            const pageContextNew = createPageContext(url, prerenderContext);
             objectAssign(pageContextNew, {
                 _providedByHook: {
                     hookFilePath,
@@ -252,9 +251,10 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
         });
     })));
 }
-async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNotPrerenderList, concurrencyLimit) {
+async function handlePagesWithStaticRoutes(prerenderContext, doNotPrerenderList, concurrencyLimit) {
     // Pre-render pages with a static route
-    await Promise.all(renderContext.pageRoutes.map((pageRoute) => concurrencyLimit(async () => {
+    const globalContext = getGlobalContext();
+    await Promise.all(globalContext.pageRoutes.map((pageRoute) => concurrencyLimit(async () => {
         const { pageId } = pageRoute;
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
             return;
@@ -279,7 +279,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
             return;
         }
         const routeParams = {};
-        const pageContext = createPageContext(urlOriginal, renderContext, prerenderContext);
+        const pageContext = createPageContext(urlOriginal, prerenderContext);
         objectAssign(pageContext, {
             _providedByHook: null,
             routeParams,
@@ -297,7 +297,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
         prerenderContext.pageContexts.push(pageContext);
     })));
 }
-function createPageContext(urlOriginal, renderContext, prerenderContext) {
+function createPageContext(urlOriginal, prerenderContext) {
     const pageContext = {
         _urlHandler: null,
         _urlRewrite: null,
@@ -309,17 +309,18 @@ function createPageContext(urlOriginal, renderContext, prerenderContext) {
     };
     objectAssign(pageContextInit, prerenderContext.pageContextInit);
     {
-        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, renderContext);
+        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit);
         objectAssign(pageContext, pageContextInitEnhanced);
     }
     return pageContext;
 }
-async function callOnPrerenderStartHook(prerenderContext, renderContext) {
+async function callOnPrerenderStartHook(prerenderContext) {
+    const globalContext = getGlobalContext();
     let onPrerenderStartHook;
     // V1 design
-    if (renderContext.pageConfigs.length > 0) {
+    if (globalContext.pageConfigs.length > 0) {
         const hookName = 'onPrerenderStart';
-        const hook = getHookFromPageConfigGlobal(renderContext.pageConfigGlobal, hookName);
+        const hook = getHookFromPageConfigGlobal(globalContext.pageConfigGlobal, hookName);
         if (hook) {
             assert(hook.hookName === 'onPrerenderStart');
             onPrerenderStartHook = {
@@ -331,9 +332,9 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     }
     // Old design
     // TODO/v1-release: remove
-    if (renderContext.pageConfigs.length === 0) {
+    if (globalContext.pageConfigs.length === 0) {
         const hookTimeout = getHookTimeoutDefault('onBeforePrerender');
-        const pageFilesWithOnBeforePrerenderHook = renderContext.pageFilesAll.filter((p) => {
+        const pageFilesWithOnBeforePrerenderHook = globalContext.pageFilesAll.filter((p) => {
             assertExportNames(p);
             if (!p.exportNames?.includes('onBeforePrerender'))
                 return false;
@@ -481,7 +482,7 @@ async function routeAndPrerender(prerenderContext, concurrencyLimit, onComplete)
                 usesClientRouter = getConfigValueRuntime(pageConfig, 'clientRouting', 'boolean')?.value ?? false;
             }
             else {
-                usesClientRouter = globalContext.pluginManifest.usesClientRouter;
+                usesClientRouter = globalContext.usesClientRouter;
             }
         }
         objectAssign(pageContext, {
@@ -521,27 +522,28 @@ function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerende
         assertWarning(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${pc.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${pc.cyan(setByConfigName)} to ${pc.cyan(String(setByConfigValue))} or remove the URL ${pc.cyan(urlOriginal)} from the list of URLs to be pre-rendered.`, { onlyOnce: true });
     });
 }
-function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, renderContext, partial) {
-    const isV1 = renderContext.pageConfigs.length > 0;
+function warnMissingPages(prerenderedPageContexts, doNotPrerenderList, partial) {
+    const globalContext = getGlobalContext();
+    const isV1 = globalContext.pageConfigs.length > 0;
     const hookName = isV1 ? 'onBeforePrerenderStart' : 'prerender';
     /* TODO/after-v1-design-release: document setting `prerender: false` as an alternative to using prerender.partial (both in the warnings and the docs)
     const optOutName = isV1 ? 'prerender' : 'doNotPrerender'
     const msgAddendum = `Explicitly opt-out by setting the config ${optOutName} to ${isV1 ? 'false' : 'true'} or use the option prerender.partial`
     */
-    renderContext.allPageIds
+    globalContext.allPageIds
         .filter((pageId) => !prerenderedPageContexts[pageId])
         .filter((pageId) => !doNotPrerenderList.find((p) => p.pageId === pageId))
-        .filter((pageId) => !isErrorPage(pageId, renderContext.pageConfigs))
+        .filter((pageId) => !isErrorPage(pageId, globalContext.pageConfigs))
         .forEach((pageId) => {
         const pageAt = isV1 ? pageId : `\`${pageId}.page.*\``;
         assertWarning(partial, `Cannot pre-render page ${pageAt} because it has a non-static route, while no ${hookName}() hook returned any URL matching the page's route. You need to use a ${hookName}() hook (https://vike.dev/${hookName}) providing a list of URLs for ${pageAt} that should be pre-rendered. If you don't want to pre-render ${pageAt} then use the option prerender.partial (https://vike.dev/prerender#partial) to suppress this warning.`, { onlyOnce: true });
     });
 }
-async function prerender404(prerenderedPageContexts, renderContext, prerenderContext, onComplete) {
+async function prerender404(prerenderedPageContexts, prerenderContext, onComplete) {
     if (!Object.values(prerenderedPageContexts).find(({ urlOriginal }) => urlOriginal === '/404')) {
         let result;
         try {
-            result = await prerender404Page(renderContext, prerenderContext.pageContextInit);
+            result = await prerender404Page(prerenderContext.pageContextInit);
         }
         catch (err) {
             assertIsNotAbort(err, 'the 404 page');
@@ -672,25 +674,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);
 }
@@ -740,3 +723,38 @@ function makePageContextComputedUrlNonEnumerable(pageContexts) {
         });
     }
 }
+function validatePrerenderConfig(
+// Guaranteed by configDef.type to be either an object or boolean
+prerenderConfig) {
+    if (!prerenderConfig || typeof prerenderConfig === 'boolean')
+        return;
+    assert(isObject(prerenderConfig));
+    const wrongValue = (() => {
+        {
+            const p = 'partial';
+            if (!hasProp(prerenderConfig, p, 'boolean') && !hasProp(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'noExtraDir';
+            if (!hasProp(prerenderConfig, p, 'boolean') && !hasProp(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'disableAutoRun';
+            if (!hasProp(prerenderConfig, p, 'boolean') && !hasProp(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'parallel';
+            if (!hasProp(prerenderConfig, p, 'boolean') &&
+                !hasProp(prerenderConfig, p, 'number') &&
+                !hasProp(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean or a number' };
+        }
+    })();
+    if (wrongValue) {
+        const { prop, errMsg } = wrongValue;
+        assertUsage(false, `Setting ${pc.cyan(`prerender.${prop}`)} ${errMsg}`);
+    }
+}

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

@@ -13,4 +13,5 @@ export * from '../../utils/assertSetup.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
+export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';

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

@@ -15,4 +15,5 @@ export * from '../../utils/assertSetup.js';
 export * from '../../utils/pLimit.js';
 export * from '../../utils/isFilePathAbsoluteFilesystem.js';
 export * from '../../utils/isArray.js';
+export * from '../../utils/isObject.js';
 export * from '../../utils/changeEnumerable.js';

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

@@ -12,40 +12,43 @@ 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';
+import type { ConfigUserFriendly } from '../../shared/page-configs/getPageConfigUserFriendly.js';
 type GlobalContextPublic = {
     assetsManifest: null | ViteManifest;
 };
+type PageRuntimeInfo = Awaited<ReturnType<typeof getPageRuntimeInfo>>['userFiles'];
 type GlobalContext = {
     baseServer: string;
     baseAssets: null | string;
     includeAssetsImportedByServer: boolean;
-    redirects: Record<string, string>;
     trailingSlash: boolean;
     disableUrlNormalization: boolean;
-} & ({
+    vikeConfig: {
+        global: ConfigUserFriendly;
+    };
+} & PageRuntimeInfo & ({
     isProduction: false;
     isPrerendering: false;
     viteConfig: ResolvedConfig;
-    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;
@@ -63,4 +66,17 @@ 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 getPageRuntimeInfo(isProduction: boolean): Promise<{
+    userFiles: {
+        pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
+        pageConfigs: import("../../__internal/index.js").PageConfig[];
+        pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        allPageIds: string[];
+        pageRoutes: import("../../shared/route/loadPageRoutes.js").PageRoutes;
+        onBeforeRouteHook: import("../../shared/hooks/getHook.js").Hook | null;
+    };
+    globalConfig: ConfigUserFriendly;
+}>;
 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,26 @@ 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 { getPageFilesAll, 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
-    };
-})());
+import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
+import { assertV1Design } from '../shared/assertV1Design.js';
+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 */
@@ -48,6 +51,7 @@ async function getGlobalContextAsync(isProduction) {
 }
 function makePublic(globalContext) {
     const globalContextPublic = {
+        // TODO/now: add viteConfig and vikeConfig
         assetsManifest: globalContext.assetsManifest
     };
     // Add internals (and prepended _ prefix to their keys)
@@ -109,9 +113,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 +131,7 @@ async function initGlobalContext_runPrerender() {
     await initGlobalContext(true);
 }
 async function initGlobalContext_getGlobalContextAsync(isProduction) {
+    debug('initGlobalContext_getGlobalContextAsync()');
     if (!isProduction) {
         const waitFor = 20;
         const timeout = setTimeout(() => {
@@ -138,6 +145,7 @@ async function initGlobalContext_getGlobalContextAsync(isProduction) {
     }
     await initGlobalContext(isProduction);
 }
+// TODO/now: refactor: move this to the top of the file
 async function initGlobalContext(isProduction) {
     if (globalObject.globalContext) {
         assert(globalObject.globalContext.isProduction === isProduction);
@@ -152,41 +160,45 @@ async function initGlobalContext(isProduction) {
         assert(vikeConfig);
         assert(viteDevServer);
         assert(!isPrerendering);
-        const vikeConfigGlobal = vikeConfig.vikeConfigGlobal;
-        const pluginManifest = getRuntimeManifest(vikeConfigGlobal, viteConfig);
+        const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
+        const pluginManifest = getRuntimeManifest(vikeConfig.vikeConfigGlobal, viteConfig);
         globalObject.globalContext = {
             isProduction: false,
             isPrerendering: false,
             assetsManifest: null,
-            pluginManifest: null,
             viteDevServer,
             viteConfig,
-            vikeConfig,
+            vikeConfig: {
+                global: globalConfig
+            },
+            ...userFiles,
             baseServer: pluginManifest.baseServer,
             baseAssets: pluginManifest.baseAssets,
             includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
-            redirects: pluginManifest.redirects,
             trailingSlash: pluginManifest.trailingSlash,
             disableUrlNormalization: pluginManifest.disableUrlNormalization
         };
     }
     else {
-        const buildEntries = await loadImportBuild(globalObject.outDirRoot);
-        assertBuildEntries(buildEntries, isPrerendering ?? false);
-        const { pageFiles, assetsManifest, pluginManifest } = buildEntries;
-        setPageFiles(pageFiles);
+        const buildEntry = await getBuildEntry(globalObject.outDirRoot, isPrerendering);
+        const { assetsManifest, pluginManifest } = buildEntry;
+        setPageFiles(buildEntry.pageFiles);
+        const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
         assertViteManifest(assetsManifest);
         assertPluginManifest(pluginManifest);
         const globalContext = {
             isProduction: true,
             assetsManifest,
-            pluginManifest,
+            vikeConfig: {
+                global: globalConfig
+            },
+            ...userFiles,
             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) {
@@ -206,29 +218,35 @@ async function initGlobalContext(isProduction) {
         }
     }
 }
+async function getPageRuntimeInfo(isProduction) {
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig } = await getPageFilesAll(false, isProduction);
+    const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
+    const userFiles = {
+        pageFilesAll,
+        pageConfigs,
+        pageConfigGlobal,
+        allPageIds,
+        pageRoutes,
+        onBeforeRouteHook
+    };
+    assertV1Design(
+    // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
+    pageConfigs.length > 0, pageFilesAll);
+    return { userFiles, globalConfig };
+}
 function getRuntimeManifest(vikeConfigGlobal, viteConfig) {
-    const { includeAssetsImportedByServer, redirects, trailingSlash, disableUrlNormalization } = vikeConfigGlobal;
+    const { includeAssetsImportedByServer, trailingSlash, disableUrlNormalization } = vikeConfigGlobal;
     const { baseServer, baseAssets } = resolveBaseFromResolvedConfig(vikeConfigGlobal.baseServer, vikeConfigGlobal.baseAssets, viteConfig);
     const manifest = {
         baseServer,
         baseAssets,
         includeAssetsImportedByServer,
-        redirects,
         trailingSlash,
         disableUrlNormalization
     };
     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 +265,59 @@ function eagerlyLoadUserFiles() {
     // We call it as early as possible here for better performance.
     getPageFilesExports();
 }
+async function getBuildEntry(outDir, isPrerendering) {
+    debug('getBuildEntry()');
+    if (!globalObject.buildEntry) {
+        debug('importServerProductionEntry()');
+        // importServerProductionEntry() loads dist/server/entry.mjs which calls setGlobalContext_buildEntry()
+        await importServerProductionEntry({ outDir, doNotLoadServer: isPrerendering });
+        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';

package/dist/esm/node/runtime/index-common.d.ts

@@ -6,4 +6,3 @@ export { getGlobalContextSync, getGlobalContextAsync } from './globalContext.js'
 export { createDevMiddleware } from '../runtime-dev/index.js';
 export { injectAssets__public as _injectAssets } from './html/injectAssets/injectAssets__public.js';
 export { createPageRenderer } from '../createPageRenderer.js';
-import './page-files/setup.js';