vike 0.4.236 → 0.4.237-commit-85e89b1

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

@@ -1,6 +1,7 @@
 export { configDefinitionsBuiltIn };
 import { assert, assertUsage } from '../../utils.js';
 import { getConfigDefinedAt } from '../../../../shared/page-configs/getConfigDefinedAt.js';
+import { getConfigValueSourcesRelevant } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
         env: { server: true },
@@ -95,6 +96,22 @@ const configDefinitionsBuiltIn = {
     meta: {
         env: { config: true },
     },
+    serverOnlyHooks: {
+        env: { client: true },
+        eager: true,
+        _computed: (pageConfig) => {
+            const sources = ['data', 'onBeforeRender', 'onCreatePageContext']
+                .map((hookName) => getConfigValueSourcesRelevant(hookName, {
+                isForClientSide: false,
+                // TO-DO/eventually/remove-server-router: let's eventually remove support for Server Routing
+                isClientRouting: true,
+            }, pageConfig))
+                .flat(1)
+                // Server-only
+                .filter((source) => !source.configEnv.client);
+            return sources.length > 0;
+        },
+    },
     // Whether the page loads:
     //  - Vike's client runtime
     //  - User's client hooks
@@ -102,7 +119,8 @@ const configDefinitionsBuiltIn = {
     isClientRuntimeLoaded: {
         env: { server: true, client: true },
         eager: true,
-        _computed: (configValueSources) => {
+        _computed: (pageConfig) => {
+            const { configValueSources } = pageConfig;
             {
                 const source = getConfigValueSource(configValueSources, 'clientHooks');
                 if (source) {
@@ -120,15 +138,25 @@ const configDefinitionsBuiltIn = {
                 !!getConfigEnv(configValueSources, 'Page')?.client);
         },
     },
+    // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks entries)
     onBeforeRenderEnv: {
         env: { client: true },
         eager: true,
-        _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender'),
+        _computed: (pageConfig) => {
+            const { configValueSources } = pageConfig;
+            return !isConfigSet(configValueSources, 'onBeforeRender')
+                ? null
+                : getConfigEnv(configValueSources, 'onBeforeRender');
+        },
     },
+    // TO-DO/soon/cumulative-hooks: remove and replace with new computed prop `clientOnlyHooks: string[]` (see other TO-DO/soon/cumulative-hooks entries)
     dataEnv: {
         env: { client: true },
         eager: true,
-        _computed: (configValueSources) => !isConfigSet(configValueSources, 'data') ? null : getConfigEnv(configValueSources, 'data'),
+        _computed: (pageConfig) => {
+            const { configValueSources } = pageConfig;
+            return !isConfigSet(configValueSources, 'data') ? null : getConfigEnv(configValueSources, 'data');
+        },
     },
     hooksTimeout: {
         env: { server: true, client: true },

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

@@ -30,9 +30,7 @@ async function crawlPlusFiles(userRootDir) {
         : // Fallback to tinyglobby for users that dynamically generate plus files. (Assuming that no plus file is found because of the user's .gitignore list.)
             filesGlob;
     assert(files);
-    if (debug.isActivated) {
-        assert(filesGit);
-        assert(filesGlob);
+    if (debug.isActivated && filesGit && filesGlob) {
         assertWarning(deepEqual(filesGlob.slice().sort(), filesGit.slice().sort()), "Git and glob results aren't matching.", { onlyOnce: false });
     }
     // Filter build files

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

@@ -7,13 +7,12 @@ export { isV1Design };
 export { getConfVal };
 export { getConfigDefinitionOptional };
 export { getVikeConfigFromCliOrEnv };
-export { isOverridden };
 export type { VikeConfigInternal };
 export { getVikeConfig };
 export type { VikeConfig };
-import type { PageConfigGlobalBuildTime, ConfigValueSource, PageConfigBuildTime } from '../../../types/PageConfig.js';
+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';
@@ -34,7 +33,7 @@ type VikeConfigInternal = {
     config: VikeConfigPublicGlobal['config'];
     _from: VikeConfigPublicGlobal['_from'];
     pages: Record<string, // pageId
-    VikeConfigPublicPageEager>;
+    VikeConfigPublicPageEagerLoaded>;
     _vikeConfigDependencies: Set<string>;
     prerenderContext: PrerenderContext;
 };
@@ -65,4 +64,3 @@ declare function getConfVal(plusFile: PlusFile, configName: string): null | {
 } | {
     valueIsLoaded: false;
 };
-declare function isOverridden(source: ConfigValueSource, configName: string, pageConfig: PageConfigBuildTime | PageConfigGlobalBuildTime): boolean;

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/node/vite/utils.d.ts

@@ -19,3 +19,4 @@ export * from '../../utils/isDocker.js';
 export * from '../../utils/isVitest.js';
 export * from '../../utils/rollupSourceMap.js';
 export * from '../../utils/isImportPath.js';
+export * from '../../utils/virtualFileId.js';

package/dist/esm/node/vite/utils.js

@@ -26,3 +26,4 @@ export * from '../../utils/isDocker.js';
 export * from '../../utils/isVitest.js';
 export * from '../../utils/rollupSourceMap.js';
 export * from '../../utils/isImportPath.js';
+export * from '../../utils/virtualFileId.js';

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

@@ -9,10 +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<GlobalContextAddendum 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[];
-}, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddendum>, addGlobalContextSync?: (globalContext: GlobalContextBase) => GlobalContextAddendum): Promise<{
+}, 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 +20,7 @@ declare function createGlobalContextShared<GlobalContextAddendum extends Record<
      */
     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<GlobalContextAddendum extends Record<
     };
     config: import("../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEager;
+        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
     };
-} & GlobalContextAddendum>;
+} & 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,31 +1,51 @@
 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, addGlobalContextAsync, addGlobalContextSync) {
-    const globalContext = createGlobalContextBase(virtualFileExports);
+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 { 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.
+        // - Required by vike-vercel
         globalObject.globalContext = globalContext;
         isNewGlobalContext = false;
     }
     else {
         isNewGlobalContext = true;
     }
-    if (addGlobalContextSync &&
-        // TODO/next-major-release: remove
+    if (addGlobalContext &&
+        // TO-DO/next-major-release: remove
         globalContext._pageConfigs.length > 0) {
-        const globalContextAddendum = addGlobalContextSync?.(globalContext);
-        objectAssign(globalContext, globalContextAddendum);
+        const globalContextAdded = addGlobalContext?.(globalContext);
+        objectAssign(globalContext, globalContextAdded);
     }
     else {
-        const globalContextAddendum = await addGlobalContextAsync?.(globalContext);
-        objectAssign(globalContext, globalContextAddendum);
+        const globalContextAdded = await addGlobalContextTmp?.(globalContext);
+        objectAssign(globalContext, globalContextAdded);
+    }
+    {
+        const globalContextAddedAsync = await addGlobalContextAsync?.(globalContext);
+        objectAssign(globalContext, globalContextAddedAsync);
     }
     const onCreateGlobalContextHooks = getHookFromPageConfigGlobalCumulative(globalContext._pageConfigGlobal, 'onCreateGlobalContext');
     let hooksCalled = false;
@@ -44,10 +64,11 @@ async function createGlobalContextShared(virtualFileExports, globalObject, addGl
             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.
@@ -56,7 +77,7 @@ function createGlobalContextBase(virtualFileExports) {
          */
         isGlobalContext: true,
         _isOriginalObject: true,
-        _virtualFileExports: virtualFileExports,
+        _virtualFileExportsGlobalEntry: virtualFileExportsGlobalEntry,
         _pageFilesAll: pageFilesAll,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
@@ -68,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,27 +1,27 @@
-export { parseVirtualFileExports };
+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);
@@ -32,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);
@@ -45,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;