vike 0.4.236-commit-eab75f6 → 0.4.237-commit-85e89b1

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

@@ -8,10 +8,9 @@ export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
-export { isOverridden };
 // 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, } from '../utils.js';
+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 { configDefinitionsBuiltIn, } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect, } from './resolveVikeConfigInternal/filesystemRouting.js';
 import { getViteDevServer } from '../../runtime/globalContext.js';
@@ -23,7 +22,7 @@ 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';
@@ -179,7 +178,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,
@@ -287,15 +286,16 @@ function getPageConfigsBuildTime(configDefinitionsResolved, plusFilesAll, userRo
         applyEffectsMetaEnv(configValueSources, configDefinitionsLocal);
         applyEffectsConfVal(configValueSources, configDefinitionsLocal, plusFilesAll);
         sortConfigValueSources(configValueSources, locationId);
-        const configValuesComputed = getComputed(configValueSources, configDefinitionsLocal);
         const pageConfig = {
             pageId: locationId,
             ...pageConfigRoute,
             configDefinitions: configDefinitionsLocal,
             plusFiles: plusFilesRelevant,
             configValueSources,
-            configValuesComputed,
         };
+        const configValuesComputed = getComputed(pageConfig);
+        objectAssign(pageConfig, { configValuesComputed });
+        checkType(pageConfig);
         return pageConfig;
     });
     assertPageConfigs(pageConfigs);
@@ -362,7 +362,7 @@ function assertOnBeforeRenderEnv(pageConfig) {
 }
 function getConfigValues(pageConfig, tolerateMissingValue) {
     const configValues = {};
-    getConfigValuesBase(pageConfig, (configEnv) => !!configEnv.config, null).forEach((entry) => {
+    getConfigValuesBase(pageConfig, { isForConfig: true }, null).forEach((entry) => {
         if (entry.configValueBase.type === 'computed') {
             assert('value' in entry); // Help TS
             const { configValueBase, value, configName } = entry;
@@ -896,12 +896,12 @@ function applyEffectMetaEnv(configModFromEffect, configValueSources, configDefEf
         });
     });
 }
-function getComputed(configValueSources, configDefinitions) {
+function getComputed(pageConfig) {
     const configValuesComputed = {};
-    objectEntries(configDefinitions).forEach(([configName, configDef]) => {
+    objectEntries(pageConfig.configDefinitions).forEach(([configName, configDef]) => {
         if (!configDef._computed)
             return;
-        const value = configDef._computed(configValueSources);
+        const value = configDef._computed(pageConfig);
         if (value === undefined)
             return;
         configValuesComputed[configName] = {
@@ -1097,17 +1097,6 @@ function isGlobalLocation(locationId, plusFilesAll) {
         .map(([locationId]) => locationId);
     return locationIdsPage.every((locId) => isInherited(locationId, locId));
 }
-function isOverridden(source, configName, pageConfig) {
-    const configDef = pageConfig.configDefinitions[configName];
-    assert(configDef);
-    if (configDef.cumulative)
-        return false;
-    const sources = pageConfig.configValueSources[configName];
-    assert(sources);
-    const idx = sources.indexOf(source);
-    assert(idx >= 0);
-    return idx > 0;
-}
 function resolvePrerenderContext(vikeConfig) {
     const { isPrerenderingEnabled, isPrerenderingEnabledForAllPages } = resolvePrerenderConfigGlobal(vikeConfig);
     prerenderContext ?? (prerenderContext = {

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

@@ -9,7 +9,7 @@ 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[];
 }, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
@@ -20,7 +20,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 +33,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 +46,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 +59,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,16 +1,28 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
-import { changeEnumerable, objectAssign, objectReplace, unique } from './utils.js';
-import { parseVirtualFileExports } from './getPageFiles/parseVirtualFileExports.js';
-import { resolveVikeConfigPublicGlobal, resolveVikeConfigPublicPageEager, } from './page-configs/resolveVikeConfigPublic.js';
+import { changeEnumerable, genPromise, getGlobalObject, 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.";
-async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext, 
+const globalObject_ = getGlobalObject('shared/createGlobalContextShared.ts', {});
+// TO-DO/eventually use flat globalContext — like flat pageContext
+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 globalContext = createGlobalContextBase(virtualFileExports);
+    const { previousCallPromise } = globalObject_;
+    const { promise, resolve } = genPromise({
+        // Avoid this Cloudflare Worker error:
+        // ```console
+        // Error: Disallowed operation called within global scope. Asynchronous I/O (ex: fetch() or connect()), setting a timeout, and generating random values are not allowed within global scope. To fix this error, perform this operation within a handler.
+        // ```
+        timeout: null,
+    });
+    globalObject_.previousCallPromise = promise;
+    await previousCallPromise;
+    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.
@@ -22,7 +34,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);
@@ -52,10 +64,11 @@ addGlobalContextTmp, addGlobalContextAsync) {
             objectAssign(globalObject.globalContext, globalContext, true);
         }
     }
+    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.
@@ -64,7 +77,7 @@ function createGlobalContextBase(virtualFileExports) {
          */
         isGlobalContext: true,
         _isOriginalObject: true,
-        _virtualFileExports: virtualFileExports,
+        _virtualFileExportsGlobalEntry: virtualFileExportsGlobalEntry,
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
@@ -76,14 +89,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/modifyUrlSameOrigin.d.ts

@@ -5,5 +5,5 @@ type ModifyUrlSameOriginOptions = {
     search?: Search | null;
     pathname?: string;
 };
-type Search = Record<string, string | null> | URLSearchParams;
+type Search = Record<string, string | null | undefined> | URLSearchParams;
 declare function modifyUrlSameOrigin(url: string, modify: ModifyUrlSameOriginOptions): string;

package/dist/esm/shared/modifyUrlSameOrigin.js

@@ -1,4 +1,6 @@
 export { modifyUrlSameOrigin };
+// We don't move modifyUrlSameOrigin() to the modifyUrl.ts file because we plan to use modifyUrlSameOrigin() on the client-side:
+// https://github.com/vikejs/vike/blob/c5a2de5e85262771f97851767c00ac35da69c64b/packages/vike/client/runtime-client-routing/navigate.ts#L4
 import { createUrlFromComponents, isNotNullish_keyVal, parseUrl, objectFilter, assertUsageUrlPathnameAbsolute, } from './utils.js';
 function modifyUrlSameOrigin(url, modify) {
     const urlParsed = parseUrl(url, '/');
@@ -25,16 +27,19 @@ function modifyUrlSameOrigin(url, modify) {
     const urlModified = createUrlFromComponents(urlParsed.origin, pathname, search, hash);
     return urlModified;
 }
-function resolveSearch(urlParsed, search) {
+function resolveSearch(urlParsed, modifySearch) {
     let searchParams;
-    if (search instanceof URLSearchParams) {
+    if (modifySearch instanceof URLSearchParams) {
         // Overwrite
-        searchParams = search;
+        searchParams = modifySearch;
     }
     else {
         // Merge
-        const searchMap = objectFilter({ ...urlParsed.search, ...search }, (isNotNullish_keyVal));
+        const searchMap = objectFilter({ ...urlParsed.search, ...objectFilter(modifySearch, isNotUndefined) }, (isNotNullish_keyVal));
         searchParams = new URLSearchParams(searchMap);
     }
     return '?' + searchParams.toString();
 }
+function isNotUndefined(arg) {
+    return arg[1] !== undefined;
+}

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

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

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

@@ -0,0 +1,23 @@
+export { loadPageEntry };
+import { assert, objectAssign } from '../utils.js';
+import { parseConfigValuesSerialized } from './serialize/parsePageConfigsSerialized.js';
+async function loadPageEntry(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;
+}

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

@@ -1,9 +1,9 @@
 export { resolveVikeConfigPublicGlobal };
-export { resolveVikeConfigPublicPageEager };
-export { resolveVikeConfigPublicPageLazy };
+export { resolveVikeConfigPublicPageEagerLoaded };
+export { resolveVikeConfigPublicPageLazyLoaded };
 export type { VikeConfigPublicGlobal };
-export type { VikeConfigPublicPageEager };
-export type { VikeConfigPublicPageLazy };
+export type { VikeConfigPublicPageEagerLoaded };
+export type { VikeConfigPublicPageLazyLoaded };
 export type { Source };
 export type { Sources };
 export type { From };
@@ -35,7 +35,7 @@ type ConfigEntries = Record<string, {
     configDefinedAt: ConfigDefinedAtOptional;
     configDefinedByFile: string | null;
 }[]>;
-type VikeConfigPublicPageLazy = {
+type VikeConfigPublicPageLazyLoaded = {
     config: ConfigResolved;
     source: Source;
     sources: Sources;
@@ -90,12 +90,12 @@ type WithRoute = {
     route?: undefined;
     isErrorPage: true;
 };
-type VikeConfigPublicPageEager = VikeConfigPublic & WithRoute;
+type VikeConfigPublicPageEagerLoaded = VikeConfigPublic & WithRoute;
 type VikeConfigPublicGlobal = VikeConfigPublic;
-declare function resolveVikeConfigPublicPageEager(pageConfigGlobalValues: ConfigValues, pageConfig: PageConfigRuntime | PageConfigBuildTime, pageConfigValues: ConfigValues): [string, VikeConfigPublicPageEager];
+declare function resolveVikeConfigPublicPageEagerLoaded(pageConfigGlobalValues: ConfigValues, pageConfig: PageConfigRuntime | PageConfigBuildTime, pageConfigValues: ConfigValues): [string, VikeConfigPublicPageEagerLoaded];
 declare function resolveVikeConfigPublicGlobal({ pageConfigGlobalValues, }: {
     pageConfigGlobalValues: ConfigValues;
 }): VikeConfigPublicGlobal;
-declare function resolveVikeConfigPublicPageLazy(pageFiles: PageFile[], // V0.4 design
+declare function resolveVikeConfigPublicPageLazyLoaded(pageFiles: PageFile[], // V0.4 design
 pageConfig: PageConfigRuntimeLoaded | null, // V1 design
-pageConfigGlobal: PageConfigGlobalRuntime): VikeConfigPublicPageLazy;
+pageConfigGlobal: PageConfigGlobalRuntime): VikeConfigPublicPageLazyLoaded;

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

@@ -1,14 +1,14 @@
 // TO-DO/soon/same-api: use public API internally?
 // TO-DO/soon/flat-pageContext: rename definedAt => definedBy
 export { resolveVikeConfigPublicGlobal };
-export { resolveVikeConfigPublicPageEager };
-export { resolveVikeConfigPublicPageLazy };
+export { resolveVikeConfigPublicPageEagerLoaded };
+export { resolveVikeConfigPublicPageLazyLoaded };
 import { assertDefaultExports, forbiddenDefaultExports } from '../getPageFiles/assert_exports_old_design.js';
 import { getConfigDefinedAtOptional, getDefinedAtString } from './getConfigDefinedAt.js';
 import { getConfigValueFilePathToShowToUser } from './helpers.js';
 import { assert, isObject, assertWarning, assertUsage, makeLast, isBrowser, isScriptFile, isTemplateFile, objectDefineProperty, } from '../utils.js';
 import pc from '@brillout/picocolors';
-function resolveVikeConfigPublicPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues) {
+function resolveVikeConfigPublicPageEagerLoaded(pageConfigGlobalValues, pageConfig, pageConfigValues) {
     const vikeConfigPublicPage_ = resolveVikeConfigPublic_base({ pageConfigGlobalValues, pageConfigValues });
     const vikeConfigPublicPage = getPublicCopy(vikeConfigPublicPage_);
     let page;
@@ -43,7 +43,7 @@ function resolveVikeConfigPublicGlobal({ pageConfigGlobalValues, }) {
     const vikeConfigPublicGlobal = resolveVikeConfigPublic_V1Design({ configValues: pageConfigGlobalValues });
     return getPublicCopy(vikeConfigPublicGlobal);
 }
-function resolveVikeConfigPublicPageLazy(pageFiles, // V0.4 design
+function resolveVikeConfigPublicPageLazyLoaded(pageFiles, // V0.4 design
 pageConfig, // V1 design
 pageConfigGlobal) {
     const config = {};

package/dist/esm/shared/page-configs/serialize/PageConfigSerialized.d.ts

@@ -7,7 +7,7 @@ import type { ConfigValueStandard, ConfigValueComputed, ConfigValueCumulative, P
 type PageConfigRuntimeSerialized = PageConfigCommon & {
     /** Config values that are serializable and loaded eagerly such as config.passToClient */
     configValuesSerialized: Record<string, ConfigValueSerialized>;
-    loadConfigLazy: PageConfigRuntime['loadConfigLazy'];
+    loadVirtualFilePageEntry: PageConfigRuntime['loadVirtualFilePageEntry'];
 };
 type PageConfigGlobalRuntimeSerialized = {
     configValuesSerialized: Record<string, ConfigValueSerialized>;

package/dist/esm/shared/page-configs/serialize/{parsePageConfigs.d.ts → parsePageConfigsSerialized.d.ts}

@@ -1,9 +1,9 @@
-export { parsePageConfigs };
+export { parsePageConfigsSerialized };
 export { parseConfigValuesSerialized };
 import type { ConfigValues, PageConfigRuntime, PageConfigGlobalRuntime } from '../../../types/PageConfig.js';
 import type { PageConfigGlobalRuntimeSerialized, PageConfigRuntimeSerialized } from './PageConfigSerialized.js';
 import type { ConfigValueSerialized } from './PageConfigSerialized.js';
-declare function parsePageConfigs(pageConfigsSerialized: PageConfigRuntimeSerialized[], pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized): {
+declare function parsePageConfigsSerialized(pageConfigsSerialized: PageConfigRuntimeSerialized[], pageConfigGlobalSerialized: PageConfigGlobalRuntimeSerialized): {
     pageConfigs: PageConfigRuntime[];
     pageConfigGlobal: PageConfigGlobalRuntime;
 };

package/dist/esm/shared/page-configs/serialize/{parsePageConfigs.js → parsePageConfigsSerialized.js}

@@ -1,10 +1,10 @@
-export { parsePageConfigs };
+export { parsePageConfigsSerialized };
 export { parseConfigValuesSerialized };
 import { assert, assertUsage, isCallable } from '../../utils.js';
 import { getConfigDefinedAt } from '../getConfigDefinedAt.js';
 import { parseTransform } from '@brillout/json-serializer/parse';
 import { assertPlusFileExport } from '../assertPlusFileExport.js';
-function parsePageConfigs(pageConfigsSerialized, pageConfigGlobalSerialized) {
+function parsePageConfigsSerialized(pageConfigsSerialized, pageConfigGlobalSerialized) {
     // pageConfigs
     const pageConfigs = pageConfigsSerialized.map((pageConfigSerialized) => {
         const configValues = parseConfigValuesSerialized(pageConfigSerialized.configValuesSerialized);

package/dist/esm/shared/page-configs/serialize/serializeConfigValues.d.ts

@@ -3,9 +3,10 @@ export { getConfigValuesBase };
 export { isJsonValue };
 export type { FilesEnv };
 import type { ConfigEnvInternal, ConfigValueSource, DefinedAt, PageConfigBuildTime, PageConfigGlobalBuildTime } from '../../../types/PageConfig.js';
-declare function serializeConfigValues(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, importStatements: string[], filesEnv: FilesEnv, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, tabspace: string, isEager: boolean | null): string[];
+import { type RuntimeEnv } from '../../../node/vite/plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
+declare function serializeConfigValues(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, importStatements: string[], filesEnv: FilesEnv, runtimeEnv: RuntimeEnv, tabspace: string, isEager: boolean | null): string[];
 declare function isJsonValue(value: unknown): boolean;
-declare function getConfigValuesBase(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, isEnvMatch: (configEnv: ConfigEnvInternal) => boolean, isEager: boolean | null): ConfigValuesBase;
+declare function getConfigValuesBase(pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime, runtimeEnv: RuntimeEnv, isEager: boolean | null): ConfigValuesBase;
 type ConfigValuesBase = ({
     configValueBase: {
         type: 'computed';