vike 0.4.220-commit-af5c91f → 0.4.221-commit-8577456

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

@@ -5,64 +5,94 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobalContextSync = getGlobalContextSync;
 exports.getGlobalContextAsync = getGlobalContextAsync;
-exports.getGlobalContext = getGlobalContext;
+exports.getGlobalContextInternal = getGlobalContextInternal;
 exports.getViteDevServer = getViteDevServer;
 exports.getViteConfig = getViteConfig;
 exports.initGlobalContext_renderPage = initGlobalContext_renderPage;
 exports.initGlobalContext_runPrerender = initGlobalContext_runPrerender;
-exports.initGlobalContext_getGlobalContextAsync = initGlobalContext_getGlobalContextAsync;
+exports.initGlobalContext_getPagesAndRoutes = initGlobalContext_getPagesAndRoutes;
 exports.setGlobalContext_viteDevServer = setGlobalContext_viteDevServer;
 exports.setGlobalContext_viteConfig = setGlobalContext_viteConfig;
-exports.setGlobalContext_vikeConfig = setGlobalContext_vikeConfig;
-exports.setGlobalContext_isViteDev = setGlobalContext_isViteDev;
 exports.setGlobalContext_isPrerendering = setGlobalContext_isPrerendering;
+exports.setGlobalContext_isProduction = setGlobalContext_isProduction;
 exports.setGlobalContext_buildEntry = setGlobalContext_buildEntry;
 exports.clearGlobalContext = clearGlobalContext;
 exports.assertBuildInfo = assertBuildInfo;
 exports.getViteConfigRuntime = getViteConfigRuntime;
+exports.updateUserFiles = updateUserFiles;
+// The core logic revolves around:
+// - globalObject.userFiles which is the main requirement for assembleGlobalContext()
+// - In production: globalObject.buildEntry which is the production entry set by @brillout/vite-plugin-server-entry
+//   - loadBuildEntry() sets globalObject.buildEntry and then sets globalObject.userFiles
+//   - With vike-server it's set at server start: @brillout/vite-plugin-server-entry injects `import './entry.mjs'` (the production entry generated by @brillout/vite-plugin-server-entry) as first line of code of dist/server/index.mjs while dist/server/entry.mjs calls setGlobalContext_buildEntry()
+//   - Without vike-server it's manually loaded here using importServerProductionEntry() which uses @brillout/vite-plugin-server-entry's autoImporter or crawler
+// - In development: globalObject.viteDevServer which is Vite's development server
+//   - globalObject.viteDevServer is used by updateUserFiles() which then sets globalConfig.userFiles
 const utils_js_1 = require("./utils.js");
 const runtime_1 = require("@brillout/vite-plugin-server-entry/runtime");
 const virtualFileImportUserCode_js_1 = require("../shared/virtual-files/virtualFileImportUserCode.js");
-const getPageFiles_js_1 = require("../../shared/getPageFiles/getPageFiles.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const loadPageRoutes_js_1 = require("../../shared/route/loadPageRoutes.js");
 const assertV1Design_js_1 = require("../shared/assertV1Design.js");
+const getPageConfigsRuntime_js_1 = require("../../shared/getPageConfigsRuntime.js");
 const debug = (0, utils_js_1.createDebugger)('vike:globalContext');
 const globalObject = (0, utils_js_1.getGlobalObject)('globalContext.ts', getInitialGlobalContext());
-initDevEntry();
-function getGlobalContext() {
-    if (!globalObject.globalContext) {
-        debug('getGlobalContext()', new Error().stack);
+async function getGlobalContextInternal() {
+    // getGlobalContextInternal() should always be called after initGlobalContext()
+    (0, utils_js_1.assert)(globalObject.isInitialized);
+    assertGlobalContextIsDefined();
+    if (globalObject.isProduction !== true)
+        await globalObject.waitForUserFilesUpdate;
+    const { globalContext } = globalObject;
+    assertIsDefined(globalContext);
+    return globalContext;
+}
+function assertIsDefined(globalContext) {
+    if (!globalContext) {
+        debug('globalContext', globalContext);
+        debug('assertIsDefined()', new Error().stack);
         (0, utils_js_1.assert)(false);
     }
-    return globalObject.globalContext;
+}
+function assertGlobalContextIsDefined() {
+    assertIsDefined(globalObject.globalContext);
+    (0, utils_js_1.assert)(globalObject.globalContext_public);
 }
 /** @experimental https://vike.dev/getGlobalContext */
 function getGlobalContextSync() {
-    (0, utils_js_1.assertUsage)(globalObject.globalContext, "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContextAsync() instead.");
-    return makePublic(globalObject.globalContext);
+    const { globalContext_public } = globalObject;
+    (0, utils_js_1.assertUsage)(globalContext_public, "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContextAsync() instead.");
+    return globalContext_public;
 }
 /** @experimental https://vike.dev/getGlobalContext */
 async function getGlobalContextAsync(isProduction) {
     (0, utils_js_1.assertUsage)(typeof isProduction === 'boolean', `[getGlobalContextAsync(isProduction)] Argument ${picocolors_1.default.cyan('isProduction')} ${isProduction === undefined ? 'is missing' : `should be ${picocolors_1.default.cyan('true')} or ${picocolors_1.default.cyan('false')}`}`);
-    await initGlobalContext_getGlobalContextAsync(isProduction);
-    const { globalContext } = globalObject;
-    (0, utils_js_1.assert)(globalContext);
-    return makePublic(globalContext);
+    setIsProduction(isProduction);
+    if (!globalObject.globalContext)
+        await initGlobalContext_getGlobalContextAsync();
+    if (!isProduction)
+        await globalObject.waitForUserFilesUpdate;
+    assertGlobalContextIsDefined();
+    const { globalContext_public } = globalObject;
+    (0, utils_js_1.assert)(globalContext_public);
+    return globalContext_public;
 }
 function makePublic(globalContext) {
-    // TODO/now: add viteConfig and vikeConfig
-    const globalContextPublic = (0, utils_js_1.makePublicCopy)(globalContext, 'globalContext', ['assetsManifest']);
+    // TODO/soon: add `pages`
+    const globalContextPublic = (0, utils_js_1.makePublicCopy)(globalContext, 'globalContext', ['assetsManifest', 'config', 'viteConfig']);
     return globalContextPublic;
 }
-function setGlobalContext_viteDevServer(viteDevServer) {
+async function setGlobalContext_viteDevServer(viteDevServer) {
+    debug('setGlobalContext_viteDevServer()');
+    setIsProduction(false);
     if (globalObject.viteDevServer)
         return;
     assertIsNotInitilizedYet();
     (0, utils_js_1.assert)(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
+    await updateUserFiles();
+    assertGlobalContextIsDefined();
     globalObject.viteDevServerPromiseResolve(viteDevServer);
-    eagerlyLoadUserFiles();
 }
 function setGlobalContext_viteConfig(viteConfig, outDirRoot) {
     if (globalObject.viteConfig)
@@ -71,21 +101,16 @@ function setGlobalContext_viteConfig(viteConfig, outDirRoot) {
     globalObject.viteConfig = viteConfig;
     globalObject.outDirRoot = outDirRoot;
 }
-function setGlobalContext_vikeConfig(vikeConfig) {
-    if (globalObject.vikeConfig)
-        return;
-    assertIsNotInitilizedYet();
-    globalObject.vikeConfig = vikeConfig;
-}
 function assertIsNotInitilizedYet() {
-    // In develpoment, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
+    // In development, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
     (0, utils_js_1.assert)(!globalObject.globalContext);
 }
-function setGlobalContext_isViteDev(isViteDev) {
-    globalObject.isViteDev = isViteDev;
-}
 function setGlobalContext_isPrerendering() {
     globalObject.isPrerendering = true;
+    setIsProduction(true);
+}
+function setGlobalContext_isProduction(isProduction) {
+    setIsProduction(isProduction);
 }
 function getViteDevServer() {
     return globalObject.viteDevServer ?? null;
@@ -95,10 +120,15 @@ function getViteConfig() {
 }
 async function initGlobalContext_renderPage() {
     debug('initGlobalContext_renderPage()');
-    await initGlobalContext(!globalObject.isViteDev);
+    // globalObject.isProduction isn't set upon production server without vike-server (there isn't any signal we can use)
+    if (globalObject.isProduction === undefined)
+        setIsProduction(true);
+    await initGlobalContext();
 }
 async function initGlobalContext_runPrerender() {
     debug('initGlobalContext_runPrerender()');
+    (0, utils_js_1.assert)(globalObject.isPrerendering === true);
+    (0, utils_js_1.assert)(globalObject.isProduction === true);
     if (globalObject.initGlobalContext_runPrerender_alreadyCalled)
         return;
     globalObject.initGlobalContext_runPrerender_alreadyCalled = true;
@@ -108,65 +138,93 @@ async function initGlobalContext_runPrerender() {
     // We assume initGlobalContext_runPrerender() to be called before:
     // - initGlobalContext_renderPage()
     // - initGlobalContext_getGlobalContextAsync()
-    (0, utils_js_1.assert)(!globalObject.globalContext);
-    await initGlobalContext(true);
+    assertIsNotInitilizedYet();
+    await initGlobalContext();
 }
-async function initGlobalContext_getGlobalContextAsync(isProduction) {
+async function initGlobalContext_getGlobalContextAsync() {
     debug('initGlobalContext_getGlobalContextAsync()');
+    await initGlobalContext();
+}
+async function initGlobalContext_getPagesAndRoutes() {
+    debug('initGlobalContext_getPagesAndRoutes()');
+    setIsProduction(true);
+    await initGlobalContext();
+}
+async function waitForViteDevServer() {
+    debug('waitForViteDevServer()');
+    const waitFor = 20;
+    const timeout = setTimeout(() => {
+        (0, utils_js_1.assertWarning)(false, `Vite's development server still not created after ${waitFor} seconds.`, {
+            onlyOnce: false,
+            showStackTrace: true
+        });
+    }, waitFor * 1000);
+    await globalObject.viteDevServerPromise;
+    clearTimeout(timeout);
+    assertGlobalContextIsDefined();
+}
+async function initGlobalContext() {
+    const { isProduction } = globalObject;
+    (0, utils_js_1.assert)(typeof isProduction === 'boolean');
     if (!isProduction) {
-        const waitFor = 20;
-        const timeout = setTimeout(() => {
-            (0, utils_js_1.assertWarning)(false, `Vite's development server still not created after ${waitFor} seconds.`, {
-                onlyOnce: false,
-                showStackTrace: true
-            });
-        }, waitFor * 1000);
-        await globalObject.viteDevServerPromise;
-        clearTimeout(timeout);
+        await waitForViteDevServer();
     }
-    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);
-        // We assume setGlobalContext_isPrerendering() is called before initGlobalContext()
-        (0, utils_js_1.assert)(globalObject.globalContext.isPrerendering === (globalObject.isPrerendering ?? false));
-        return;
+    else {
+        await loadBuildEntry(globalObject.outDirRoot);
     }
-    const { viteDevServer, viteConfig, vikeConfig, isPrerendering } = globalObject;
+    assertGlobalContextIsDefined();
+    globalObject.isInitialized = true;
+}
+function setIsProduction(isProduction) {
+    debug('setIsProduction', isProduction);
+    (0, utils_js_1.assert)(typeof isProduction === 'boolean');
+    if (globalObject.isProduction !== undefined)
+        (0, utils_js_1.assert)(globalObject.isProduction === isProduction);
+    globalObject.isProduction = isProduction;
+}
+function defineGlobalContext() {
+    const globalContext = assembleGlobalContext();
+    assertIsDefined(globalContext);
+    const globalContext_public = makePublic(globalContext);
+    (0, utils_js_1.objectAssign)(globalContext, { globalContext_public });
+    globalObject.globalContext = globalContext;
+    globalObject.globalContext_public = globalContext_public;
+    assertGlobalContextIsDefined();
     (0, utils_js_1.onSetupRuntime)();
+}
+function assembleGlobalContext() {
+    const { viteDevServer, viteConfig, isPrerendering, isProduction, userFiles } = globalObject;
+    (0, utils_js_1.assert)(typeof isProduction === 'boolean');
+    let globalContext;
     if (!isProduction) {
+        // Requires globalObject.viteDevServer
+        if (!viteDevServer)
+            return null;
+        (0, utils_js_1.assert)(userFiles); // main common requiement
         (0, utils_js_1.assert)(viteConfig);
-        (0, utils_js_1.assert)(vikeConfig);
-        (0, utils_js_1.assert)(viteDevServer);
         (0, utils_js_1.assert)(!isPrerendering);
-        const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
         const viteConfigRuntime = getViteConfigRuntime(viteConfig);
-        globalObject.globalContext = {
+        globalContext = {
             isProduction: false,
             isPrerendering: false,
             assetsManifest: null,
             viteDevServer,
             viteConfig,
-            vikeConfig: {
-                global: globalConfig
-            },
             ...userFiles,
             viteConfigRuntime
         };
     }
     else {
-        const buildEntry = await getBuildEntry(globalObject.outDirRoot, isPrerendering);
-        const { assetsManifest, buildInfo } = buildEntry;
-        (0, getPageFiles_js_1.setPageFiles)(buildEntry.pageFiles);
-        const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
-        const globalContext = {
+        // Requires globalObject.buildEntry
+        if (!globalObject.buildEntry)
+            return null;
+        (0, utils_js_1.assert)(userFiles); // main common requiement
+        const { buildInfo, assetsManifest } = globalObject;
+        (0, utils_js_1.assert)(buildInfo);
+        (0, utils_js_1.assert)(assetsManifest);
+        const globalContext_ = {
             isProduction: true,
             assetsManifest,
-            vikeConfig: {
-                global: globalConfig
-            },
             ...userFiles,
             viteDevServer: null,
             viteConfigRuntime: buildInfo.viteConfigRuntime,
@@ -174,23 +232,28 @@ async function initGlobalContext(isProduction) {
         };
         if (isPrerendering) {
             (0, utils_js_1.assert)(viteConfig);
-            (0, utils_js_1.objectAssign)(globalContext, {
+            (0, utils_js_1.objectAssign)(globalContext_, {
                 isPrerendering: true,
                 viteConfig
             });
-            globalObject.globalContext = globalContext;
+            globalContext = globalContext_;
         }
         else {
-            (0, utils_js_1.objectAssign)(globalContext, {
+            (0, utils_js_1.objectAssign)(globalContext_, {
                 isPrerendering: false,
                 viteConfig: null
             });
-            globalObject.globalContext = globalContext;
+            globalContext = globalContext_;
         }
     }
+    return globalContext;
 }
-async function getPageRuntimeInfo(isProduction) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig } = await (0, getPageFiles_js_1.getPageFilesAll)(false, isProduction);
+async function getUserFiles() {
+    // Help TypeScript resolve what TypeScript (wrongfully) believes to be cyclic dependency
+    const globalObject_ = globalObject;
+    const { pageConfigsRuntime } = globalObject_;
+    (0, utils_js_1.assert)(pageConfigsRuntime);
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig } = pageConfigsRuntime;
     const { pageRoutes, onBeforeRouteHook } = await (0, loadPageRoutes_js_1.loadPageRoutes)(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
     const userFiles = {
         pageFilesAll,
@@ -198,12 +261,13 @@ async function getPageRuntimeInfo(isProduction) {
         pageConfigGlobal,
         allPageIds,
         pageRoutes,
-        onBeforeRouteHook
+        onBeforeRouteHook,
+        config: globalConfig.config
     };
     (0, assertV1Design_js_1.assertV1Design)(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
     pageConfigs.length > 0, pageFilesAll);
-    return { userFiles, globalConfig };
+    return userFiles;
 }
 function assertViteManifest(manifest) {
     (0, utils_js_1.assert)((0, utils_js_1.isPlainObject)(manifest));
@@ -218,45 +282,56 @@ function assertViteManifest(manifest) {
       })
     */
 }
-function eagerlyLoadUserFiles() {
-    // Other than here, the getPageFilesExports() function is only called only upon calling the renderPage() function.
-    // We call it as early as possible here for better performance.
-    getPageFilesExports();
-}
-async function getBuildEntry(outDir, isPrerendering) {
-    debug('getBuildEntry()');
+async function loadBuildEntry(outDir) {
+    debug('loadBuildEntry()');
+    if (globalObject.userFiles) {
+        (0, utils_js_1.assert)(globalObject.buildInfo);
+        (0, utils_js_1.assert)(globalObject.assetsManifest);
+        (0, utils_js_1.assert)(globalObject.buildEntry);
+        return;
+    }
     if (!globalObject.buildEntry) {
         debug('importServerProductionEntry()');
         // importServerProductionEntry() loads dist/server/entry.mjs which calls setGlobalContext_buildEntry()
-        await (0, runtime_1.importServerProductionEntry)({ outDir, doNotLoadServer: isPrerendering });
+        await (0, runtime_1.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;
         }
         (0, utils_js_1.assert)(globalObject.buildEntry);
+        (0, utils_js_1.assertWarning)(!globalObject.buildInfo?.viteConfigRuntime.vitePluginServerEntry.inject, 
+        // TODO/soon: show precise path
+        // TODO/soon: make this warning work on test/vike-node/
+        `Run the server production build (e.g. ${picocolors_1.default.cyan('$ node dist/server/index.mjs')}) instead of running the original server entry (e.g. ${picocolors_1.default.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
     }
     const { buildEntry } = globalObject;
     assertBuildEntry(buildEntry);
-    return buildEntry;
+    globalObject.assetsManifest = buildEntry.assetsManifest;
+    globalObject.buildInfo = buildEntry.buildInfo;
+    await setUserFiles(buildEntry.virtualFileExports);
 }
-function setGlobalContext_buildEntry(buildEntry) {
+async function setGlobalContext_buildEntry(buildEntry) {
     debug('setGlobalContext_buildEntry()');
+    setIsProduction(true);
     assertBuildEntry(buildEntry);
     globalObject.buildEntry = buildEntry;
     globalObject.buildEntryPrevious = buildEntry;
+    (0, utils_js_1.assert)(globalObject.buildEntry); // ensure no infinite loop
+    await loadBuildEntry();
+    assertGlobalContextIsDefined();
 }
 function assertBuildEntry(buildEntry) {
     (0, utils_js_1.assert)((0, utils_js_1.isObject)(buildEntry));
-    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'pageFiles', 'object'));
-    const { pageFiles } = buildEntry;
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'virtualFileExports', 'object'));
+    const { virtualFileExports } = buildEntry;
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'assetsManifest', 'object'));
     const { assetsManifest } = buildEntry;
     assertViteManifest(assetsManifest);
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildEntry, 'buildInfo', 'object'));
     const { buildInfo } = buildEntry;
     assertBuildInfo(buildInfo);
-    (0, utils_js_1.checkType)({ pageFiles, assetsManifest, buildInfo });
+    (0, utils_js_1.checkType)({ virtualFileExports, assetsManifest, buildInfo });
 }
 function assertBuildInfo(buildInfo) {
     (0, utils_js_1.assert)((0, utils_js_1.isObject)(buildInfo));
@@ -264,6 +339,7 @@ function assertBuildInfo(buildInfo) {
     assertVersionAtBuildTime(buildInfo.versionAtBuildTime);
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo, 'viteConfigRuntime', 'object'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo.viteConfigRuntime, '_baseViteOriginal', 'string'));
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo.viteConfigRuntime, 'vitePluginServerEntry', 'object'));
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(buildInfo, 'usesClientRouter', 'boolean'));
     (0, utils_js_1.checkType)({ ...buildInfo, viteConfigRuntime: buildInfo.viteConfigRuntime });
 }
@@ -275,28 +351,38 @@ function assertVersionAtBuildTime(versionAtBuildTime) {
 function getViteConfigRuntime(viteConfig) {
     (0, utils_js_1.assert)((0, utils_js_1.hasProp)(viteConfig, '_baseViteOriginal', 'string'));
     const viteConfigRuntime = {
-        _baseViteOriginal: viteConfig._baseViteOriginal
+        _baseViteOriginal: viteConfig._baseViteOriginal,
+        vitePluginServerEntry: {
+            inject: viteConfig.vitePluginServerEntry?.inject
+        }
     };
     return viteConfigRuntime;
 }
-function initDevEntry() {
-    (0, getPageFiles_js_1.setPageFilesAsync)(getPageFilesExports);
-}
-async function getPageFilesExports() {
+async function updateUserFiles() {
+    const { promise, resolve } = (0, utils_js_1.genPromise)();
+    (0, utils_js_1.assert)(!globalObject.isProduction);
+    globalObject.waitForUserFilesUpdate = promise;
     const viteDevServer = getViteDevServer();
     (0, utils_js_1.assert)(viteDevServer);
-    let moduleExports;
+    let virtualFileExports;
     try {
-        moduleExports = await viteDevServer.ssrLoadModule(virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer);
+        virtualFileExports = await viteDevServer.ssrLoadModule(virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer);
     }
     catch (err) {
         (0, utils_js_1.debugGlob)(`Glob error: ${virtualFileImportUserCode_js_1.virtualFileIdImportUserCodeServer} transpile error: `, err);
         throw err;
     }
-    moduleExports = moduleExports.default || moduleExports;
-    (0, utils_js_1.debugGlob)('Glob result: ', moduleExports);
-    (0, utils_js_1.assert)((0, utils_js_1.isObject)(moduleExports));
-    return moduleExports;
+    virtualFileExports = virtualFileExports.default || virtualFileExports;
+    (0, utils_js_1.debugGlob)('Glob result: ', virtualFileExports);
+    await setUserFiles(virtualFileExports);
+    resolve();
+}
+async function setUserFiles(virtualFileExports) {
+    globalObject.pageConfigsRuntime = (0, getPageConfigsRuntime_js_1.getPageConfigsRuntime)(virtualFileExports);
+    const userFiles = await getUserFiles();
+    globalObject.userFiles = userFiles;
+    defineGlobalContext();
+    assertGlobalContextIsDefined();
 }
 function clearGlobalContext() {
     debug('clearGlobalContext()');

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

@@ -12,14 +12,13 @@ const inferHtmlTags_js_1 = require("./inferHtmlTags.js");
 const mergeScriptTags_js_1 = require("./mergeScriptTags.js");
 const helpers_js_1 = require("../../../../shared/page-configs/helpers.js");
 const getConfigValueRuntime_js_1 = require("../../../../shared/page-configs/getConfigValueRuntime.js");
-const globalContext_js_1 = require("../../globalContext.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const getConfigDefinedAt_js_1 = require("../../../../shared/page-configs/getConfigDefinedAt.js");
 const stamp = '__injectFilterEntry';
-function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, isStream) {
+async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, isStream) {
     (0, utils_js_1.assert)([true, false].includes(pageContext._isHtmlOnly));
     const isHtmlOnly = pageContext._isHtmlOnly;
-    const { isProduction } = (0, globalContext_js_1.getGlobalContext)();
+    const { isProduction } = pageContext._globalContext;
     const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._pageConfigs);
     const injectFilterEntries = [];
     pageAssets

package/dist/cjs/node/runtime/html/injectAssets/getViteDevScript.js

@@ -4,11 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getViteDevScript = getViteDevScript;
-const globalContext_js_1 = require("../../globalContext.js");
 const utils_js_1 = require("../../utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
-async function getViteDevScript() {
-    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+async function getViteDevScript(pageContext) {
+    const globalContext = pageContext._globalContext;
     if (globalContext.isProduction) {
         return '';
     }

package/dist/cjs/node/runtime/html/injectAssets.js

@@ -9,8 +9,8 @@ const getHtmlTags_js_1 = require("./injectAssets/getHtmlTags.js");
 const getViteDevScript_js_1 = require("./injectAssets/getViteDevScript.js");
 async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
     const pageAssets = await pageContext.__getPageAssets();
-    const viteDevScript = await (0, getViteDevScript_js_1.getViteDevScript)();
-    const htmlTags = (0, getHtmlTags_js_1.getHtmlTags)(pageContext, null, injectFilter, pageAssets, viteDevScript, false);
+    const viteDevScript = await (0, getViteDevScript_js_1.getViteDevScript)(pageContext);
+    const htmlTags = await (0, getHtmlTags_js_1.getHtmlTags)(pageContext, null, injectFilter, pageAssets, viteDevScript, false);
     let htmlString = htmlPartsToString(htmlParts, pageAssets);
     htmlString = injectToHtmlBegin(htmlString, htmlTags);
     htmlString = injectToHtmlEnd(htmlString, htmlTags);
@@ -26,8 +26,8 @@ function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, in
     };
     async function injectAtStreamBegin(htmlPartsBegin) {
         const pageAssets = await pageContext.__getPageAssets();
-        const viteDevScript = await (0, getViteDevScript_js_1.getViteDevScript)();
-        htmlTags = (0, getHtmlTags_js_1.getHtmlTags)(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, true);
+        const viteDevScript = await (0, getViteDevScript_js_1.getViteDevScript)(pageContext);
+        htmlTags = await (0, getHtmlTags_js_1.getHtmlTags)(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, true);
         let htmlBegin = htmlPartsToString(htmlPartsBegin, pageAssets);
         htmlBegin = injectToHtmlBegin(htmlBegin, htmlTags);
         if (streamFromReactStreamingPackage) {

package/dist/cjs/node/runtime/html/renderHtml.js

@@ -12,7 +12,6 @@ const utils_js_1 = require("../utils.js");
 const injectAssets_js_1 = require("./injectAssets.js");
 const stream_js_1 = require("./stream.js");
 const react_streaming_js_1 = require("./stream/react-streaming.js");
-const globalContext_js_1 = require("../globalContext.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 function isDocumentHtml(something) {
     if (isTemplateWrapped(something) || isEscapedString(something) || (0, stream_js_1.isStream)(something)) {
@@ -36,7 +35,7 @@ async function renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreami
     }
     if (isTemplateWrapped(documentHtml)) {
         const templateContent = documentHtml._template;
-        const render = await renderTemplate(templateContent, pageContext);
+        const render = renderTemplate(templateContent, pageContext);
         if (!('htmlStream' in render)) {
             (0, utils_js_1.objectAssign)(pageContext, { _isStream: false });
             const { htmlPartsAll } = render;
@@ -125,7 +124,7 @@ function _dangerouslySkipEscape(arg) {
     });
     return { _escaped: String(arg) };
 }
-async function renderTemplate(templateContent, pageContext) {
+function renderTemplate(templateContent, pageContext) {
     const htmlPartsBegin = [];
     const htmlPartsEnd = [];
     let htmlStream = null;
@@ -156,7 +155,7 @@ async function renderTemplate(templateContent, pageContext) {
         // Process `escapeInject` fragments
         if (isTemplateWrapped(templateVar)) {
             const templateContentInner = templateVar._template;
-            const result = await renderTemplate(templateContentInner, pageContext);
+            const result = renderTemplate(templateContentInner, pageContext);
             if (!('htmlStream' in result)) {
                 result.htmlPartsAll.forEach(addHtmlPart);
             }
@@ -198,7 +197,7 @@ async function renderTemplate(templateContent, pageContext) {
             }
         }
         {
-            const { isProduction } = (0, globalContext_js_1.getGlobalContext)();
+            const { isProduction } = pageContext._globalContext;
             if ((0, utils_js_1.isHtml)(templateVar) &&
                 // We don't show this warning in production because it's expected that some users may (un)willingly do some XSS injection: we avoid flooding the production logs.
                 !isProduction) {

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

@@ -5,9 +5,8 @@ const determineClientEntry_js_1 = require("../../../shared/getPageFiles/analyzeP
 const analyzePageClientSide_js_1 = require("../../../shared/getPageFiles/analyzePageClientSide.js");
 const virtualFilePageConfigValuesAll_js_1 = require("../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
 const analyzeClientSide_js_1 = require("../../../shared/getPageFiles/analyzeClientSide.js");
-const globalContext_js_1 = require("../globalContext.js");
 const getConfigValueRuntime_js_1 = require("../../../shared/page-configs/getConfigValueRuntime.js");
-function analyzePage(pageFilesAll, pageConfig, pageId) {
+async function analyzePage(pageFilesAll, pageConfig, pageId, globalContext) {
     if (pageConfig) {
         const { isClientRuntimeLoaded, isClientRouting } = (0, analyzeClientSide_js_1.analyzeClientSide)(pageConfig, pageFilesAll, pageId);
         const clientEntries = [];
@@ -23,7 +22,7 @@ function analyzePage(pageFilesAll, pageConfig, pageId) {
             eagerlyImported: false
         });
         // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
-        if (!(0, globalContext_js_1.getGlobalContext)().isProduction) {
+        if (!globalContext.isProduction) {
             clientDependencies.push({
                 id: (0, virtualFilePageConfigValuesAll_js_1.getVirtualFileIdPageConfigValuesAll)(pageConfig.pageId, false),
                 onlyAssets: true,

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

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sortPageAssetsForEarlyHintsHeader = sortPageAssetsForEarlyHintsHeader;
-const globalContext_js_1 = require("../../globalContext.js");
 const utils_js_1 = require("../../utils.js");
-function sortPageAssetsForEarlyHintsHeader(pageAssets) {
-    const globalContext = (0, globalContext_js_1.getGlobalContext)();
+async function sortPageAssetsForEarlyHintsHeader(pageAssets, isProduction) {
     pageAssets.sort((0, utils_js_1.higherFirst)(({ assetType }) => {
         // In dev, we load scripts first in order to parallelize I/O and CPU
-        if (!globalContext.isProduction && assetType === 'script') {
+        if (!isProduction && assetType === 'script') {
             return 1;
         }
         let priority = 0;

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

@@ -8,13 +8,13 @@ const retrieveAssetsProd_js_1 = require("./getPageAssets/retrieveAssetsProd.js")
 const inferMediaType_js_1 = require("./inferMediaType.js");
 const getManifestEntry_js_1 = require("./getPageAssets/getManifestEntry.js");
 const sortPageAssetsForEarlyHintsHeader_js_1 = require("./getPageAssets/sortPageAssetsForEarlyHintsHeader.js");
-const globalContext_js_1 = require("../globalContext.js");
 const globalObject = (0, utils_js_1.getGlobalObject)('getPageAssets.ts', {
     resolveClientEntriesDev: null
 });
 async function getPageAssets(pageContext, clientDependencies, clientEntries) {
-    const globalContext = (0, globalContext_js_1.getGlobalContext)();
-    const isDev = !globalContext.isProduction;
+    const globalContext = pageContext._globalContext;
+    const { isProduction } = globalContext;
+    const isDev = !isProduction;
     let assetUrls;
     let clientEntriesSrc;
     if (isDev) {
@@ -57,7 +57,7 @@ async function getPageAssets(pageContext, clientDependencies, clientEntries) {
         pageAsset.src = (0, utils_js_1.prependBase)((0, utils_js_1.toPosixPath)(pageAsset.src), baseServerAssets);
         return pageAsset;
     });
-    (0, sortPageAssetsForEarlyHintsHeader_js_1.sortPageAssetsForEarlyHintsHeader)(pageAssets);
+    await (0, sortPageAssetsForEarlyHintsHeader_js_1.sortPageAssetsForEarlyHintsHeader)(pageAssets, isProduction);
     return pageAssets;
 }
 function resolveClientEntriesProd(clientEntry, assetsManifest) {