vike 0.4.218-commit-85af52a → 0.4.218-commit-65f582c

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

@@ -108,6 +108,7 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { outDirClient } = (0, utils_js_1.getOutDirs)(viteConfig);
     const { root } = viteConfig;
     const prerenderConfig = vikeConfig.vikeConfigGlobal.prerender;
+    validatePrerenderConfig(prerenderConfig);
     if (!prerenderConfig) {
         (0, utils_js_1.assert)(standaloneTrigger);
         (0, utils_js_1.assertWarning)(prerenderConfig, `You're executing ${picocolors_1.default.cyan(standaloneTrigger)} but the config ${picocolors_1.default.cyan('prerender')} isn't set to true`, {
@@ -117,8 +118,8 @@ async function runPrerender(options = {}, standaloneTrigger) {
     const { partial = false, noExtraDir = false, parallel = true } = prerenderConfig || {};
     const concurrencyLimit = (0, utils_js_1.pLimit)(parallel === false || parallel === 0 ? 1 : parallel === true || parallel === undefined ? (0, os_1.cpus)().length : parallel);
     await (0, globalContext_js_1.initGlobalContext_runPrerender)();
-    const renderContext = await (0, renderPageAlreadyRouted_js_1.getRenderContext)();
-    renderContext.pageFilesAll.forEach(assertExportNames);
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    globalContext.pageFilesAll.forEach(assertExportNames);
     const prerenderContext = {};
     (0, utils_js_1.objectAssign)(prerenderContext, {
         _urlHandler: null,
@@ -127,10 +128,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) => {
@@ -142,14 +143,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(`${picocolors_1.default.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';
@@ -167,7 +168,8 @@ async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerend
     });
     // Old design
     // TODO/v1-release: remove
-    await Promise.all(renderContext.pageFilesAll
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    await Promise.all(globalContext.pageFilesAll
         .filter((p) => {
         assertExportNames(p);
         if (!p.exportNames?.includes('doNotPrerender'))
@@ -179,8 +181,8 @@ async function collectDoNoPrerenderList(renderContext, pageConfigs, doNotPrerend
         (0, utils_js_1.assert)(p.loadFile);
         await p.loadFile();
     })));
-    renderContext.allPageIds.forEach((pageId) => {
-        const pageFilesServerSide = (0, getPageFiles_js_1.getPageFilesServerSide)(renderContext.pageFilesAll, pageId);
+    globalContext.allPageIds.forEach((pageId) => {
+        const pageFilesServerSide = (0, getPageFiles_js_1.getPageFilesServerSide)(globalContext.pageFilesAll, pageId);
         for (const p of pageFilesServerSide) {
             if (!p.exportNames?.includes('doNotPrerender'))
                 continue;
@@ -209,10 +211,11 @@ function assertExportNames(pageFile) {
     const { exportNames, fileType } = pageFile;
     (0, utils_js_1.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 = (0, globalContext_js_1.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 (0, loadConfigValues_js_1.loadConfigValues)(pageConfig, false);
         const hook = (0, getHook_js_1.getHookFromPageConfig)(pageConfigLoaded, hookName);
@@ -228,7 +231,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'))
@@ -269,7 +272,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, renderContext,
                     (0, utils_js_1.assertUsage)(false, `URL ${picocolors_1.default.cyan(url)} provided ${providedTwice}. Make sure to provide the URL only once instead.`);
                 }
             }
-            const pageContextNew = createPageContext(url, renderContext, prerenderContext);
+            const pageContextNew = createPageContext(url, prerenderContext);
             (0, utils_js_1.objectAssign)(pageContextNew, {
                 _providedByHook: {
                     hookFilePath,
@@ -286,9 +289,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 = (0, globalContext_js_1.getGlobalContext)();
+    await Promise.all(globalContext.pageRoutes.map((pageRoute) => concurrencyLimit(async () => {
         const { pageId } = pageRoute;
         if (doNotPrerenderList.find((p) => p.pageId === pageId)) {
             return;
@@ -313,7 +317,7 @@ async function handlePagesWithStaticRoutes(prerenderContext, renderContext, doNo
             return;
         }
         const routeParams = {};
-        const pageContext = createPageContext(urlOriginal, renderContext, prerenderContext);
+        const pageContext = createPageContext(urlOriginal, prerenderContext);
         (0, utils_js_1.objectAssign)(pageContext, {
             _providedByHook: null,
             routeParams,
@@ -331,7 +335,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,
@@ -343,17 +347,18 @@ function createPageContext(urlOriginal, renderContext, prerenderContext) {
     };
     (0, utils_js_1.objectAssign)(pageContextInit, prerenderContext.pageContextInit);
     {
-        const pageContextInitEnhanced = (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, renderContext);
+        const pageContextInitEnhanced = (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit);
         (0, utils_js_1.objectAssign)(pageContext, pageContextInitEnhanced);
     }
     return pageContext;
 }
-async function callOnPrerenderStartHook(prerenderContext, renderContext) {
+async function callOnPrerenderStartHook(prerenderContext) {
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
     let onPrerenderStartHook;
     // V1 design
-    if (renderContext.pageConfigs.length > 0) {
+    if (globalContext.pageConfigs.length > 0) {
         const hookName = 'onPrerenderStart';
-        const hook = (0, getHook_js_1.getHookFromPageConfigGlobal)(renderContext.pageConfigGlobal, hookName);
+        const hook = (0, getHook_js_1.getHookFromPageConfigGlobal)(globalContext.pageConfigGlobal, hookName);
         if (hook) {
             (0, utils_js_1.assert)(hook.hookName === 'onPrerenderStart');
             onPrerenderStartHook = {
@@ -365,9 +370,9 @@ async function callOnPrerenderStartHook(prerenderContext, renderContext) {
     }
     // Old design
     // TODO/v1-release: remove
-    if (renderContext.pageConfigs.length === 0) {
+    if (globalContext.pageConfigs.length === 0) {
         const hookTimeout = (0, getHook_js_1.getHookTimeoutDefault)('onBeforePrerender');
-        const pageFilesWithOnBeforePrerenderHook = renderContext.pageFilesAll.filter((p) => {
+        const pageFilesWithOnBeforePrerenderHook = globalContext.pageFilesAll.filter((p) => {
             assertExportNames(p);
             if (!p.exportNames?.includes('onBeforePrerender'))
                 return false;
@@ -555,27 +560,28 @@ function warnContradictoryNoPrerenderList(prerenderedPageContexts, doNotPrerende
         (0, utils_js_1.assertWarning)(false, `The ${providedByHook.hookName}() hook defined by ${providedByHook.hookFilePath} returns the URL ${picocolors_1.default.cyan(urlOriginal)}, while ${setByConfigFile} sets the config ${picocolors_1.default.cyan(setByConfigName)} to ${picocolors_1.default.cyan(String(setByConfigValue))}. This is contradictory: either don't set the config ${picocolors_1.default.cyan(setByConfigName)} to ${picocolors_1.default.cyan(String(setByConfigValue))} or remove the URL ${picocolors_1.default.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 = (0, globalContext_js_1.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) => !(0, error_page_js_1.isErrorPage)(pageId, renderContext.pageConfigs))
+        .filter((pageId) => !(0, error_page_js_1.isErrorPage)(pageId, globalContext.pageConfigs))
         .forEach((pageId) => {
         const pageAt = isV1 ? pageId : `\`${pageId}.page.*\``;
         (0, utils_js_1.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 (0, renderPageAlreadyRouted_js_1.prerender404Page)(renderContext, prerenderContext.pageContextInit);
+            result = await (0, renderPageAlreadyRouted_js_1.prerender404Page)(prerenderContext.pageContextInit);
         }
         catch (err) {
             assertIsNotAbort(err, 'the 404 page');
@@ -755,3 +761,38 @@ function makePageContextComputedUrlNonEnumerable(pageContexts) {
         });
     }
 }
+function validatePrerenderConfig(
+// Guaranteed by configDef.type to be either an object or boolean
+prerenderConfig) {
+    if (!prerenderConfig || typeof prerenderConfig === 'boolean')
+        return;
+    (0, utils_js_1.assert)((0, utils_js_1.isObject)(prerenderConfig));
+    const wrongValue = (() => {
+        {
+            const p = 'partial';
+            if (!(0, utils_js_1.hasProp)(prerenderConfig, p, 'boolean') && !(0, utils_js_1.hasProp)(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'noExtraDir';
+            if (!(0, utils_js_1.hasProp)(prerenderConfig, p, 'boolean') && !(0, utils_js_1.hasProp)(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'disableAutoRun';
+            if (!(0, utils_js_1.hasProp)(prerenderConfig, p, 'boolean') && !(0, utils_js_1.hasProp)(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean' };
+        }
+        {
+            const p = 'parallel';
+            if (!(0, utils_js_1.hasProp)(prerenderConfig, p, 'boolean') &&
+                !(0, utils_js_1.hasProp)(prerenderConfig, p, 'number') &&
+                !(0, utils_js_1.hasProp)(prerenderConfig, p, 'undefined'))
+                return { prop: p, errMsg: 'should be a boolean or a number' };
+        }
+    })();
+    if (wrongValue) {
+        const { prop, errMsg } = wrongValue;
+        (0, utils_js_1.assertUsage)(false, `Setting ${picocolors_1.default.cyan(`prerender.${prop}`)} ${errMsg}`);
+    }
+}

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

@@ -31,4 +31,5 @@ __exportStar(require("../../utils/assertSetup.js"), exports);
 __exportStar(require("../../utils/pLimit.js"), exports);
 __exportStar(require("../../utils/isFilePathAbsoluteFilesystem.js"), exports);
 __exportStar(require("../../utils/isArray.js"), exports);
+__exportStar(require("../../utils/isObject.js"), exports);
 __exportStar(require("../../utils/changeEnumerable.js"), exports);

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

@@ -27,6 +27,8 @@ const assertPluginManifest_js_1 = require("../shared/assertPluginManifest.js");
 const assertRuntimeManifest_js_1 = require("../shared/assertRuntimeManifest.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const resolveBase_js_1 = require("../shared/resolveBase.js");
+const loadPageRoutes_js_1 = require("../../shared/route/loadPageRoutes.js");
+const assertV1Design_js_1 = require("../shared/assertV1Design.js");
 const debug = (0, utils_js_1.createDebugger)('vike:globalContext');
 const globalObject = (0, utils_js_1.getGlobalObject)('globalContext.ts', getInitialGlobalContext());
 initDevEntry();
@@ -52,6 +54,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)
@@ -145,6 +148,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) {
         (0, utils_js_1.assert)(globalObject.globalContext.isProduction === isProduction);
@@ -159,6 +163,7 @@ async function initGlobalContext(isProduction) {
         (0, utils_js_1.assert)(vikeConfig);
         (0, utils_js_1.assert)(viteDevServer);
         (0, utils_js_1.assert)(!isPrerendering);
+        const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
         const pluginManifest = getRuntimeManifest(vikeConfig.vikeConfigGlobal, viteConfig);
         globalObject.globalContext = {
             isProduction: false,
@@ -166,11 +171,13 @@ async function initGlobalContext(isProduction) {
             assetsManifest: 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
         };
@@ -179,16 +186,20 @@ async function initGlobalContext(isProduction) {
         const buildEntry = await getBuildEntry(globalObject.outDirRoot);
         const { assetsManifest, pluginManifest } = buildEntry;
         (0, getPageFiles_js_1.setPageFiles)(buildEntry.pageFiles);
+        const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
         assertViteManifest(assetsManifest);
         (0, assertPluginManifest_js_1.assertPluginManifest)(pluginManifest);
         const globalContext = {
             isProduction: true,
             assetsManifest,
+            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
@@ -210,14 +221,29 @@ async function initGlobalContext(isProduction) {
         }
     }
 }
+async function getPageRuntimeInfo(isProduction) {
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig } = await (0, getPageFiles_js_1.getPageFilesAll)(false, isProduction);
+    const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
+    const userFiles = {
+        pageFilesAll,
+        pageConfigs,
+        pageConfigGlobal,
+        allPageIds,
+        pageRoutes,
+        onBeforeRouteHook
+    };
+    (0, assertV1Design_js_1.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 } = (0, resolveBase_js_1.resolveBaseFromResolvedConfig)(vikeConfigGlobal.baseServer, vikeConfigGlobal.baseAssets, viteConfig);
     const manifest = {
         baseServer,
         baseAssets,
         includeAssetsImportedByServer,
-        redirects,
         trailingSlash,
         disableUrlNormalization
     };

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

@@ -7,10 +7,8 @@ exports.renderPageAlreadyRouted = renderPageAlreadyRouted;
 exports.prerenderPage = prerenderPage;
 exports.prerender404Page = prerender404Page;
 exports.getPageContextInitEnhanced = getPageContextInitEnhanced;
-exports.getRenderContext = getRenderContext;
 const error_page_js_1 = require("../../../shared/error-page.js");
 const renderHtml_js_1 = require("../html/renderHtml.js");
-const getPageFiles_js_1 = require("../../../shared/getPageFiles/getPageFiles.js");
 const utils_js_1 = require("../utils.js");
 const serializePageContextClientSide_js_1 = require("../html/serializePageContextClientSide.js");
 const getPageContextUrlComputed_js_1 = require("../../../shared/getPageContextUrlComputed.js");
@@ -23,10 +21,8 @@ const loggerRuntime_js_1 = require("./loggerRuntime.js");
 const isNewError_js_1 = require("./isNewError.js");
 const preparePageContextForUserConsumptionServerSide_js_1 = require("./preparePageContextForUserConsumptionServerSide.js");
 const executeGuardHook_js_1 = require("../../../shared/route/executeGuardHook.js");
-const loadPageRoutes_js_1 = require("../../../shared/route/loadPageRoutes.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
-const assertV1Design_js_1 = require("../../shared/assertV1Design.js");
 async function renderPageAlreadyRouted(pageContext) {
     // pageContext.pageId can either be the:
     //  - ID of the page matching the routing, or the
@@ -89,8 +85,9 @@ async function prerenderPage(pageContext) {
         return { documentHtml, pageContextSerialized, pageContext };
     }
 }
-async function prerender404Page(renderContext, pageContextInit_) {
-    const errorPageId = (0, error_page_js_1.getErrorPageId)(renderContext.pageFilesAll, renderContext.pageConfigs);
+async function prerender404Page(pageContextInit_) {
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext.pageFilesAll, globalContext.pageConfigs);
     if (!errorPageId) {
         return null;
     }
@@ -109,13 +106,13 @@ async function prerender404Page(renderContext, pageContextInit_) {
     };
     (0, utils_js_1.objectAssign)(pageContextInit, pageContextInit_);
     {
-        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit, renderContext);
+        const pageContextInitEnhanced = getPageContextInitEnhanced(pageContextInit);
         (0, utils_js_1.objectAssign)(pageContext, pageContextInitEnhanced);
     }
     (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
     return prerenderPage(pageContext);
 }
-function getPageContextInitEnhanced(pageContextInit, renderContext, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
+function getPageContextInitEnhanced(pageContextInit, { ssr: { urlRewrite, urlHandler, isClientSideNavigation } = {
     urlRewrite: null,
     urlHandler: null,
     isClientSideNavigation: false
@@ -131,12 +128,12 @@ function getPageContextInitEnhanced(pageContextInit, renderContext, { ssr: { url
         _baseAssets: globalContext.baseAssets,
         _includeAssetsImportedByServer: globalContext.includeAssetsImportedByServer,
         // TODO: use GloablContext instead
-        _pageFilesAll: renderContext.pageFilesAll,
-        _pageConfigs: renderContext.pageConfigs,
-        _pageConfigGlobal: renderContext.pageConfigGlobal,
-        _allPageIds: renderContext.allPageIds,
-        _pageRoutes: renderContext.pageRoutes,
-        _onBeforeRouteHook: renderContext.onBeforeRouteHook,
+        _pageFilesAll: globalContext.pageFilesAll,
+        _pageConfigs: globalContext.pageConfigs,
+        _pageConfigGlobal: globalContext.pageConfigGlobal,
+        _allPageIds: globalContext.allPageIds,
+        _pageRoutes: globalContext.pageRoutes,
+        _onBeforeRouteHook: globalContext.onBeforeRouteHook,
         _pageContextInit: pageContextInit,
         _urlRewrite: urlRewrite,
         _urlHandler: urlHandler,
@@ -164,22 +161,3 @@ function getPageContextInitEnhanced(pageContextInit, renderContext, { ssr: { url
     }
     return pageContextInitEnhanced;
 }
-// TODO: remove getRenderContext() in favor of getGlobalObject() + reloadGlobalContext()
-// TODO: impl GlobalNodeContext + GlobalClientContext + GloablContext, and use GlobalContext instead of RenderContext
-async function getRenderContext() {
-    const globalContext = (0, globalContext_js_1.getGlobalContext)();
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal } = await (0, getPageFiles_js_1.getPageFilesAll)(false, globalContext.isProduction);
-    const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
-    (0, assertV1Design_js_1.assertV1Design)(
-    // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
-    pageConfigs.length > 0, pageFilesAll);
-    const renderContext = {
-        pageFilesAll,
-        pageConfigs,
-        pageConfigGlobal,
-        allPageIds,
-        pageRoutes,
-        onBeforeRouteHook
-    };
-    return renderContext;
-}

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

@@ -13,7 +13,8 @@ const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 (0, assertIsNotBrowser_js_1.assertIsNotBrowser)(); // Don't bloat the client
 // TODO/next-major-release: update
 const configSrc = '[vite.config.js > vike({ redirects })]';
-function resolveRedirects(redirects, urlPathname) {
+function resolveRedirects(redirectsAll, urlPathname) {
+    const redirects = merge(redirectsAll);
     for (const [urlSource, urlTarget] of Object.entries(redirects)) {
         const urlResolved = resolveRouteStringRedirect(urlSource, urlTarget, urlPathname);
         if (urlResolved)
@@ -44,3 +45,10 @@ function assertParams(urlSource, urlTarget) {
         }
     });
 }
+function merge(objs) {
+    const obj = {};
+    objs.forEach((e) => {
+        Object.assign(obj, e);
+    });
+    return obj;
+}

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

@@ -66,10 +66,8 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         }
     }
     // Prepare context
-    let renderContext;
     try {
         await (0, globalContext_js_1.initGlobalContext_renderPage)();
-        renderContext = await (0, renderPageAlreadyRouted_js_1.getRenderContext)();
     }
     catch (err) {
         // Errors are expected since assertUsage() is used in both initGlobalContext_renderPage() and getRenderContext().
@@ -83,7 +81,7 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         return handleInvalidConfig(isConfigInvalid_js_1.isConfigInvalid.err);
     }
     else {
-        // From now on, renderContext.pageConfigs contains all the configuration data; getVikeConfig() isn't called anymore for this request
+        // From now on, gloablContext contains all the configuration data; getVikeConfig() isn't called anymore for this request
     }
     // Check Base URL
     assertBaseUrl(pageContextInit);
@@ -99,9 +97,9 @@ async function renderPageAndPrepare(pageContextInit, httpRequestId) {
         if (pageContextHttpResponse)
             return pageContextHttpResponse;
     }
-    return await renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderContext, []);
+    return await renderPageAlreadyPrepared(pageContextInit, httpRequestId, []);
 }
-async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderContext, pageContextsFromRewrite) {
+async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, pageContextsFromRewrite) {
     (0, abort_js_1.assertNoInfiniteAbortLoop)(pageContextsFromRewrite.length, 
     // There doesn't seem to be a way to count the number of HTTP redirects (vike don't have access to the HTTP request headers/cookies)
     // https://stackoverflow.com/questions/9683007/detect-infinite-http-redirect-loop-on-server-side
@@ -113,7 +111,7 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
         (0, utils_js_1.objectAssign)(pageContextNominalPageInit, pageContextFromAllRewrites);
     }
     {
-        const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, renderContext, pageContextNominalPageInit._urlRewrite, httpRequestId);
+        const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, pageContextNominalPageInit._urlRewrite, httpRequestId);
         (0, utils_js_1.objectAssign)(pageContextNominalPageInit, pageContextInitEnhanced);
     }
     let errNominalPage;
@@ -145,10 +143,10 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
         (0, utils_js_1.assert)(pageContextNominalPageSuccess === undefined);
         (0, utils_js_1.assert)(pageContextNominalPageInit);
         (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextNominalPageInit, 'urlOriginal', 'string'));
-        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPageInit, renderContext, httpRequestId);
+        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPageInit, httpRequestId);
         // Handle `throw redirect()` and `throw render()` while rendering nominal page
         if ((0, abort_js_1.isAbortError)(errNominalPage)) {
-            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageInit);
+            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit);
             if (handled.pageContextReturn) {
                 // - throw redirect()
                 // - throw render(url)
@@ -161,7 +159,8 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
             Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
         }
         {
-            const errorPageId = (0, error_page_js_1.getErrorPageId)(renderContext.pageFilesAll, renderContext.pageConfigs);
+            const globalContext = (0, globalContext_js_1.getGlobalContext)();
+            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext.pageFilesAll, globalContext.pageConfigs);
             if (!errorPageId) {
                 (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: null });
                 return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContextErrorPageInit);
@@ -177,7 +176,7 @@ async function renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderC
         catch (errErrorPage) {
             // Handle `throw redirect()` and `throw render()` while rendering error page
             if ((0, abort_js_1.isAbortError)(errErrorPage)) {
-                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageInit);
+                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextInit, pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit);
                 // throw render(abortStatusCode)
                 if (!handled.pageContextReturn) {
                     const pageContextAbort = errErrorPage._pageContextAbort;
@@ -293,8 +292,8 @@ async function renderPageNominal(pageContext) {
     (0, utils_js_1.assert)(pageContext === pageContextAfterRender);
     return pageContextAfterRender;
 }
-async function getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPagePartial, renderContext, httpRequestId) {
-    const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, renderContext, null, httpRequestId);
+async function getPageContextErrorPageInit(pageContextInit, errNominalPage, pageContextNominalPagePartial, httpRequestId) {
+    const pageContextInitEnhanced = getPageContextInitEnhancedSSR(pageContextInit, null, httpRequestId);
     (0, utils_js_1.assert)(errNominalPage);
     const pageContext = {};
     (0, utils_js_1.objectAssign)(pageContext, pageContextInitEnhanced);
@@ -309,9 +308,9 @@ async function getPageContextErrorPageInit(pageContextInit, errNominalPage, page
     (0, utils_js_1.assert)(pageContext.errorWhileRendering);
     return pageContext;
 }
-function getPageContextInitEnhancedSSR(pageContextInit, renderContext, urlRewrite, httpRequestId) {
+function getPageContextInitEnhancedSSR(pageContextInit, urlRewrite, httpRequestId) {
     const { isClientSideNavigation, _urlHandler } = handlePageContextUrl(pageContextInit.urlOriginal);
-    const pageContextInitEnhanced = (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, renderContext, {
+    const pageContextInitEnhanced = (0, renderPageAlreadyRouted_js_1.getPageContextInitEnhanced)(pageContextInit, {
         ssr: {
             urlRewrite,
             urlHandler: _urlHandler,
@@ -360,12 +359,12 @@ function normalizeUrl(pageContextInit, httpRequestId) {
     return pageContextHttpResponse;
 }
 function getPermanentRedirect(pageContextInit, httpRequestId) {
-    const { redirects, baseServer } = (0, globalContext_js_1.getGlobalContext)();
-    const urlWithoutBase = (0, utils_js_1.removeBaseServer)(pageContextInit.urlOriginal, baseServer);
+    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+    const urlWithoutBase = (0, utils_js_1.removeBaseServer)(pageContextInit.urlOriginal, globalContext.baseServer);
     let origin = null;
     let urlTargetExternal = null;
     let urlTarget = (0, utils_js_1.modifyUrlPathname)(urlWithoutBase, (urlPathname) => {
-        const urlTarget = (0, resolveRedirects_js_1.resolveRedirects)(redirects, urlPathname);
+        const urlTarget = (0, resolveRedirects_js_1.resolveRedirects)(globalContext.vikeConfig.global.config.redirects ?? [], urlPathname);
         if (urlTarget === null)
             return null;
         if (!(0, utils_js_1.isUrl)(urlTarget)) {
@@ -393,7 +392,7 @@ function getPermanentRedirect(pageContextInit, httpRequestId) {
         if (normalize(urlTarget) === normalize(urlWithoutBase))
             return null;
         if (!originChanged)
-            urlTarget = (0, utils_js_1.prependBase)(urlTarget, baseServer);
+            urlTarget = (0, utils_js_1.prependBase)(urlTarget, globalContext.baseServer);
         (0, utils_js_1.assert)(urlTarget !== pageContextInit.urlOriginal);
     }
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(`Permanent redirection defined by config.redirects (https://vike.dev/redirects)`, httpRequestId, 'info');
@@ -407,13 +406,14 @@ function normalize(url) {
 }
 async function handleAbortError(errAbort, pageContextsFromRewrite, pageContextInit, 
 // handleAbortError() creates a new pageContext object and we don't merge pageContextNominalPageInit to it: we only use some pageContextNominalPageInit information.
-pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageInit) {
+pageContextNominalPageInit, httpRequestId, pageContextErrorPageInit) {
     (0, abort_js_1.logAbortErrorHandled)(errAbort, (0, globalContext_js_1.getGlobalContext)().isProduction, pageContextNominalPageInit);
     const pageContextAbort = errAbort._pageContextAbort;
     let pageContextSerialized;
     if (pageContextNominalPageInit.isClientSideNavigation) {
         if (pageContextAbort.abortStatusCode) {
-            const errorPageId = (0, error_page_js_1.getErrorPageId)(renderContext.pageFilesAll, renderContext.pageConfigs);
+            const globalContext = (0, globalContext_js_1.getGlobalContext)();
+            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext.pageFilesAll, globalContext.pageConfigs);
             const abortCall = pageContextAbort._abortCall;
             (0, utils_js_1.assert)(abortCall);
             (0, utils_js_1.assertUsage)(errorPageId, `You called ${picocolors_1.default.cyan(abortCall)} but you didn't define an error page, make sure to define one https://vike.dev/error-page`);
@@ -421,7 +421,6 @@ pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageIn
             (0, utils_js_1.objectAssign)(pageContext, { pageId: errorPageId });
             (0, utils_js_1.objectAssign)(pageContext, pageContextAbort);
             (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit);
-            (0, utils_js_1.objectAssign)(pageContext, renderContext);
             (0, utils_js_1.objectAssign)(pageContext, await (0, loadUserFilesServerSide_js_1.loadUserFilesServerSide)(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = (0, serializePageContextClientSide_js_1.serializePageContextClientSide)(pageContext);
@@ -434,7 +433,7 @@ pageContextNominalPageInit, httpRequestId, renderContext, pageContextErrorPageIn
         return { pageContextReturn };
     }
     if (pageContextAbort._urlRewrite) {
-        const pageContextReturn = await renderPageAlreadyPrepared(pageContextInit, httpRequestId, renderContext, [
+        const pageContextReturn = await renderPageAlreadyPrepared(pageContextInit, httpRequestId, [
             ...pageContextsFromRewrite,
             pageContextAbort
         ]);

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

@@ -10,8 +10,6 @@ function assertRuntimeManifest(obj) {
     (0, utils_js_1.assert)((0, utils_js_1.isBaseServer)(obj.baseServer));
     (0, utils_js_1.assert)((0, utils_js_1.isBaseAssets)(obj.baseAssets));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(obj, 'includeAssetsImportedByServer', 'boolean'));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(obj, 'redirects', 'object'));
-    (0, utils_js_1.castType)(obj);
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(obj, 'trailingSlash', 'boolean'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(obj, 'disableUrlNormalization', 'boolean'));
     (0, utils_js_1.checkType)(obj);