vike 0.4.237 → 0.4.238-commit-3c1a09d

package/dist/esm/node/vite/shared/resolveVikeConfigInternal/crawlPlusFiles.js

@@ -1,7 +1,7 @@
 export { crawlPlusFiles };
 export { isPlusFile };
 export { getPlusFileValueConfigName };
-import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsSingleModuleInstance, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish, } from '../../utils.js';
+import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish, getGlobalObject, } from '../../utils.js';
 import path from 'node:path';
 import { glob } from 'tinyglobby';
 import { exec } from 'node:child_process';
@@ -14,8 +14,9 @@ import { ignorePatternsBuiltIn } from './crawlPlusFiles/ignorePatternsBuiltIn.js
 const execA = promisify(exec);
 const debug = createDebugger('vike:crawl');
 assertIsNotProductionRuntime();
-assertIsSingleModuleInstance('getVikeConfig/crawlPlusFiles.ts');
-let gitIsNotUsable = false;
+const globalObject = getGlobalObject('getVikeConfig/crawlPlusFiles.ts', {
+    gitIsNotUsable: false,
+});
 async function crawlPlusFiles(userRootDir) {
     assertPosixPath(userRootDir);
     assertFilePathAbsoluteFilesystem(userRootDir);
@@ -48,7 +49,7 @@ async function crawlPlusFiles(userRootDir) {
 }
 // Same as tinyglobby() but using `$ git ls-files`
 async function gitLsFiles(userRootDir, ignorePatterns, ignoreMatchers) {
-    if (gitIsNotUsable)
+    if (globalObject.gitIsNotUsable)
         return null;
     // Preserve UTF-8 file paths.
     // https://github.com/vikejs/vike/issues/1658
@@ -82,7 +83,7 @@ async function gitLsFiles(userRootDir, ignorePatterns, ignoreMatchers) {
     }
     catch (err) {
         if (await isGitNotUsable(userRootDir)) {
-            gitIsNotUsable = true;
+            globalObject.gitIsNotUsable = true;
             return null;
         }
         throw err;

package/dist/esm/node/vite/shared/resolveVikeConfigInternal.d.ts

@@ -8,11 +8,12 @@ export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
 export type { VikeConfigInternal };
+export type { PageConfigBuildTimeBeforeComputed };
 export { getVikeConfig };
 export type { VikeConfig };
 import type { PageConfigGlobalBuildTime, PageConfigBuildTime } from '../../../types/PageConfig.js';
 import { type ConfigDefinitionsInternal, type ConfigDefinitionInternal } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
-import { type VikeConfigPublicGlobal, type VikeConfigPublicPageEager } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { type VikeConfigPublicGlobal, type VikeConfigPublicPageEagerLoaded } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { type PlusFile } from './resolveVikeConfigInternal/getPlusFilesAll.js';
 import type { PrerenderContextPublic } from '../../prerender/runPrerender.js';
 import type { ResolvedConfig, UserConfig } from 'vite';
@@ -33,7 +34,7 @@ type VikeConfigInternal = {
     config: VikeConfigPublicGlobal['config'];
     _from: VikeConfigPublicGlobal['_from'];
     pages: Record<string, // pageId
-    VikeConfigPublicPageEager>;
+    VikeConfigPublicPageEagerLoaded>;
     _vikeConfigDependencies: Set<string>;
     prerenderContext: PrerenderContext;
 };
@@ -57,6 +58,7 @@ declare function getVikeConfigFromCliOrEnv(): {
     configFromCliOptions: import("../../cli/parseCli.js").CliOptions | null;
     configFromEnvVar: Record<string, unknown> | null;
 };
+type PageConfigBuildTimeBeforeComputed = Omit<PageConfigBuildTime, 'configValuesComputed'>;
 declare function getConfigDefinitionOptional(configDefinitions: ConfigDefinitionsInternal, configName: string): ConfigDefinitionInternal | null;
 declare function getConfVal(plusFile: PlusFile, configName: string): null | {
     value: unknown;

package/dist/esm/node/vite/shared/resolveVikeConfigInternal.js

@@ -10,7 +10,7 @@ export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
 // Public usage
 export { getVikeConfig };
-import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, assertIsSingleModuleInstance, genPromise, checkType, objectAssign, } from '../utils.js';
+import { assertPosixPath, assert, isObject, assertUsage, assertWarning, objectEntries, hasProp, includes, assertIsNotProductionRuntime, getMostSimilar, joinEnglish, assertKeys, objectKeys, objectFromEntries, unique, isCallable, makeFirst, lowerFirst, makeLast, genPromise, checkType, objectAssign, getGlobalObject, } from '../utils.js';
 import { configDefinitionsBuiltIn, } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect, } from './resolveVikeConfigInternal/filesystemRouting.js';
 import { getViteDevServer } from '../../runtime/globalContext.js';
@@ -22,31 +22,29 @@ import { loadPointerImport, loadValueFile } from './resolveVikeConfigInternal/lo
 import { resolvePointerImport } from './resolveVikeConfigInternal/resolvePointerImport.js';
 import { getFilePathResolved } from './getFilePath.js';
 import { getConfigValueBuildTime } from '../../../shared/page-configs/getConfigValueBuildTime.js';
-import { resolveVikeConfigPublicGlobal, resolveVikeConfigPublicPageEager, } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { resolveVikeConfigPublicGlobal, resolveVikeConfigPublicPageEagerLoaded, } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
 import { getConfigValuesBase, isJsonValue } from '../../../shared/page-configs/serialize/serializeConfigValues.js';
 import { getPlusFilesAll, } from './resolveVikeConfigInternal/getPlusFilesAll.js';
 import { getEnvVarObject } from './getEnvVarObject.js';
-import { getApiOperation } from '../../api/context.js';
+import { getVikeApiOperation } from '../../api/context.js';
 import { getCliOptions } from '../../cli/context.js';
 import { resolvePrerenderConfigGlobal } from '../../prerender/resolvePrerenderConfig.js';
 import { getProxyForPublicUsage } from '../../../shared/getProxyForPublicUsage.js';
 import { setVikeConfigError } from '../../shared/getVikeConfigError.js';
 assertIsNotProductionRuntime();
-// We can simply use global variables since Vike's config is:
-//  - global
-//  - independent of Vite (therefore we don't need to tie Vike's config with Vite's `config` object)
-assertIsSingleModuleInstance('v1-design/getVikeConfig.ts');
-let restartVite = false;
-let vikeConfigHasBuildError = null;
-let isV1Design_ = null;
-let vikeConfigPromise = null;
-// TO-DO/next-major-release: remove
-let vikeConfigSync = null;
-let vikeConfigCtx = null; // Information provided by Vite's `config` and Vike's CLI. We could, if we want or need to, completely remove the dependency on Vite.
-let prerenderContext;
+const globalObject = getGlobalObject('vite/shared/resolveVikeConfigInternal.ts', {
+    restartVite: false,
+    vikeConfigHasBuildError: null,
+    isV1Design_: null,
+    vikeConfigPromise: null,
+    // TO-DO/next-major-release: remove
+    vikeConfigSync: null,
+    vikeConfigCtx: null, // Information provided by Vite's `config` and Vike's CLI. We could, if we want or need to, completely remove the dependency on Vite.
+    prerenderContext: null,
+});
 function reloadVikeConfig() {
-    assert(vikeConfigCtx);
-    const { userRootDir, vikeVitePluginOptions } = vikeConfigCtx;
+    assert(globalObject.vikeConfigCtx);
+    const { userRootDir, vikeVitePluginOptions } = globalObject.vikeConfigCtx;
     assert(vikeVitePluginOptions);
     resolveVikeConfigInternal_withErrorHandling(userRootDir, true, vikeVitePluginOptions);
 }
@@ -54,15 +52,15 @@ async function getVikeConfigInternal(
 // I don't remember the logic behind it — neither why we restart Vite's dev server, nor why we sometimes don't.
 // TO-DO/eventually: re-think all that. Some + settings are expected to influence Vite's config (restarting Vite's dev server is needed) while some don't.
 doNotRestartViteOnError = false) {
-    assert(vikeConfigCtx);
-    const { userRootDir, isDev, vikeVitePluginOptions } = vikeConfigCtx;
+    assert(globalObject.vikeConfigCtx);
+    const { userRootDir, isDev, vikeVitePluginOptions } = globalObject.vikeConfigCtx;
     const vikeConfig = await getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
     return vikeConfig;
 }
 // TO-DO/next-major-release: remove
 function getVikeConfigInternalSync() {
-    assert(vikeConfigSync);
-    return vikeConfigSync;
+    assert(globalObject.vikeConfigSync);
+    return globalObject.vikeConfigSync;
 }
 // TO-DO/eventually: this maybe(/probably?) isn't safe against race conditions upon file changes in development, thus:
 // - Like getGlobalContext() and getGlobalContextSync() — make getVikeConfig() async and provide a getVikeConfigSync() while discourage using it
@@ -83,29 +81,29 @@ config) {
 }
 function setVikeConfigContext(vikeConfigCtx_) {
     // If the user changes Vite's `config.root` => Vite completely reloads itself => setVikeConfigContext() is called again
-    vikeConfigCtx = vikeConfigCtx_;
+    globalObject.vikeConfigCtx = vikeConfigCtx_;
 }
 async function getOrResolveVikeConfig(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
-    if (!vikeConfigPromise) {
+    if (!globalObject.vikeConfigPromise) {
         resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError);
     }
-    assert(vikeConfigPromise);
-    const vikeConfig = await vikeConfigPromise;
+    assert(globalObject.vikeConfigPromise);
+    const vikeConfig = await globalObject.vikeConfigPromise;
     return vikeConfig;
 }
 async function getVikeConfigInternalOptional() {
-    if (!vikeConfigPromise)
+    if (!globalObject.vikeConfigPromise)
         return null;
-    const vikeConfig = await vikeConfigPromise;
+    const vikeConfig = await globalObject.vikeConfigPromise;
     return vikeConfig;
 }
 function isV1Design() {
-    assert(typeof isV1Design_ === 'boolean');
-    return isV1Design_;
+    assert(typeof globalObject.isV1Design_ === 'boolean');
+    return globalObject.isV1Design_;
 }
 async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, vikeVitePluginOptions, doNotRestartViteOnError) {
     const { promise, resolve, reject } = genPromise();
-    vikeConfigPromise = promise;
+    globalObject.vikeConfigPromise = promise;
     const esbuildCache = {
         transpileCache: {},
         vikeConfigDependencies: new Set(),
@@ -122,10 +120,10 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
     }
     // 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.
-    if (vikeConfigPromise !== promise) {
+    if (globalObject.vikeConfigPromise !== promise) {
         // vikeConfigPromise.then(resolve).catch(reject)
         try {
-            resolve(await vikeConfigPromise);
+            resolve(await globalObject.vikeConfigPromise);
         }
         catch (err) {
             reject(err);
@@ -135,13 +133,13 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
     if (!hasError) {
         assert(ret);
         assert(err === undefined);
-        const hadError = vikeConfigHasBuildError;
-        vikeConfigHasBuildError = false;
+        const hadError = globalObject.vikeConfigHasBuildError;
+        globalObject.vikeConfigHasBuildError = false;
         setVikeConfigError({ errorBuild: false });
         if (hadError) {
             logConfigErrorRecover();
-            if (restartVite) {
-                restartVite = false;
+            if (globalObject.restartVite) {
+                globalObject.restartVite = false;
                 restartViteDevServer();
             }
         }
@@ -150,10 +148,10 @@ async function resolveVikeConfigInternal_withErrorHandling(userRootDir, isDev, v
     else {
         assert(ret === undefined);
         assert(err);
-        vikeConfigHasBuildError = true;
+        globalObject.vikeConfigHasBuildError = true;
         setVikeConfigError({ errorBuild: { err } });
         if (!doNotRestartViteOnError)
-            restartVite = true;
+            globalObject.restartVite = true;
         if (!isDev) {
             reject(err);
         }
@@ -167,8 +165,8 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
     const plusFilesAll = await getPlusFilesAll(userRootDir, esbuildCache);
     const configDefinitionsResolved = await resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache);
     const { pageConfigGlobal, pageConfigs } = getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRootDir);
-    if (!isV1Design_)
-        isV1Design_ = pageConfigs.length > 0;
+    if (!globalObject.isV1Design_)
+        globalObject.isV1Design_ = pageConfigs.length > 0;
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
@@ -178,7 +176,7 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
     // pages
     const vikeConfigPublicPagesEager = objectFromEntries(pageConfigs.map((pageConfig) => {
         const pageConfigValues = getConfigValues(pageConfig, true);
-        return resolveVikeConfigPublicPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues);
+        return resolveVikeConfigPublicPageEagerLoaded(pageConfigGlobalValues, pageConfig, pageConfigValues);
     }));
     const prerenderContext = resolvePrerenderContext({
         config: vikeConfigPublicGlobal.config,
@@ -194,7 +192,7 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
         prerenderContext,
         _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
     };
-    vikeConfigSync = vikeConfig;
+    globalObject.vikeConfigSync = vikeConfig;
     return vikeConfig;
 }
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
@@ -418,9 +416,9 @@ function temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, use
 }
 function setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved) {
     // Vike API — passed options [lowest precedence]
-    const apiOperation = getApiOperation();
-    if (apiOperation?.options.vikeConfig) {
-        addSources(apiOperation.options.vikeConfig, { definedBy: 'api', operation: apiOperation.operation }, false);
+    const vikeApiOperation = getVikeApiOperation();
+    if (vikeApiOperation?.options.vikeConfig) {
+        addSources(vikeApiOperation.options.vikeConfig, { definedBy: 'api', operation: vikeApiOperation.operation }, false);
     }
     const { configFromCliOptions, configFromEnvVar } = getVikeConfigFromCliOrEnv();
     // Vike CLI options
@@ -1099,7 +1097,7 @@ function isGlobalLocation(locationId, plusFilesAll) {
 }
 function resolvePrerenderContext(vikeConfig) {
     const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = resolvePrerenderConfigGlobal(vikeConfig);
-    prerenderContext ?? (prerenderContext = {
+    globalObject.prerenderContext ?? (globalObject.prerenderContext = {
         isPrerenderingEnabled: false,
         isPrerenderingEnabledForAllPages: false,
         // Set at runPrerender()
@@ -1107,9 +1105,9 @@ function resolvePrerenderContext(vikeConfig) {
         // Set at runPrerender()
         pageContexts: null,
     });
-    prerenderContext.isPrerenderingEnabled = isPrerenderingEnabled;
-    prerenderContext.isPrerenderingEnabledForAllPages = isPrerenderingEnabledForAllPages;
-    return prerenderContext;
+    globalObject.prerenderContext.isPrerenderingEnabled = isPrerenderingEnabled;
+    globalObject.prerenderContext.isPrerenderingEnabledForAllPages = isPrerenderingEnabledForAllPages;
+    return globalObject.prerenderContext;
 }
 function restartViteDevServer() {
     const viteDevServer = getViteDevServer();
@@ -1146,7 +1144,7 @@ function getVikeConfigDummy(esbuildCache) {
         prerenderContext: prerenderContextDummy,
         _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
     };
-    vikeConfigSync = vikeConfigDummy;
-    isV1Design_ = true;
+    globalObject.vikeConfigSync = vikeConfigDummy;
+    globalObject.isV1Design_ = true;
     return vikeConfigDummy;
 }

package/dist/esm/shared/createGlobalContextShared.d.ts

@@ -9,9 +9,10 @@ import type { GlobalContextServerInternal } from '../node/runtime/globalContext.
 import type { GlobalContextClientInternal } from '../client/runtime-client-routing/globalContext.js';
 import { type Hook } from './hooks/getHook.js';
 declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
-declare function createGlobalContextShared<GlobalContextAdded extends Record<string, any>, GlobalContextAddedAsync extends Record<string, any>>(virtualFileExports: unknown, globalObject: {
+declare function createGlobalContextShared<GlobalContextAdded extends Record<string, any>, GlobalContextAddedAsync extends Record<string, any>>(virtualFileExportsGlobalEntry: unknown, globalObject: {
     globalContext?: Record<string, unknown>;
     onCreateGlobalContextHooks?: Hook[];
+    previousCreateGlobalContextPromise?: Promise<void>;
 }, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -20,7 +21,7 @@ declare function createGlobalContextShared<GlobalContextAdded extends Record<str
      */
     isGlobalContext: true;
     _isOriginalObject: true;
-    _virtualFileExports: unknown;
+    _virtualFileExportsGlobalEntry: unknown;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -33,12 +34,12 @@ declare function createGlobalContextShared<GlobalContextAdded extends Record<str
     };
     config: import("../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
     };
 } & GlobalContextAdded & GlobalContextAddedAsync>;
 type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
 type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
-declare function createGlobalContextBase(virtualFileExports: unknown): {
+declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown): {
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
      *
@@ -46,7 +47,7 @@ declare function createGlobalContextBase(virtualFileExports: unknown): {
      */
     isGlobalContext: true;
     _isOriginalObject: true;
-    _virtualFileExports: unknown;
+    _virtualFileExportsGlobalEntry: unknown;
     _pageFilesAll: PageFile[];
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
@@ -59,6 +60,6 @@ declare function createGlobalContextBase(virtualFileExports: unknown): {
     };
     config: import("../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
     };
 };

package/dist/esm/shared/createGlobalContextShared.js

@@ -1,18 +1,17 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
-import { changeEnumerable, genPromise, getGlobalObject, objectAssign, objectReplace, unique } from './utils.js';
-import { parseVirtualFileExports } from './getPageFiles/parseVirtualFileExports.js';
-import { resolveVikeConfigPublicGlobal, resolveVikeConfigPublicPageEager, } from './page-configs/resolveVikeConfigPublic.js';
+import { assert, changeEnumerable, genPromise, objectAssign, objectReplace, unique } from './utils.js';
+import { parseVirtualFileExportsGlobalEntry } from './getPageFiles/parseVirtualFileExportsGlobalEntry.js';
+import { resolveVikeConfigPublicGlobal, resolveVikeConfigPublicPageEagerLoaded, } from './page-configs/resolveVikeConfigPublic.js';
 import { execHookGlobal } from './hooks/execHook.js';
 import { prepareGlobalContextForPublicUsage } from './prepareGlobalContextForPublicUsage.js';
 import { getHookFromPageConfigGlobalCumulative } from './hooks/getHook.js';
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
-const globalObject_ = getGlobalObject('shared/createGlobalContextShared.ts', {});
 // TO-DO/eventually use flat globalContext — like flat pageContext
-async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext, 
+async function createGlobalContextShared(virtualFileExportsGlobalEntry, globalObject, addGlobalContext, 
 // TO-DO/next-major-release: we'll be able to remove addGlobalContextTmp after loadPageRoutes() is sync (it will be sync after we remove the old design)
 addGlobalContextTmp, addGlobalContextAsync) {
-    const { previousCallPromise } = globalObject_;
+    const { previousCreateGlobalContextPromise } = globalObject;
     const { promise, resolve } = genPromise({
         // Avoid this Cloudflare Worker error:
         // ```console
@@ -20,9 +19,12 @@ addGlobalContextTmp, addGlobalContextAsync) {
         // ```
         timeout: null,
     });
-    globalObject_.previousCallPromise = promise;
-    await previousCallPromise;
-    const globalContext = createGlobalContextBase(virtualFileExports);
+    globalObject.previousCreateGlobalContextPromise = promise;
+    if (previousCreateGlobalContextPromise) {
+        assert(globalObject.globalContext);
+        await previousCreateGlobalContextPromise;
+    }
+    const globalContext = createGlobalContextBase(virtualFileExportsGlobalEntry);
     let isNewGlobalContext;
     if (!globalObject.globalContext) {
         // We set globalObject.globalContext early and before any async operations, so that getGlobalContextSync() can be used early.
@@ -34,7 +36,7 @@ addGlobalContextTmp, addGlobalContextAsync) {
         isNewGlobalContext = true;
     }
     if (addGlobalContext &&
-        // TODO/next-major-release: remove
+        // TO-DO/next-major-release: remove
         globalContext._pageConfigs.length > 0) {
         const globalContextAdded = addGlobalContext?.(globalContext);
         objectAssign(globalContext, globalContextAdded);
@@ -67,8 +69,8 @@ addGlobalContextTmp, addGlobalContextAsync) {
     resolve();
     return globalObject.globalContext;
 }
-function createGlobalContextBase(virtualFileExports) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, vikeConfigPublicGlobal, vikeConfigPublicPagesEager, } = getConfigsAll(virtualFileExports);
+function createGlobalContextBase(virtualFileExportsGlobalEntry) {
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, vikeConfigPublicGlobal, vikeConfigPublicPagesEager, } = getConfigsAll(virtualFileExportsGlobalEntry);
     const globalContext = {
         /**
          * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -77,7 +79,7 @@ function createGlobalContextBase(virtualFileExports) {
          */
         isGlobalContext: true,
         _isOriginalObject: true,
-        _virtualFileExports: virtualFileExports,
+        _virtualFileExportsGlobalEntry: virtualFileExportsGlobalEntry,
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
@@ -89,14 +91,14 @@ function createGlobalContextBase(virtualFileExports) {
     changeEnumerable(globalContext, '_isOriginalObject', false);
     return globalContext;
 }
-function getConfigsAll(virtualFileExports) {
-    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseVirtualFileExports(virtualFileExports);
+function getConfigsAll(virtualFileExportsGlobalEntry) {
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
     const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
     const vikeConfigPublicGlobal = resolveVikeConfigPublicGlobal({
         pageConfigGlobalValues: pageConfigGlobal.configValues,
     });
     const vikeConfigPublicPagesEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
-        return resolveVikeConfigPublicPageEager(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
+        return resolveVikeConfigPublicPageEagerLoaded(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
     }));
     return {
         pageFilesAll,

package/dist/esm/shared/getPageFiles/{parseVirtualFileExports.d.ts → parseVirtualFileExportsGlobalEntry.d.ts}

@@ -1,7 +1,7 @@
-export { parseVirtualFileExports };
+export { parseVirtualFileExportsGlobalEntry };
 import { type PageFile } from './getPageFileObject.js';
 import type { PageConfigRuntime, PageConfigGlobalRuntime } from '../../types/PageConfig.js';
-declare function parseVirtualFileExports(virtualFileExports: unknown): {
+declare function parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry: unknown): {
     pageFilesAll: PageFile[];
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;

package/dist/esm/shared/getPageFiles/{parseVirtualFileExports.js → parseVirtualFileExportsGlobalEntry.js}

@@ -1,33 +1,27 @@
-export { parseVirtualFileExports };
-// TODO/now: rename parseVirtualFileExportsEntryGlobal
-// TODO/now: merge or collocate following both files?
-// ```filesystem
-// vike/packages/vike/shared/getPageFiles/parseVirtualFileExports.ts
-// vike/shared/page-configs/serialize/parsePageConfigs.ts
-// ```
+export { parseVirtualFileExportsGlobalEntry };
 // TO-DO/next-major-release: remove old design code, and remove all assertions.
 import { assert, hasProp, isCallable, isObject, cast, isArray } from '../utils.js';
 import { assertExportValues } from './assert_exports_old_design.js';
 import { getPageFileObject } from './getPageFileObject.js';
 import { fileTypes } from './fileTypes.js';
-import { parsePageConfigs } from '../page-configs/serialize/parsePageConfigs.js';
-function parseVirtualFileExports(virtualFileExports) {
-    assert(hasProp(virtualFileExports, 'pageFilesLazy', 'object'));
-    assert(hasProp(virtualFileExports, 'pageFilesEager', 'object'));
-    assert(hasProp(virtualFileExports, 'pageFilesExportNamesLazy', 'object'));
-    assert(hasProp(virtualFileExports, 'pageFilesExportNamesEager', 'object'));
-    assert(hasProp(virtualFileExports.pageFilesLazy, '.page'));
-    assert(hasProp(virtualFileExports.pageFilesLazy, '.page.client') ||
-        hasProp(virtualFileExports.pageFilesLazy, '.page.server'));
-    assert(hasProp(virtualFileExports, 'pageFilesList', 'string[]'));
-    assert(hasProp(virtualFileExports, 'pageConfigsSerialized'));
-    assert(hasProp(virtualFileExports, 'pageConfigGlobalSerialized'));
-    const { pageConfigsSerialized, pageConfigGlobalSerialized } = virtualFileExports;
+import { parsePageConfigsSerialized } from '../page-configs/serialize/parsePageConfigsSerialized.js';
+function parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry) {
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesLazy', 'object'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesEager', 'object'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesExportNamesLazy', 'object'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesExportNamesEager', 'object'));
+    assert(hasProp(virtualFileExportsGlobalEntry.pageFilesLazy, '.page'));
+    assert(hasProp(virtualFileExportsGlobalEntry.pageFilesLazy, '.page.client') ||
+        hasProp(virtualFileExportsGlobalEntry.pageFilesLazy, '.page.server'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageFilesList', 'string[]'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageConfigsSerialized'));
+    assert(hasProp(virtualFileExportsGlobalEntry, 'pageConfigGlobalSerialized'));
+    const { pageConfigsSerialized, pageConfigGlobalSerialized } = virtualFileExportsGlobalEntry;
     assertPageConfigsSerialized(pageConfigsSerialized);
     assertPageConfigGlobalSerialized(pageConfigGlobalSerialized);
-    const { pageConfigs, pageConfigGlobal } = parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized);
+    const { pageConfigs, pageConfigGlobal } = parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized);
     const pageFilesMap = {};
-    parseGlobResult(virtualFileExports.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExportsGlobalEntry.pageFilesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const loadModule = globValue;
         assertLoadModule(loadModule);
@@ -38,7 +32,7 @@ function parseVirtualFileExports(virtualFileExports) {
             }
         };
     });
-    parseGlobResult(virtualFileExports.pageFilesExportNamesLazy).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExportsGlobalEntry.pageFilesExportNamesLazy).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const loadModule = globValue;
         assertLoadModule(loadModule);
@@ -51,20 +45,20 @@ function parseVirtualFileExports(virtualFileExports) {
         };
     });
     // `pageFilesEager` contains `.page.route.js` files
-    parseGlobResult(virtualFileExports.pageFilesEager).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExportsGlobalEntry.pageFilesEager).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const moduleExports = globValue;
         assert(isObject(moduleExports));
         pageFile.fileExports = moduleExports;
     });
-    parseGlobResult(virtualFileExports.pageFilesExportNamesEager).forEach(({ filePath, pageFile, globValue }) => {
+    parseGlobResult(virtualFileExportsGlobalEntry.pageFilesExportNamesEager).forEach(({ filePath, pageFile, globValue }) => {
         pageFile = pageFilesMap[filePath] = pageFilesMap[filePath] ?? pageFile;
         const moduleExports = globValue;
         assert(isObject(moduleExports));
         assert(hasProp(moduleExports, 'exportNames', 'string[]'), pageFile.filePath);
         pageFile.exportNames = moduleExports.exportNames;
     });
-    virtualFileExports.pageFilesList.forEach((filePath) => {
+    virtualFileExportsGlobalEntry.pageFilesList.forEach((filePath) => {
         pageFilesMap[filePath] = pageFilesMap[filePath] ?? getPageFileObject(filePath);
     });
     const pageFilesAll = Object.values(pageFilesMap);

package/dist/esm/shared/getPageFiles.d.ts

@@ -1,4 +1,4 @@
 export type { PageFile } from './getPageFiles/getPageFileObject.js';
-export type { ExportsAll, VikeConfigPublicPageLazy } from './page-configs/resolveVikeConfigPublic.js';
+export type { ExportsAll, VikeConfigPublicPageLazyLoaded } from './page-configs/resolveVikeConfigPublic.js';
 export { getPageFilesClientSide } from './getPageFiles/getAllPageIdFiles.js';
 export { getPageFilesServerSide } from './getPageFiles/getAllPageIdFiles.js';

package/dist/esm/shared/hooks/execHook.d.ts

@@ -11,14 +11,14 @@ export { isUserHookError };
 export type { PageContextExecHook };
 import type { PageContextClient, PageContextServer } from '../../types/PageContext.js';
 import type { Hook, HookLoc } from './getHook.js';
-import type { VikeConfigPublicPageLazy } from '../getPageFiles.js';
+import type { VikeConfigPublicPageLazyLoaded } from '../getPageFiles.js';
 import type { HookName, HookNameGlobal } from '../../types/Config.js';
 import type { PageConfigGlobalRuntime } from '../../types/PageConfig.js';
 import type { PageContextForPublicUsageServer } from '../../node/runtime/renderPage/preparePageContextForPublicUsageServer.js';
 import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
 import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
 import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
-type PageContextExecHook = VikeConfigPublicPageLazy & PageContextForPublicUsage;
+type PageContextExecHook = VikeConfigPublicPageLazyLoaded & PageContextForPublicUsage;
 type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
 type HookWithResult = Hook & {
     hookReturn: unknown;

package/dist/esm/shared/hooks/getHook.d.ts

@@ -9,7 +9,7 @@ export type { HookLoc };
 export type { HookTimeout };
 export type { HooksTimeoutProvidedByUser };
 export { getHookTimeoutDefault };
-import type { VikeConfigPublicPageLazy } from '../getPageFiles.js';
+import type { VikeConfigPublicPageLazyLoaded } from '../getPageFiles.js';
 import type { HookNameOld, HookNamePage, HookNameGlobal, HookName } from '../../types/Config.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../../types/PageConfig.js';
 import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
@@ -28,8 +28,8 @@ type HookTimeout = {
     warning: number | false;
 };
 type HooksTimeoutProvidedByUser = false | Partial<Record<HookNameOld, false | Partial<HookTimeout>>>;
-declare function getHookFromPageContext(pageContext: VikeConfigPublicPageLazy, hookName: HookNameOld): null | Hook;
-declare function getHookFromPageContextNew(hookName: HookName, pageContext: VikeConfigPublicPageLazy): Hook[];
+declare function getHookFromPageContext(pageContext: VikeConfigPublicPageLazyLoaded, hookName: HookNameOld): null | Hook;
+declare function getHookFromPageContextNew(hookName: HookName, pageContext: VikeConfigPublicPageLazyLoaded): Hook[];
 declare function getHookFromPageConfig(pageConfig: PageConfigRuntime, hookName: HookNamePage): null | Hook;
 declare function getHookFromPageConfigGlobal(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): null | Hook;
 declare function getHookFromPageConfigGlobalCumulative(pageConfigGlobal: PageConfigGlobalRuntime, hookName: HookNameGlobal): Hook[];

package/dist/esm/shared/page-configs/loadAndParseVirtualFilePageEntry.d.ts

@@ -0,0 +1,3 @@
+export { loadAndParseVirtualFilePageEntry };
+import type { PageConfigRuntime, PageConfigRuntimeLoaded } from '../../types/PageConfig.js';
+declare function loadAndParseVirtualFilePageEntry(pageConfig: PageConfigRuntime, isDev: boolean): Promise<PageConfigRuntimeLoaded>;

package/dist/esm/shared/page-configs/loadAndParseVirtualFilePageEntry.js

@@ -0,0 +1,23 @@
+export { loadAndParseVirtualFilePageEntry };
+import { assert, objectAssign } from '../utils.js';
+import { parseConfigValuesSerialized } from './serialize/parsePageConfigsSerialized.js';
+async function loadAndParseVirtualFilePageEntry(pageConfig, isDev) {
+    if ('isPageEntryLoaded' in pageConfig &&
+        // We don't need to cache in dev, since Vite already caches the virtual module
+        !isDev) {
+        return pageConfig;
+    }
+    const { moduleId, moduleExportsPromise } = pageConfig.loadVirtualFilePageEntry();
+    const virtualFileExportsPageEntry = await moduleExportsPromise;
+    // `configValuesLoaded` is sometimes `undefined` https://github.com/vikejs/vike/discussions/2092
+    if (!virtualFileExportsPageEntry)
+        assert(false, { moduleExportsPromise, virtualFileExportsPageEntry, moduleId });
+    const configValues = parseVirtualFileExportsPageEntry(virtualFileExportsPageEntry);
+    Object.assign(pageConfig.configValues, configValues);
+    objectAssign(pageConfig, { isPageEntryLoaded: true });
+    return pageConfig;
+}
+function parseVirtualFileExportsPageEntry(virtualFileExportsPageEntry) {
+    const configValues = parseConfigValuesSerialized(virtualFileExportsPageEntry.configValuesSerialized);
+    return configValues;
+}