vike 0.4.220 → 0.4.221-commit-8577456

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

@@ -2,86 +2,94 @@
 export { getGlobalContextSync };
 export { getGlobalContextAsync };
 // Internal use
-export { getGlobalContext };
+export { getGlobalContextInternal };
 export { getViteDevServer };
 export { getViteConfig };
-export { getRuntimeManifest };
 export { initGlobalContext_renderPage };
 export { initGlobalContext_runPrerender };
-export { initGlobalContext_getGlobalContextAsync };
+export { initGlobalContext_getPagesAndRoutes };
 export { setGlobalContext_viteDevServer };
 export { setGlobalContext_viteConfig };
-export { setGlobalContext_vikeConfig };
-export { setGlobalContext_isViteDev };
 export { setGlobalContext_isPrerendering };
+export { setGlobalContext_isProduction };
 export { setGlobalContext_buildEntry };
 export { clearGlobalContext };
-import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, objectKeys, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger } from './utils.js';
+export { assertBuildInfo };
+export { getViteConfigRuntime };
+export { 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
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectAssign, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, makePublicCopy, projectInfo, checkType } 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 { resolveBaseFromResolvedConfig } from '../shared/resolveBase.js';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { assertV1Design } from '../shared/assertV1Design.js';
+import { getPageConfigsRuntime } from '../../shared/getPageConfigsRuntime.js';
 const debug = createDebugger('vike:globalContext');
 const globalObject = 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()
+    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);
         assert(false);
     }
-    return globalObject.globalContext;
+}
+function assertGlobalContextIsDefined() {
+    assertIsDefined(globalObject.globalContext);
+    assert(globalObject.globalContext_public);
 }
 /** @experimental https://vike.dev/getGlobalContext */
 function getGlobalContextSync() {
-    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;
+    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) {
     assertUsage(typeof isProduction === 'boolean', `[getGlobalContextAsync(isProduction)] Argument ${pc.cyan('isProduction')} ${isProduction === undefined ? 'is missing' : `should be ${pc.cyan('true')} or ${pc.cyan('false')}`}`);
-    await initGlobalContext_getGlobalContextAsync(isProduction);
-    const { globalContext } = globalObject;
-    assert(globalContext);
-    return makePublic(globalContext);
+    setIsProduction(isProduction);
+    if (!globalObject.globalContext)
+        await initGlobalContext_getGlobalContextAsync();
+    if (!isProduction)
+        await globalObject.waitForUserFilesUpdate;
+    assertGlobalContextIsDefined();
+    const { globalContext_public } = globalObject;
+    assert(globalContext_public);
+    return globalContext_public;
 }
 function makePublic(globalContext) {
-    const globalContextPublic = {
-        // TODO/now: add viteConfig and vikeConfig
-        assetsManifest: globalContext.assetsManifest
-    };
-    // Add internals (and prepended _ prefix to their keys)
-    {
-        const publicKeys = Object.keys(globalContextPublic);
-        objectKeys(globalContext)
-            .filter((key) => !publicKeys.includes(key))
-            .forEach((key) => {
-            const keyPublic = `_${key}`;
-            Object.defineProperty(globalContextPublic, keyPublic, {
-                enumerable: true,
-                get() {
-                    assertWarning(false, `Using internal globalContext.${keyPublic} which is discouraged: it may break in any minor version update. Instead, reach out on GitHub and elaborate your use case.`, {
-                        onlyOnce: true
-                    });
-                    return globalContext[key];
-                }
-            });
-        });
-    }
+    // TODO/soon: add `pages`
+    const globalContextPublic = 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();
     assert(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
+    await updateUserFiles();
+    assertGlobalContextIsDefined();
     globalObject.viteDevServerPromiseResolve(viteDevServer);
-    eagerlyLoadUserFiles();
 }
 function setGlobalContext_viteConfig(viteConfig, outDirRoot) {
     if (globalObject.viteConfig)
@@ -90,21 +98,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
     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;
@@ -114,10 +117,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()');
+    assert(globalObject.isPrerendering === true);
+    assert(globalObject.isProduction === true);
     if (globalObject.initGlobalContext_runPrerender_alreadyCalled)
         return;
     globalObject.initGlobalContext_runPrerender_alreadyCalled = true;
@@ -127,99 +135,122 @@ async function initGlobalContext_runPrerender() {
     // We assume initGlobalContext_runPrerender() to be called before:
     // - initGlobalContext_renderPage()
     // - initGlobalContext_getGlobalContextAsync()
-    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(() => {
+        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;
+    assert(typeof isProduction === 'boolean');
     if (!isProduction) {
-        const waitFor = 20;
-        const timeout = setTimeout(() => {
-            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) {
-        assert(globalObject.globalContext.isProduction === isProduction);
-        // We assume setGlobalContext_isPrerendering() is called before initGlobalContext()
-        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);
+    assert(typeof isProduction === 'boolean');
+    if (globalObject.isProduction !== undefined)
+        assert(globalObject.isProduction === isProduction);
+    globalObject.isProduction = isProduction;
+}
+function defineGlobalContext() {
+    const globalContext = assembleGlobalContext();
+    assertIsDefined(globalContext);
+    const globalContext_public = makePublic(globalContext);
+    objectAssign(globalContext, { globalContext_public });
+    globalObject.globalContext = globalContext;
+    globalObject.globalContext_public = globalContext_public;
+    assertGlobalContextIsDefined();
     onSetupRuntime();
+}
+function assembleGlobalContext() {
+    const { viteDevServer, viteConfig, isPrerendering, isProduction, userFiles } = globalObject;
+    assert(typeof isProduction === 'boolean');
+    let globalContext;
     if (!isProduction) {
+        // Requires globalObject.viteDevServer
+        if (!viteDevServer)
+            return null;
+        assert(userFiles); // main common requiement
         assert(viteConfig);
-        assert(vikeConfig);
-        assert(viteDevServer);
         assert(!isPrerendering);
-        const { globalConfig, userFiles } = await getPageRuntimeInfo(isProduction);
-        const pluginManifest = getRuntimeManifest(vikeConfig.vikeConfigGlobal, viteConfig);
-        globalObject.globalContext = {
+        const viteConfigRuntime = getViteConfigRuntime(viteConfig);
+        globalContext = {
             isProduction: false,
             isPrerendering: false,
             assetsManifest: null,
             viteDevServer,
             viteConfig,
-            vikeConfig: {
-                global: globalConfig
-            },
             ...userFiles,
-            baseServer: pluginManifest.baseServer,
-            baseAssets: pluginManifest.baseAssets,
-            includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
-            trailingSlash: pluginManifest.trailingSlash,
-            disableUrlNormalization: pluginManifest.disableUrlNormalization
+            viteConfigRuntime
         };
     }
     else {
-        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 = {
+        // Requires globalObject.buildEntry
+        if (!globalObject.buildEntry)
+            return null;
+        assert(userFiles); // main common requiement
+        const { buildInfo, assetsManifest } = globalObject;
+        assert(buildInfo);
+        assert(assetsManifest);
+        const globalContext_ = {
             isProduction: true,
             assetsManifest,
-            vikeConfig: {
-                global: globalConfig
-            },
             ...userFiles,
             viteDevServer: null,
-            baseServer: pluginManifest.baseServer,
-            baseAssets: pluginManifest.baseAssets,
-            includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
-            trailingSlash: pluginManifest.trailingSlash,
-            usesClientRouter: pluginManifest.usesClientRouter,
-            disableUrlNormalization: pluginManifest.disableUrlNormalization
+            viteConfigRuntime: buildInfo.viteConfigRuntime,
+            usesClientRouter: buildInfo.usesClientRouter
         };
         if (isPrerendering) {
             assert(viteConfig);
-            objectAssign(globalContext, {
+            objectAssign(globalContext_, {
                 isPrerendering: true,
                 viteConfig
             });
-            globalObject.globalContext = globalContext;
+            globalContext = globalContext_;
         }
         else {
-            objectAssign(globalContext, {
+            objectAssign(globalContext_, {
                 isPrerendering: false,
                 viteConfig: null
             });
-            globalObject.globalContext = globalContext;
+            globalContext = globalContext_;
         }
     }
+    return globalContext;
 }
-async function getPageRuntimeInfo(isProduction) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig } = await getPageFilesAll(false, isProduction);
+async function getUserFiles() {
+    // Help TypeScript resolve what TypeScript (wrongfully) believes to be cyclic dependency
+    const globalObject_ = globalObject;
+    const { pageConfigsRuntime } = globalObject_;
+    assert(pageConfigsRuntime);
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig } = pageConfigsRuntime;
     const { pageRoutes, onBeforeRouteHook } = await loadPageRoutes(pageFilesAll, pageConfigs, pageConfigGlobal, allPageIds);
     const userFiles = {
         pageFilesAll,
@@ -227,25 +258,13 @@ async function getPageRuntimeInfo(isProduction) {
         pageConfigGlobal,
         allPageIds,
         pageRoutes,
-        onBeforeRouteHook
+        onBeforeRouteHook,
+        config: globalConfig.config
     };
     assertV1Design(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
     pageConfigs.length > 0, pageFilesAll);
-    return { userFiles, globalConfig };
-}
-function getRuntimeManifest(vikeConfigGlobal, viteConfig) {
-    const { includeAssetsImportedByServer, trailingSlash, disableUrlNormalization } = vikeConfigGlobal;
-    const { baseServer, baseAssets } = resolveBaseFromResolvedConfig(vikeConfigGlobal.baseServer, vikeConfigGlobal.baseAssets, viteConfig);
-    const manifest = {
-        baseServer,
-        baseAssets,
-        includeAssetsImportedByServer,
-        trailingSlash,
-        disableUrlNormalization
-    };
-    assertRuntimeManifest(manifest);
-    return manifest;
+    return userFiles;
 }
 function assertViteManifest(manifest) {
     assert(isPlainObject(manifest));
@@ -260,54 +279,107 @@ 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) {
+        assert(globalObject.buildInfo);
+        assert(globalObject.assetsManifest);
+        assert(globalObject.buildEntry);
+        return;
+    }
     if (!globalObject.buildEntry) {
         debug('importServerProductionEntry()');
         // importServerProductionEntry() loads dist/server/entry.mjs which calls setGlobalContext_buildEntry()
-        await importServerProductionEntry({ outDir, doNotLoadServer: isPrerendering });
+        await importServerProductionEntry({ outDir });
         if (!globalObject.buildEntry) {
             debug('globalObject.buildEntryPrevious');
             // Needed, for example, when calling the API prerender() then preview() because both trigger a importServerProductionEntry() call but only the first only is applied because of the import() cache. (A proper implementation would be to clear the import() cache, but it probably isn't possible on platforms such as Cloudflare Workers.)
             globalObject.buildEntry = globalObject.buildEntryPrevious;
         }
         assert(globalObject.buildEntry);
+        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. ${pc.cyan('$ node dist/server/index.mjs')}) instead of running the original server entry (e.g. ${pc.cyan('$ ts-node server/index.ts')})`, { onlyOnce: true });
     }
     const { buildEntry } = globalObject;
-    assert(isObject(buildEntry));
-    assert(hasProp(buildEntry, 'pageFiles', 'object'));
-    assert(hasProp(buildEntry, 'assetsManifest', 'object'));
-    assert(hasProp(buildEntry, 'pluginManifest', 'object'));
-    return buildEntry;
+    assertBuildEntry(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;
+    assert(globalObject.buildEntry); // ensure no infinite loop
+    await loadBuildEntry();
+    assertGlobalContextIsDefined();
+}
+function assertBuildEntry(buildEntry) {
+    assert(isObject(buildEntry));
+    assert(hasProp(buildEntry, 'virtualFileExports', 'object'));
+    const { virtualFileExports } = buildEntry;
+    assert(hasProp(buildEntry, 'assetsManifest', 'object'));
+    const { assetsManifest } = buildEntry;
+    assertViteManifest(assetsManifest);
+    assert(hasProp(buildEntry, 'buildInfo', 'object'));
+    const { buildInfo } = buildEntry;
+    assertBuildInfo(buildInfo);
+    checkType({ virtualFileExports, assetsManifest, buildInfo });
 }
-function initDevEntry() {
-    setPageFilesAsync(getPageFilesExports);
+function assertBuildInfo(buildInfo) {
+    assert(isObject(buildInfo));
+    assert(hasProp(buildInfo, 'versionAtBuildTime', 'string'));
+    assertVersionAtBuildTime(buildInfo.versionAtBuildTime);
+    assert(hasProp(buildInfo, 'viteConfigRuntime', 'object'));
+    assert(hasProp(buildInfo.viteConfigRuntime, '_baseViteOriginal', 'string'));
+    assert(hasProp(buildInfo.viteConfigRuntime, 'vitePluginServerEntry', 'object'));
+    assert(hasProp(buildInfo, 'usesClientRouter', 'boolean'));
+    checkType({ ...buildInfo, viteConfigRuntime: buildInfo.viteConfigRuntime });
 }
-async function getPageFilesExports() {
+function assertVersionAtBuildTime(versionAtBuildTime) {
+    const versionAtRuntime = projectInfo.projectVersion;
+    const pretty = (version) => pc.bold(`vike@${version}`);
+    assertUsage(versionAtBuildTime === versionAtRuntime, `Re-build your app (you're using ${pretty(versionAtRuntime)} but your app was built with ${pretty(versionAtBuildTime)})`);
+}
+function getViteConfigRuntime(viteConfig) {
+    assert(hasProp(viteConfig, '_baseViteOriginal', 'string'));
+    const viteConfigRuntime = {
+        _baseViteOriginal: viteConfig._baseViteOriginal,
+        vitePluginServerEntry: {
+            inject: viteConfig.vitePluginServerEntry?.inject
+        }
+    };
+    return viteConfigRuntime;
+}
+async function updateUserFiles() {
+    const { promise, resolve } = genPromise();
+    assert(!globalObject.isProduction);
+    globalObject.waitForUserFilesUpdate = promise;
     const viteDevServer = getViteDevServer();
     assert(viteDevServer);
-    let moduleExports;
+    let virtualFileExports;
     try {
-        moduleExports = await viteDevServer.ssrLoadModule(virtualFileIdImportUserCodeServer);
+        virtualFileExports = 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;
+    virtualFileExports = virtualFileExports.default || virtualFileExports;
+    debugGlob('Glob result: ', virtualFileExports);
+    await setUserFiles(virtualFileExports);
+    resolve();
+}
+async function setUserFiles(virtualFileExports) {
+    globalObject.pageConfigsRuntime = getPageConfigsRuntime(virtualFileExports);
+    const userFiles = await getUserFiles();
+    globalObject.userFiles = userFiles;
+    defineGlobalContext();
+    assertGlobalContextIsDefined();
 }
 function clearGlobalContext() {
     debug('clearGlobalContext()');

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.d.ts

@@ -29,4 +29,4 @@ type HtmlTag = {
 };
 declare function getHtmlTags(pageContext: {
     _isStream: boolean;
-} & PageContextInjectAssets, streamFromReactStreamingPackage: null | StreamFromReactStreamingPackage, injectFilter: PreloadFilter, pageAssets: PageAsset[], viteDevScript: string, isStream: boolean): HtmlTag[];
+} & PageContextInjectAssets, streamFromReactStreamingPackage: null | StreamFromReactStreamingPackage, injectFilter: PreloadFilter, pageAssets: PageAsset[], viteDevScript: string, isStream: boolean): Promise<HtmlTag[]>;

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

@@ -1,3 +1,4 @@
+import { isFontFallback } from '../../renderPage/isFontFallback.js';
 export { getHtmlTags };
 import { assert, assertWarning, assertUsage, isObject, freezePartial } from '../../utils.js';
 import { serializePageContextClientSide } from '../serializePageContextClientSide.js';
@@ -6,16 +7,16 @@ 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/getConfigValueRuntime.js';
-import { getGlobalContext } from '../../globalContext.js';
 import pc from '@brillout/picocolors';
 import { getConfigDefinedAt } from '../../../../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) {
     assert([true, false].includes(pageContext._isHtmlOnly));
     const isHtmlOnly = pageContext._isHtmlOnly;
-    const { isProduction } = getGlobalContext();
+    const { isProduction } = pageContext._globalContext;
     const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._pageConfigs);
-    const injectFilterEntries = pageAssets
+    const injectFilterEntries = [];
+    pageAssets
         .filter((asset) => {
         if (asset.isEntry && asset.assetType === 'script') {
             // We could allow the user to change the position of <script> but we currently don't:
@@ -26,15 +27,18 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
         }
         return true;
     })
-        .map((asset) => {
+        .forEach((asset) => {
         const inject = (() => {
             if (!isProduction) {
                 // In development, we should always load assets as soon as possible, in order to eagerly process assets (e.g. applying the transform() hooks of Vite plugins) which are lazily discovered.
                 return 'HTML_BEGIN';
             }
-            if (asset.assetType === 'style' || asset.assetType === 'font') {
+            if (asset.assetType === 'style') {
                 return 'HTML_BEGIN';
             }
+            if (asset.assetType === 'font') {
+                return !isFontFallback(asset, injectFilterEntries) ? 'HTML_BEGIN' : false;
+            }
             if (asset.assetType === 'script') {
                 if (isHtmlOnly)
                     return false;
@@ -48,7 +52,7 @@ function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter,
             // @ts-ignore
             [stamp]: true
         };
-        return entry;
+        injectFilterEntries.push(entry);
     });
     assertInjectFilterEntries(injectFilterEntries);
     // ==============

package/dist/esm/node/runtime/html/injectAssets/getViteDevScript.d.ts

@@ -1,2 +1,5 @@
 export { getViteDevScript };
-declare function getViteDevScript(): Promise<string>;
+import type { GlobalContext } from '../../globalContext.js';
+declare function getViteDevScript(pageContext: {
+    _globalContext: GlobalContext;
+}): Promise<string>;

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

@@ -1,9 +1,8 @@
 export { getViteDevScript };
-import { getGlobalContext } from '../../globalContext.js';
 import { assert, assertUsage, assertWarning } from '../../utils.js';
 import pc from '@brillout/picocolors';
-async function getViteDevScript() {
-    const globalContext = getGlobalContext();
+async function getViteDevScript(pageContext) {
+    const globalContext = pageContext._globalContext;
     if (globalContext.isProduction) {
         return '';
     }

package/dist/esm/node/runtime/html/injectAssets.d.ts

@@ -8,6 +8,7 @@ import { type PreloadFilter } from './injectAssets/getHtmlTags.js';
 import type { StreamFromReactStreamingPackage } from './stream/react-streaming.js';
 import type { PageConfigRuntime } from '../../../shared/page-configs/PageConfig.js';
 import type { PageContextSerialization } from './serializePageContextClientSide.js';
+import type { GlobalContext } from '../globalContext.js';
 type PageContextInjectAssets = {
     urlPathname: string;
     __getPageAssets: () => Promise<PageAsset[]>;
@@ -21,6 +22,7 @@ type PageContextInjectAssets = {
     _baseServer: string;
     _pageConfigs: PageConfigRuntime[];
     is404: null | boolean;
+    _globalContext: GlobalContext;
 } & PageContextSerialization;
 declare function injectHtmlTagsToString(htmlParts: HtmlPart[], pageContext: PageContextInjectAssets & {
     _isStream: false;

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

@@ -7,8 +7,8 @@ import { getHtmlTags } from './injectAssets/getHtmlTags.js';
 import { getViteDevScript } from './injectAssets/getViteDevScript.js';
 async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
     const pageAssets = await pageContext.__getPageAssets();
-    const viteDevScript = await getViteDevScript();
-    const htmlTags = getHtmlTags(pageContext, null, injectFilter, pageAssets, viteDevScript, false);
+    const viteDevScript = await getViteDevScript(pageContext);
+    const htmlTags = await getHtmlTags(pageContext, null, injectFilter, pageAssets, viteDevScript, false);
     let htmlString = htmlPartsToString(htmlParts, pageAssets);
     htmlString = injectToHtmlBegin(htmlString, htmlTags);
     htmlString = injectToHtmlEnd(htmlString, htmlTags);
@@ -24,8 +24,8 @@ function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, in
     };
     async function injectAtStreamBegin(htmlPartsBegin) {
         const pageAssets = await pageContext.__getPageAssets();
-        const viteDevScript = await getViteDevScript();
-        htmlTags = getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, true);
+        const viteDevScript = await getViteDevScript(pageContext);
+        htmlTags = await getHtmlTags(pageContext, streamFromReactStreamingPackage, injectFilter, pageAssets, viteDevScript, true);
         let htmlBegin = htmlPartsToString(htmlPartsBegin, pageAssets);
         htmlBegin = injectToHtmlBegin(htmlBegin, htmlTags);
         if (streamFromReactStreamingPackage) {