vike 0.4.231 → 0.4.232-commit-134207d

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

@@ -15,14 +15,15 @@ export { setGlobalContext_buildEntry };
 export { clearGlobalContext };
 export { assertBuildInfo };
 export { updateUserFiles };
+export { vikeConfigErrorRecoverMsg };
 export type { BuildInfo };
 export type { GlobalContextServerInternal as GlobalContextServerInternal };
 export type { GlobalContextServer };
-import type { ViteManifest } from '../shared/ViteManifest.js';
+import type { ViteManifest } from '../../types/ViteManifest.js';
 import type { ResolvedConfig, ViteDevServer } from 'vite';
-import type { PageConfigUserFriendly } from '../../shared/page-configs/getUserFriendlyConfigs.js';
-import type { ViteConfigRuntime } from '../plugin/shared/getViteConfigRuntime.js';
-import type { GlobalContext } from '../../shared/types.js';
+import type { ViteConfigRuntime } from '../vite/shared/getViteConfigRuntime.js';
+import type { GlobalContext } from '../../types/PageContext.js';
+declare const vikeConfigErrorRecoverMsg: "Vike config loaded";
 type GlobalContextServer = Pick<GlobalContextServerInternal, 'assetsManifest' | 'config' | 'viteConfig' | 'viteConfigRuntime' | 'pages' | 'baseServer' | 'baseAssets' | 'isClientSide'> & Vike.GlobalContext & Vike.GlobalContextServer;
 type GlobalContextServerInternal = Awaited<ReturnType<typeof setGlobalContext>>;
 declare function getGlobalContextServerInternal(): Promise<{
@@ -31,19 +32,18 @@ declare function getGlobalContextServerInternal(): Promise<{
         _isOriginalObject: true;
         _virtualFileExports: unknown;
         _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
-        _pageConfigs: import("../../__internal/index.js").PageConfig[];
-        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
         _allPageIds: string[];
-        _userFriendlyConfigsGlobal: PageConfigUserFriendly;
+        _vikeConfigPublicGlobal: {
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        };
         config: import("../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: PageConfigUserFriendly & ({
-                route: import("../../shared/page-configs/Config.js").Route;
-                isErrorPage?: undefined;
-            } | {
-                route?: undefined;
-                isErrorPage: true;
-            });
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
         };
     } & {
         _isProduction: false;
@@ -71,19 +71,18 @@ declare function getGlobalContextServerInternal(): Promise<{
         _isOriginalObject: true;
         _virtualFileExports: unknown;
         _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
-        _pageConfigs: import("../../__internal/index.js").PageConfig[];
-        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
         _allPageIds: string[];
-        _userFriendlyConfigsGlobal: PageConfigUserFriendly;
+        _vikeConfigPublicGlobal: {
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        };
         config: import("../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: PageConfigUserFriendly & ({
-                route: import("../../shared/page-configs/Config.js").Route;
-                isErrorPage?: undefined;
-            } | {
-                route?: undefined;
-                isErrorPage: true;
-            });
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
         };
     } & {
         _isPrerendering: true;
@@ -112,19 +111,18 @@ declare function getGlobalContextServerInternal(): Promise<{
         _isOriginalObject: true;
         _virtualFileExports: unknown;
         _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
-        _pageConfigs: import("../../__internal/index.js").PageConfig[];
-        _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+        _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+        _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
         _allPageIds: string[];
-        _userFriendlyConfigsGlobal: PageConfigUserFriendly;
+        _vikeConfigPublicGlobal: {
+            config: import("../../types/index.js").ConfigResolved;
+            _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+        };
         config: import("../../types/index.js").ConfigResolved;
         pages: {
-            [k: string]: PageConfigUserFriendly & ({
-                route: import("../../shared/page-configs/Config.js").Route;
-                isErrorPage?: undefined;
-            } | {
-                route?: undefined;
-                isErrorPage: true;
-            });
+            [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
         };
     } & {
         _isPrerendering: false;
@@ -186,25 +184,26 @@ type BuildInfo = {
     viteConfigRuntime: ViteConfigRuntime;
 };
 declare function assertBuildInfo(buildInfo: unknown): asserts buildInfo is BuildInfo;
-declare function updateUserFiles(): Promise<void>;
+declare function updateUserFiles(): Promise<{
+    success: boolean;
+}>;
 declare function setGlobalContext(virtualFileExports: unknown): Promise<{
     isGlobalContext: true;
     _isOriginalObject: true;
     _virtualFileExports: unknown;
     _pageFilesAll: import("../../shared/getPageFiles.js").PageFile[];
-    _pageConfigs: import("../../__internal/index.js").PageConfig[];
-    _pageConfigGlobal: import("../../shared/page-configs/PageConfig.js").PageConfigGlobalRuntime;
+    _pageConfigs: import("../../types/PageConfig.js").PageConfigRuntime[];
+    _pageConfigGlobal: import("../../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _userFriendlyConfigsGlobal: PageConfigUserFriendly;
+    _vikeConfigPublicGlobal: {
+        config: import("../../types/index.js").ConfigResolved;
+        _source: import("../../shared/page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("../../shared/page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("../../shared/page-configs/resolveVikeConfigPublic.js").From;
+    };
     config: import("../../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: PageConfigUserFriendly & ({
-            route: import("../../shared/page-configs/Config.js").Route;
-            isErrorPage?: undefined;
-        } | {
-            route?: undefined;
-            isErrorPage: true;
-        });
+        [k: string]: import("../../shared/page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
     };
 } & ({
     _isProduction: false;

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

@@ -17,6 +17,7 @@ export { setGlobalContext_buildEntry };
 export { clearGlobalContext };
 export { assertBuildInfo };
 export { updateUserFiles };
+export { vikeConfigErrorRecoverMsg };
 // The core logic revolves around:
 // - virtualFileExports is the main requirement
 // - In production: globalObject.buildEntry which is the production entry set by @brillout/vite-plugin-server-entry
@@ -25,20 +26,24 @@ export { updateUserFiles };
 //   - 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 virtualFileExports
-import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectReplace, isObject, hasProp, debugGlob, getGlobalObject, genPromise, createDebugger, checkType, PROJECT_VERSION } from './utils.js';
+import { assert, onSetupRuntime, assertUsage, assertWarning, isPlainObject, objectReplace, isObject, hasProp, getGlobalObject, genPromise, createDebugger, checkType, PROJECT_VERSION, } from './utils.js';
 import { importServerProductionEntry } from '@brillout/vite-plugin-server-entry/runtime';
-import { virtualFileIdImportUserCodeServer } from '../shared/virtual-files/virtualFileImportUserCode.js';
+import { virtualFileIdEntryServer } from '../shared/virtualFiles/virtualFileEntry.js';
 import pc from '@brillout/picocolors';
 import { loadPageRoutes } from '../../shared/route/loadPageRoutes.js';
 import { assertV1Design } from '../shared/assertV1Design.js';
 import { resolveBase } from '../shared/resolveBase.js';
-import { createGlobalContextShared, getGlobalContextSyncErrMsg } from '../../shared/createGlobalContextShared.js';
+import { createGlobalContextShared, getGlobalContextSyncErrMsg, } from '../../shared/createGlobalContextShared.js';
 import { prepareGlobalContextForPublicUsage } from '../../shared/prepareGlobalContextForPublicUsage.js';
+import { logRuntimeError, logRuntimeInfo } from './loggerRuntime.js';
+import { getVikeConfigErrorBuild, setVikeConfigError } from '../shared/getVikeConfigError.js';
+import { hasAlreadyLogged } from './renderPage/isNewError.js';
 const debug = createDebugger('vike:globalContext');
 const globalObject = getGlobalObject('runtime/globalContext.ts', getInitialGlobalContext());
 // Trick to break down TypeScript circular dependency
 // https://chat.deepseek.com/a/chat/s/d7e9f90a-c7f3-4108-9cd5-4ad6caed3539
 const globalObjectTyped = globalObject;
+const vikeConfigErrorRecoverMsg = pc.bold(pc.green('Vike config loaded'));
 async function getGlobalContextServerInternal() {
     // getGlobalContextServerInternal() should always be called after initGlobalContext()
     assert(globalObject.isInitialized);
@@ -118,22 +123,24 @@ async function setGlobalContext_viteDevServer(viteDevServer) {
     setIsProduction(false);
     // We cannot cache globalObject.viteDevServer because it's fully replaced when the user modifies vite.config.js => Vite's dev server is fully reloaded and a new viteDevServer replaces the previous one.
     if (!globalObject.viteDevServer) {
-        assertIsNotInitilizedYet();
+        assertIsNotInitializedYet();
     }
     assert(globalObject.viteConfig);
     globalObject.viteDevServer = viteDevServer;
-    await updateUserFiles();
-    assertGlobalContextIsDefined();
     globalObject.viteDevServerPromiseResolve(viteDevServer);
+    const { success } = await updateUserFiles();
+    if (!success)
+        return;
+    assertGlobalContextIsDefined();
 }
 function setGlobalContext_viteConfig(viteConfig, viteConfigRuntime) {
     if (globalObject.viteConfig)
         return;
-    assertIsNotInitilizedYet();
+    assertIsNotInitializedYet();
     globalObject.viteConfig = viteConfig;
     globalObject.viteConfigRuntime = viteConfigRuntime;
 }
-function assertIsNotInitilizedYet() {
+function assertIsNotInitializedYet() {
     // In development, globalObject.viteDevServer always needs to be awaited for before initializing globalObject.globalContext
     assert(!globalObject.globalContext);
 }
@@ -157,7 +164,7 @@ function getViteConfig() {
 }
 async function initGlobalContext_renderPage() {
     debug('initGlobalContext_renderPage()');
-    // `globalObject.isProduction === undefined` when using production server without `vike-server`. (There isn't any reliable signal we can use to determine early whether the environement is production or development.)
+    // `globalObject.isProduction === undefined` when using production server without `vike-server`. (There isn't any reliable signal we can use to determine early whether the environment is production or development.)
     if (globalObject.isProduction === undefined)
         setIsProduction(true);
     await initGlobalContext();
@@ -174,7 +181,7 @@ async function initGlobalContext_runPrerender() {
     // We assume initGlobalContext_runPrerender() to be called before:
     // - initGlobalContext_renderPage()
     // - initGlobalContext_getGlobalContextAsync()
-    assertIsNotInitilizedYet();
+    assertIsNotInitializedYet();
     await initGlobalContext();
 }
 async function initGlobalContext_getGlobalContextAsync() {
@@ -186,24 +193,13 @@ async function 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) {
-        await waitForViteDevServer();
+        await globalObject.viteDevServerPromise;
+        assert(globalObject.waitForUserFilesUpdate);
+        await globalObject.waitForUserFilesUpdate;
     }
     else {
         await loadBuildEntry(globalObject.viteConfigRuntime?.build.outDir);
@@ -299,28 +295,72 @@ function assertVersionAtBuildTime(versionAtBuildTime) {
     assertUsage(versionAtBuildTime === versionAtRuntime, `Re-build your app (you're using ${pretty(versionAtRuntime)} but your app was built with ${pretty(versionAtBuildTime)})`);
 }
 async function updateUserFiles() {
-    const { promise, resolve } = genPromise();
     assert(!globalObject.isProduction);
+    const { promise, resolve } = genPromise();
     globalObject.waitForUserFilesUpdate = promise;
+    globalObject.waitForUserFilesUpdateResolve ?? (globalObject.waitForUserFilesUpdateResolve = []);
+    globalObject.waitForUserFilesUpdateResolve.push(resolve);
+    const onError = (err) => {
+        if (!hasAlreadyLogged(err)) {
+            logRuntimeError(err, null);
+        }
+        setVikeConfigError({ errorRuntime: { err } });
+        globalObject.vikeConfigHasRuntimeError = true;
+        return { success: false };
+    };
+    const onSuccess = () => {
+        if (globalObject.vikeConfigHasRuntimeError) {
+            assert(logRuntimeInfo); // always defined in dev
+            logRuntimeInfo(vikeConfigErrorRecoverMsg, null, 'error-recover');
+        }
+        globalObject.vikeConfigHasRuntimeError = false;
+        setVikeConfigError({ errorRuntime: false });
+        globalObject.waitForUserFilesUpdateResolve.forEach((resolve) => resolve());
+        globalObject.waitForUserFilesUpdateResolve = [];
+        resolve();
+        return { success: true };
+    };
+    const isOutdated = () => 
+    // There is a newer call — let the new call supersede the old one.
+    // We deliberately swallow the intermetidate state (including any potential error) — it's now outdated and has existed only for a very short period of time.
+    globalObject.waitForUserFilesUpdate !== promise ||
+        // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
+        viteDevServer !== globalObject.viteDevServer;
     const { viteDevServer } = globalObject;
     assert(viteDevServer);
+    let hasError = false;
     let virtualFileExports;
+    let err;
     try {
-        virtualFileExports = await viteDevServer.ssrLoadModule(virtualFileIdImportUserCodeServer);
+        virtualFileExports = await viteDevServer.ssrLoadModule(virtualFileIdEntryServer);
     }
-    catch (err) {
-        debugGlob(`Glob error: ${virtualFileIdImportUserCodeServer} transpile error: `, err);
-        throw err;
+    catch (err_) {
+        hasError = true;
+        err = err_;
     }
+    if (isOutdated())
+        return { success: false };
+    if (hasError)
+        return onError(err);
     virtualFileExports = virtualFileExports.default || virtualFileExports;
-    debugGlob('Glob result: ', virtualFileExports);
-    // Avoid race condition: abort if there is a new globalObject.viteDevServer (happens when vite.config.js is modified => Vite's dev server is fully reloaded).
-    if (viteDevServer !== globalObject.viteDevServer)
-        return;
-    await setGlobalContext(virtualFileExports);
-    resolve();
+    if (getVikeConfigErrorBuild()) {
+        return { success: false };
+    }
+    try {
+        await setGlobalContext(virtualFileExports);
+    }
+    catch (err_) {
+        hasError = true;
+        err = err_;
+    }
+    if (isOutdated())
+        return { success: false };
+    if (hasError)
+        return onError(err);
+    return onSuccess();
 }
 async function setGlobalContext(virtualFileExports) {
+    assert(!getVikeConfigErrorBuild());
     const globalContext = await createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext);
     assertV1Design(
     // pageConfigs is PageConfigRuntime[] but assertV1Design() requires PageConfigBuildTime[]
@@ -335,7 +375,7 @@ async function addGlobalContext(globalContext) {
     const globalContextBase = {
         isClientSide: false,
         _pageRoutes: pageRoutes,
-        _onBeforeRouteHook: onBeforeRouteHook
+        _onBeforeRouteHook: onBeforeRouteHook,
     };
     const { viteDevServer, viteConfig, viteConfigRuntime, isPrerendering, isProduction } = globalObject;
     assert(typeof isProduction === 'boolean');
@@ -353,7 +393,7 @@ async function addGlobalContext(globalContext) {
             assetsManifest: null,
             _viteDevServer: viteDevServer,
             viteConfig,
-            viteConfigRuntime
+            viteConfigRuntime,
         };
     }
     else {
@@ -369,21 +409,21 @@ async function addGlobalContext(globalContext) {
             assetsManifest,
             _viteDevServer: null,
             viteConfigRuntime: buildInfo.viteConfigRuntime,
-            _usesClientRouter: buildInfo.usesClientRouter
+            _usesClientRouter: buildInfo.usesClientRouter,
         };
         if (isPrerendering) {
             assert(viteConfig);
             return {
                 ...globalContextBase2,
                 _isPrerendering: true,
-                viteConfig
+                viteConfig,
             };
         }
         else {
             return {
                 ...globalContextBase2,
                 _isPrerendering: false,
-                viteConfig: null
+                viteConfig: null,
             };
         }
     }
@@ -397,7 +437,7 @@ function getInitialGlobalContext() {
     const { promise: viteDevServerPromise, resolve: viteDevServerPromiseResolve } = genPromise();
     return {
         viteDevServerPromise,
-        viteDevServerPromiseResolve
+        viteDevServerPromiseResolve,
     };
 }
 function resolveBaseRuntime(viteConfigRuntime, config) {

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

@@ -1,7 +1,7 @@
 import { isFontFallback } from '../../renderPage/isFontFallback.js';
 export { getHtmlTags };
 import { assert, assertWarning, assertUsage, isObject, freezePartial } from '../../utils.js';
-import { getGlobalContextClientSerialized, getPageContextClientSerialized } from '../serializeContext.js';
+import { getGlobalContextClientSerialized, getPageContextClientSerialized, } from '../serializeContext.js';
 import { sanitizeJson } from './sanitizeJson.js';
 import { inferAssetTag, inferPreloadTag } from './inferHtmlTags.js';
 import { mergeScriptTags } from './mergeScriptTags.js';
@@ -15,7 +15,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
     assert([true, false].includes(pageContext._isHtmlOnly));
     const isHtmlOnly = pageContext._isHtmlOnly;
     const { _isProduction: isProduction } = pageContext._globalContext;
-    const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._pageConfigs);
+    const injectScriptsAt = getInjectScriptsAt(pageContext.pageId, pageContext._globalContext._pageConfigs);
     const injectFilterEntries = [];
     pageAssets
         .filter((asset) => {
@@ -23,7 +23,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
             // We could allow the user to change the position of <script> but we currently don't:
             //  - Because of mergeScriptEntries()
             //  - We would need to add HTML_STREAM to to PreloadFilterInject
-            // To suppor this, we should add the JavaScript entry to injectFilterEntries (with an `src` value of `null`)
+            // To support this, we should add the JavaScript entry to injectFilterEntries (with an `src` value of `null`)
             return false;
         }
         return true;
@@ -51,7 +51,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
             ...asset,
             inject,
             // @ts-ignore
-            [stamp]: true
+            [stamp]: true,
         };
         injectFilterEntries.push(entry);
     });
@@ -126,14 +126,14 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
             htmlTag: () => 
             // Needs to be called after resolvePageContextPromise()
             getPageContextJsonScriptTag(pageContext),
-            position: positionJavaScriptEntry
+            position: positionJavaScriptEntry,
         });
         // <script id="vike_globalContext" type="application/json">
         htmlTags.push({
             htmlTag: () => 
             // Needs to be called after resolvePageContextPromise()
             getGlobalContextJsonScriptTag(pageContext),
-            position: positionJavaScriptEntry
+            position: positionJavaScriptEntry,
         });
     }
     // The JavaScript entry <script> tag
@@ -141,7 +141,7 @@ async function getHtmlTags(pageContext, streamFromReactStreamingPackage, injectF
     if (scriptEntry) {
         htmlTags.push({
             htmlTag: scriptEntry,
-            position: positionJavaScriptEntry
+            position: positionJavaScriptEntry,
         });
     }
     // Preload tags
@@ -216,12 +216,12 @@ function checkForWarnings(injectFilterEntries) {
             //  - https://github.com/vitejs/vite/issues/2282
             //  - https://github.com/vikejs/vike/issues/261
             assertWarning(a.inject, `[injectFilter()] We recommend against not injecting ${a.src}`, {
-                onlyOnce: true
+                onlyOnce: true,
             });
         }
         if (a.assetType === 'script') {
             assertWarning(a.inject, `[injectFilter()] We recommend against not preloading JavaScript (${a.src})`, {
-                onlyOnce: true
+                onlyOnce: true,
             });
         }
     });

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

@@ -18,7 +18,7 @@ async function getViteDevScript(pageContext) {
     const viteInjection = fakeHtml.slice(fakeHtmlBegin.length, -1 * fakeHtmlEnd.length);
     assert(viteInjection.includes('script'));
     assertWarning(!viteInjection.includes('import('), `Unexpected Vite injected HMR code. ${reachOutCTA}`, {
-        onlyOnce: true
+        onlyOnce: true,
     });
     const viteDevScript = viteInjection;
     return viteDevScript;

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

@@ -14,7 +14,7 @@ function inferPreloadTag(pageAsset) {
         !assetType ? null : `as="${assetType}"`,
         !mediaType ? null : `type="${mediaType}"`,
         // `crossorigin` is needed for fonts, see https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload#cors-enabled_fetches
-        !isCrossOrigin(pageAsset) ? null : 'crossorigin'
+        !isCrossOrigin(pageAsset) ? null : 'crossorigin',
     ]
         .filter(Boolean)
         .join(' ');

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

@@ -6,22 +6,22 @@ async function injectAssets__public(htmlString, pageContext) {
     assertWarning(false, '`_injectAssets()` is deprecated and will be removed.', { onlyOnce: true, showStackTrace: true });
     assertUsage(typeof htmlString === 'string', '[injectAssets(htmlString, pageContext)]: Argument `htmlString` should be a string.', { showStackTrace: true });
     assertUsage(pageContext, '[injectAssets(htmlString, pageContext)]: Argument `pageContext` is missing.', {
-        showStackTrace: true
+        showStackTrace: true,
     });
     const errMsg = (body) => '[injectAssets(htmlString, pageContext)]: ' +
         body +
         '. Make sure that `pageContext` is the object that Vike provided to your `render(pageContext)` hook.';
     assertUsage(hasProp(pageContext, 'urlPathname', 'string'), errMsg('`pageContext.urlPathname` should be a string'), {
-        showStackTrace: true
+        showStackTrace: true,
     });
     assertUsage(hasProp(pageContext, 'pageId', 'string'), errMsg('`pageContext.pageId` should be a string'), {
-        showStackTrace: true
+        showStackTrace: true,
     });
     assertUsage(hasProp(pageContext, '__getPageAssets'), errMsg('`pageContext.__getPageAssets` is missing'), {
-        showStackTrace: true
+        showStackTrace: true,
     });
     assertUsage(hasProp(pageContext, '_passToClient', 'string[]'), errMsg('`pageContext._passToClient` is missing'), {
-        showStackTrace: true
+        showStackTrace: true,
     });
     castProp(pageContext, '__getPageAssets');
     htmlString = await injectHtmlTagsToString([htmlString], pageContext, null);

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

@@ -29,7 +29,7 @@ function joinHtmlTags(htmlTags) {
 function injectHtmlFragment(position, htmlFragment, htmlString) {
     if (position === 'HTML_BEGIN') {
         {
-            const res = injectAtPaceholder(htmlFragment, htmlString, true);
+            const res = injectAtPlaceholder(htmlFragment, htmlString, true);
             if (res)
                 return res;
         }
@@ -39,7 +39,7 @@ function injectHtmlFragment(position, htmlFragment, htmlString) {
     }
     if (position === 'HTML_END') {
         {
-            const res = injectAtPaceholder(htmlFragment, htmlString, false);
+            const res = injectAtPlaceholder(htmlFragment, htmlString, false);
             if (res)
                 return res;
         }
@@ -148,7 +148,7 @@ function getTagClosing(tag) {
     const tagClosing = new RegExp(`</${tag}>`, 'i');
     return tagClosing;
 }
-function injectAtPaceholder(htmlFragment, htmlString, isFirst) {
+function injectAtPlaceholder(htmlFragment, htmlString, isFirst) {
     const placeholder = isFirst ? '__VITE_PLUGIN_SSR__ASSETS_FIRST__' : '__VITE_PLUGIN__SSR_ASSETS_LAST__';
     const parts = htmlString.split(placeholder);
     if (parts.length === 1)

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

@@ -6,7 +6,6 @@ import type { PageAsset } from '../renderPage/getPageAssets.js';
 import type { HtmlPart } from './renderHtml.js';
 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 './serializeContext.js';
 import type { GlobalContextServerInternal } from '../globalContext.js';
 type PageContextInjectAssets = {
@@ -20,7 +19,6 @@ type PageContextInjectAssets = {
         hookName: 'onRenderHtml' | 'render';
     };
     _baseServer: string;
-    _pageConfigs: PageConfigRuntime[];
     is404: null | boolean;
     _globalContext: GlobalContextServerInternal;
 } & PageContextSerialization;

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

@@ -2,7 +2,7 @@ export { injectHtmlTagsToString };
 export { injectHtmlTagsToStream };
 import { assert, isCallable, isPromise } from '../utils.js';
 import { assertPageContextProvidedByUser } from '../../../shared/assertPageContextProvidedByUser.js';
-import { joinHtmlTags, injectHtmlTags, createHtmlHeadIfMissing, injectHtmlTagsUsingStream } from './injectAssets/injectHtmlTags.js';
+import { joinHtmlTags, injectHtmlTags, createHtmlHeadIfMissing, injectHtmlTagsUsingStream, } from './injectAssets/injectHtmlTags.js';
 import { getHtmlTags } from './injectAssets/getHtmlTags.js';
 import { getViteDevScript } from './injectAssets/getViteDevScript.js';
 async function injectHtmlTagsToString(htmlParts, pageContext, injectFilter) {
@@ -20,7 +20,7 @@ function injectHtmlTagsToStream(pageContext, streamFromReactStreamingPackage, in
     return {
         injectAtStreamBegin,
         injectAtStreamAfterFirstChunk,
-        injectAtStreamEnd
+        injectAtStreamEnd,
     };
     async function injectAtStreamBegin(htmlPartsBegin) {
         const pageAssets = await pageContext.__getPageAssets();

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

@@ -3,9 +3,9 @@ export { dangerouslySkipEscape };
 export { renderDocumentHtml };
 export { isDocumentHtml };
 export { getHtmlString };
-import { assert, assertUsage, assertWarning, checkType, escapeHtml, hasProp, isHtml, isPromise, objectAssign } from '../utils.js';
+import { assert, assertUsage, assertWarning, checkType, escapeHtml, hasProp, isHtml, isPromise, objectAssign, } from '../utils.js';
 import { injectHtmlTagsToString, injectHtmlTagsToStream } from './injectAssets.js';
-import { processStream, isStream, streamToString } from './stream.js';
+import { processStream, isStream, streamToString, } from './stream.js';
 import { isStreamFromReactStreamingPackage } from './stream/react-streaming.js';
 import pc from '@brillout/picocolors';
 function isDocumentHtml(something) {
@@ -42,7 +42,7 @@ async function renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreami
             const { htmlStream } = render;
             const streamWrapper = await renderHtmlStream(htmlStream, {
                 htmlPartsBegin: render.htmlPartsBegin,
-                htmlPartsEnd: render.htmlPartsEnd
+                htmlPartsEnd: render.htmlPartsEnd,
             }, pageContext, onErrorWhileStreaming, injectFilter);
             return streamWrapper;
         }
@@ -53,7 +53,7 @@ async function renderDocumentHtml(documentHtml, pageContext, onErrorWhileStreami
 async function renderHtmlStream(streamOriginal, injectString, pageContext, onErrorWhileStreaming, injectFilter) {
     const processStreamOptions = {
         onErrorWhileStreaming,
-        enableEagerStreaming: pageContext.enableEagerStreaming
+        enableEagerStreaming: pageContext.enableEagerStreaming,
     };
     if (injectString) {
         let streamFromReactStreamingPackage = null;
@@ -107,8 +107,8 @@ function escapeInject(templateStrings, ...templateVariables) {
     return {
         _template: {
             templateStrings,
-            templateVariables: templateVariables
-        }
+            templateVariables: templateVariables,
+        },
     };
 }
 function dangerouslySkipEscape(alreadyEscapedString) {
@@ -125,7 +125,7 @@ function _dangerouslySkipEscape(arg) {
     }
     assertWarning(false, `[dangerouslySkipEscape(${pc.cyan('str')})] Argument ${pc.cyan('str')} should be a string but we got ${pc.cyan(`typeof str === "${typeof arg}"`)}.`, {
         onlyOnce: false,
-        showStackTrace: true
+        showStackTrace: true,
     });
     return { _escaped: String(arg) };
 }
@@ -180,7 +180,7 @@ function renderTemplate(templateContent, pageContext) {
             const nth = (i === 0 && '1st') || (i === 1 && '2nd') || (i === 2 && '3rd') || `${i}-th`;
             return [
                 `The ${nth} HTML variable is ${msg}`,
-                `The HTML was provided by the ${hookName}() hook at ${hookFilePath}.`
+                `The HTML was provided by the ${hookName}() hook at ${hookFilePath}.`,
             ]
                 .filter(Boolean)
                 .join(' ');
@@ -219,13 +219,13 @@ function renderTemplate(templateContent, pageContext) {
     if (htmlStream === null) {
         assert(htmlPartsEnd.length === 0);
         return {
-            htmlPartsAll: htmlPartsBegin
+            htmlPartsAll: htmlPartsBegin,
         };
     }
     return {
         htmlStream,
         htmlPartsBegin,
-        htmlPartsEnd
+        htmlPartsEnd,
     };
 }
 async function getHtmlString(htmlRender) {