vike 0.4.238 → 0.4.239-commit-33e55d4

package/dist/esm/node/vite/plugins/pluginWorkaroundCssModuleHmr.js

@@ -2,12 +2,14 @@ export { pluginWorkaroundCssModuleHmr };
 function pluginWorkaroundCssModuleHmr() {
     return {
         name: 'vike:pluginWorkaroundCssModuleHmr',
-        handleHotUpdate(ctx) {
-            // prevent full reload due to non self-accepting css module.
-            // here only "?direct" module should be filtered out as it doesn't have a parent module.
-            if (ctx.file.includes('module.css')) {
-                return ctx.modules.filter((m) => !m.id?.includes('?direct'));
-            }
+        handleHotUpdate: {
+            handler(ctx) {
+                // prevent full reload due to non self-accepting css module.
+                // here only "?direct" module should be filtered out as it doesn't have a parent module.
+                if (ctx.file.includes('module.css')) {
+                    return ctx.modules.filter((m) => !m.id?.includes('?direct'));
+                }
+            },
         },
     };
 }

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

@@ -171,6 +171,9 @@ const configDefinitionsBuiltIn = {
         env: { config: true },
         global: true,
     },
+    csp: {
+        env: { server: true },
+    },
     injectScriptsAt: {
         env: { server: true },
     },

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

@@ -1,7 +1,7 @@
 export { crawlPlusFiles };
 export { isPlusFile };
 export { getPlusFileValueConfigName };
-import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsNotProductionRuntime, isVersionOrAbove, isScriptFile, scriptFileExtensionList, createDebugger, deepEqual, assertUsage, assertFilePathAbsoluteFilesystem, assertWarning, hasProp, isNotNullish, getGlobalObject, } from '../../utils.js';
+import { assertPosixPath, assert, scriptFileExtensionPattern, assertIsNotProductionRuntime, isVersionMatch, 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';
@@ -147,7 +147,7 @@ async function isGitNotUsable(userRootDir) {
         //    - We didn't bother test which is the earliest version that works.
         //  - Git 2.32.0 doesn't seem to work: https://github.com/vikejs/vike/discussions/1549
         //    - Maybe it's because of StackBlitz: looking at the release notes, Git 2.32.0 should be working.
-        if (!isVersionOrAbove(gitVersion, '2.43.1'))
+        if (!isVersionMatch(gitVersion, ['2.43.1']))
             return true;
     }
     // Is userRootDir inside a Git repository?

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

@@ -1,3 +1,5 @@
+export { getVikeConfig };
+export type { VikeConfig };
 export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
 export { getVikeConfigInternalSync };
@@ -9,11 +11,9 @@ 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 VikeConfigPublicPageEagerLoaded } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { type GlobalConfigPublic } 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';
@@ -28,13 +28,9 @@ type PrerenderContext = {
 } & ({
     [K in keyof PrerenderContextPublic]: null;
 } | PrerenderContextPublic);
-type VikeConfigInternal = {
+type VikeConfigInternal = GlobalConfigPublic & {
     _pageConfigs: PageConfigBuildTime[];
     _pageConfigGlobal: PageConfigGlobalBuildTime;
-    config: VikeConfigPublicGlobal['config'];
-    _from: VikeConfigPublicGlobal['_from'];
-    pages: Record<string, // pageId
-    VikeConfigPublicPageEagerLoaded>;
     _vikeConfigDependencies: Set<string>;
     prerenderContext: PrerenderContext;
 };

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

@@ -1,3 +1,5 @@
+// Public usage
+export { getVikeConfig };
 // Internal usage
 export { getVikeConfigInternal };
 export { getVikeConfigInternalOptional };
@@ -8,8 +10,6 @@ export { isV1Design };
 export { getConfVal };
 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, genPromise, checkType, objectAssign, getGlobalObject, } from '../utils.js';
 import { configDefinitionsBuiltIn, } from './resolveVikeConfigInternal/configDefinitionsBuiltIn.js';
 import { getLocationId, getFilesystemRouteString, getFilesystemRouteDefinedBy, isInherited, sortAfterInheritanceOrder, applyFilesystemRoutingRootEffect, } from './resolveVikeConfigInternal/filesystemRouting.js';
@@ -22,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, resolveVikeConfigPublicPageEagerLoaded, } from '../../../shared/page-configs/resolveVikeConfigPublic.js';
+import { resolveGlobalConfigPublic, } 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';
@@ -170,31 +170,26 @@ async function resolveVikeConfigInternal(userRootDir, vikeVitePluginOptions, esb
     // Backwards compatibility for vike(options) in vite.config.js
     temp_interopVikeVitePlugin(pageConfigGlobal, vikeVitePluginOptions, userRootDir);
     setCliAndApiOptions(pageConfigGlobal, configDefinitionsResolved);
-    // global
-    const pageConfigGlobalValues = getConfigValues(pageConfigGlobal);
-    const vikeConfigPublicGlobal = resolveVikeConfigPublicGlobal({ pageConfigGlobalValues });
-    // pages
-    const vikeConfigPublicPagesEager = objectFromEntries(pageConfigs.map((pageConfig) => {
-        const pageConfigValues = getConfigValues(pageConfig, true);
-        return resolveVikeConfigPublicPageEagerLoaded(pageConfigGlobalValues, pageConfig, pageConfigValues);
-    }));
+    const globalConfigPublic = resolveGlobalConfig(pageConfigGlobal, pageConfigs);
     const prerenderContext = resolvePrerenderContext({
-        config: vikeConfigPublicGlobal.config,
-        _from: vikeConfigPublicGlobal._from,
+        config: globalConfigPublic.config,
+        _from: globalConfigPublic._from,
         _pageConfigs: pageConfigs,
     });
     const vikeConfig = {
+        ...globalConfigPublic,
+        prerenderContext,
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
-        config: vikeConfigPublicGlobal.config,
-        _from: vikeConfigPublicGlobal._from,
-        pages: vikeConfigPublicPagesEager,
-        prerenderContext,
         _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
     };
     globalObject.vikeConfigSync = vikeConfig;
     return vikeConfig;
 }
+function resolveGlobalConfig(pageConfigGlobal, pageConfigs) {
+    const globalConfigPublic = resolveGlobalConfigPublic(pageConfigs, pageConfigGlobal, getConfigValues);
+    return globalConfigPublic;
+}
 async function resolveConfigDefinitions(plusFilesAll, userRootDir, esbuildCache) {
     const plusFilesAllOrdered = Object.values(plusFilesAll)
         .flat()
@@ -358,7 +353,8 @@ function assertOnBeforeRenderEnv(pageConfig) {
     // When using Server Routing, loading a onBeforeRender() hook on the client-side hasn't any effect (the Server Routing's client runtime never calls it); it unnecessarily bloats client bundle sizes
     assertUsage(!(onBeforeRenderEnv.client && !isClientRouting), `Page ${pageConfig.pageId} has an onBeforeRender() hook with env ${pc.cyan(JSON.stringify(onBeforeRenderEnv))} which doesn't make sense because the page is using Server Routing: onBeforeRender() can be run in the client only when using Client Routing.`);
 }
-function getConfigValues(pageConfig, tolerateMissingValue) {
+function getConfigValues(pageConfig, isGlobalConfig) {
+    const tolerateMissingValue = !isGlobalConfig;
     const configValues = {};
     getConfigValuesBase(pageConfig, { isForConfig: true }, null).forEach((entry) => {
         if (entry.configValueBase.type === 'computed') {
@@ -1125,11 +1121,15 @@ function restartViteDevServer() {
     removeSuperfluousViteLog_disable();
 }
 function getVikeConfigDummy(esbuildCache) {
-    const globalDummy = resolveVikeConfigPublicGlobal({ pageConfigGlobalValues: {} });
     const pageConfigsDummy = [];
+    const pageConfigGlobalDummy = {
+        configValueSources: {},
+        configDefinitions: {},
+    };
+    const globalConfigPublicDummy = resolveGlobalConfig(pageConfigGlobalDummy, pageConfigsDummy);
     const prerenderContextDummy = resolvePrerenderContext({
-        config: globalDummy.config,
-        _from: globalDummy._from,
+        config: globalConfigPublicDummy.config,
+        _from: globalConfigPublicDummy._from,
         _pageConfigs: pageConfigsDummy,
     });
     const vikeConfigDummy = {
@@ -1138,9 +1138,7 @@ function getVikeConfigDummy(esbuildCache) {
             configDefinitions: {},
             configValueSources: {},
         },
-        config: globalDummy.config,
-        _from: globalDummy._from,
-        pages: {},
+        ...globalConfigPublicDummy,
         prerenderContext: prerenderContextDummy,
         _vikeConfigDependencies: esbuildCache.vikeConfigDependencies,
     };

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

@@ -9,11 +9,49 @@ 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>>(virtualFileExportsGlobalEntry: unknown, globalObject: {
-    globalContext?: Record<string, unknown>;
+declare function createGlobalContextShared<GlobalContextAdded extends {}, GlobalContextAddedAsync extends {}>(virtualFileExportsGlobalEntry: unknown, globalObject: {
+    globalContext?: {};
     onCreateGlobalContextHooks?: Hook[];
     previousCreateGlobalContextPromise?: Promise<void>;
 }, addGlobalContext?: (globalContext: GlobalContextBase) => GlobalContextAdded, addGlobalContextTmp?: (globalContext: GlobalContextBase) => Promise<GlobalContextAdded>, addGlobalContextAsync?: (globalContext: GlobalContextBase) => Promise<GlobalContextAddedAsync>): Promise<{
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: {
+                config: import("../types/index.js").ConfigResolved;
+                _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
+        config: import("../types/index.js").ConfigResolved;
+        _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+        _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+        _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+    };
+    pages: {
+        [k: string]: {
+            config: import("../types/index.js").ConfigResolved;
+            _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
+    config: import("../types/index.js").ConfigResolved;
+    _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("./page-configs/resolveVikeConfigPublic.js").From;
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
      *
@@ -26,20 +64,48 @@ declare function createGlobalContextShared<GlobalContextAdded extends Record<str
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _vikeConfigPublicGlobal: {
+} & GlobalContextAdded & Awaited<GlobalContextAddedAsync>>;
+type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
+type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
+declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown): {
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: {
+                config: import("../types/index.js").ConfigResolved;
+                _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+                _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+                _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+            } & ({
+                route: import("../types/Config.js").Route;
+                isErrorPage?: undefined;
+            } | {
+                route?: undefined;
+                isErrorPage: true;
+            });
+        };
         config: import("../types/index.js").ConfigResolved;
         _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
         _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
         _from: import("./page-configs/resolveVikeConfigPublic.js").From;
     };
-    config: import("../types/index.js").ConfigResolved;
     pages: {
-        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
+        [k: string]: {
+            config: import("../types/index.js").ConfigResolved;
+            _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+            _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+            _from: import("./page-configs/resolveVikeConfigPublic.js").From;
+        } & ({
+            route: import("../types/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
     };
-} & GlobalContextAdded & GlobalContextAddedAsync>;
-type GlobalContextBasePublic = Pick<GlobalContextBase, 'config' | 'pages' | 'isGlobalContext'>;
-type GlobalContextBase = ReturnType<typeof createGlobalContextBase>;
-declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown): {
+    config: import("../types/index.js").ConfigResolved;
+    _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
+    _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
+    _from: import("./page-configs/resolveVikeConfigPublic.js").From;
     /**
      * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
      *
@@ -52,14 +118,4 @@ declare function createGlobalContextBase(virtualFileExportsGlobalEntry: unknown)
     _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("../types/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
-    _vikeConfigPublicGlobal: {
-        config: import("../types/index.js").ConfigResolved;
-        _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
-        _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
-        _from: import("./page-configs/resolveVikeConfigPublic.js").From;
-    };
-    config: import("../types/index.js").ConfigResolved;
-    pages: {
-        [k: string]: import("./page-configs/resolveVikeConfigPublic.js").VikeConfigPublicPageEagerLoaded;
-    };
 };

package/dist/esm/shared/createGlobalContextShared.js

@@ -2,7 +2,7 @@ export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
 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 { resolveGlobalContextConfig } from './page-configs/resolveVikeConfigPublic.js';
 import { execHookGlobal } from './hooks/execHook.js';
 import { prepareGlobalContextForPublicUsage } from './prepareGlobalContextForPublicUsage.js';
 import { getHookFromPageConfigGlobalCumulative } from './hooks/getHook.js';
@@ -70,7 +70,9 @@ addGlobalContextTmp, addGlobalContextAsync) {
     return globalObject.globalContext;
 }
 function createGlobalContextBase(virtualFileExportsGlobalEntry) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, vikeConfigPublicGlobal, vikeConfigPublicPagesEager, } = getConfigsAll(virtualFileExportsGlobalEntry);
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
+    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
+    const globalContextAddendum = resolveGlobalContextConfig(pageConfigs, pageConfigGlobal);
     const globalContext = {
         /**
          * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -84,31 +86,11 @@ function createGlobalContextBase(virtualFileExportsGlobalEntry) {
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
         _allPageIds: allPageIds,
-        _vikeConfigPublicGlobal: vikeConfigPublicGlobal,
-        config: vikeConfigPublicGlobal.config,
-        pages: vikeConfigPublicPagesEager,
+        ...globalContextAddendum,
     };
     changeEnumerable(globalContext, '_isOriginalObject', false);
     return globalContext;
 }
-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 resolveVikeConfigPublicPageEagerLoaded(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
-    }));
-    return {
-        pageFilesAll,
-        allPageIds,
-        pageConfigs,
-        pageConfigGlobal,
-        vikeConfigPublicGlobal,
-        vikeConfigPublicPagesEager,
-    };
-}
 function getAllPageIds(pageFilesAll, pageConfigs) {
     const fileIds = pageFilesAll.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
     const allPageIds = unique(fileIds);

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

@@ -1,13 +1,8 @@
 export { createPageContextShared };
 export { createPageContextObject };
-import type { VikeConfigPublicGlobal } from './page-configs/resolveVikeConfigPublic.js';
+import type { GlobalConfigPublic } from './page-configs/resolveVikeConfigPublic.js';
 import { type PageContextPrepareMinimum } from './preparePageContextForPublicUsage.js';
-declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, vikeConfigPublicGlobal: VikeConfigPublicGlobal): T & {
-    config: import("../types/index.js").ConfigResolved;
-    _source: import("./page-configs/resolveVikeConfigPublic.js").Source;
-    _sources: import("./page-configs/resolveVikeConfigPublic.js").Sources;
-    _from: import("./page-configs/resolveVikeConfigPublic.js").From;
-};
+declare function createPageContextShared<T extends PageContextPrepareMinimum>(pageContextCreated: T, globalConfigPublic: GlobalConfigPublic): T & GlobalConfigPublic;
 declare function createPageContextObject(): {
     _isOriginalObject: true;
     isPageContext: true;

package/dist/esm/shared/createPageContextShared.js

@@ -1,8 +1,8 @@
 export { createPageContextShared };
 export { createPageContextObject };
 import { changeEnumerable, objectAssign } from './utils.js';
-function createPageContextShared(pageContextCreated, vikeConfigPublicGlobal) {
-    objectAssign(pageContextCreated, vikeConfigPublicGlobal);
+function createPageContextShared(pageContextCreated, globalConfigPublic) {
+    objectAssign(pageContextCreated, globalConfigPublic);
     return pageContextCreated;
 }
 function createPageContextObject() {

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

@@ -1,4 +1,4 @@
 export type { PageFile } from './getPageFiles/getPageFileObject.js';
-export type { ExportsAll, VikeConfigPublicPageLazyLoaded } from './page-configs/resolveVikeConfigPublic.js';
+export type { ExportsAll, PageContextConfig } 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 { VikeConfigPublicPageLazyLoaded } from '../getPageFiles.js';
+import type { PageContextConfig } 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 = VikeConfigPublicPageLazyLoaded & PageContextForPublicUsage;
+type PageContextExecHook = PageContextConfig & 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 { VikeConfigPublicPageLazyLoaded } from '../getPageFiles.js';
+import type { PageContextConfig } 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: VikeConfigPublicPageLazyLoaded, hookName: HookNameOld): null | Hook;
-declare function getHookFromPageContextNew(hookName: HookName, pageContext: VikeConfigPublicPageLazyLoaded): Hook[];
+declare function getHookFromPageContext(pageContext: PageContextConfig, hookName: HookNameOld): null | Hook;
+declare function getHookFromPageContextNew(hookName: HookName, pageContext: PageContextConfig): 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/resolveVikeConfigPublic.d.ts

@@ -1,9 +1,8 @@
-export { resolveVikeConfigPublicGlobal };
-export { resolveVikeConfigPublicPageEagerLoaded };
-export { resolveVikeConfigPublicPageLazyLoaded };
-export type { VikeConfigPublicGlobal };
-export type { VikeConfigPublicPageEagerLoaded };
-export type { VikeConfigPublicPageLazyLoaded };
+export { resolveGlobalConfigPublic };
+export { resolvePageContextConfig };
+export { resolveGlobalContextConfig };
+export type { PageContextConfig };
+export type { GlobalConfigPublic };
 export type { Source };
 export type { Sources };
 export type { From };
@@ -11,9 +10,9 @@ export type { ExportsAll };
 export type { ConfigEntries };
 import type { FileType } from '../getPageFiles/fileTypes.js';
 import type { PageFile } from '../getPageFiles/getPageFileObject.js';
-import type { ConfigValues, PageConfigBuildTime, PageConfigGlobalRuntime, PageConfigRuntime, PageConfigRuntimeLoaded } from '../../types/PageConfig.js';
+import type { ConfigValues, PageConfigBuildTime, PageConfigGlobalBuildTime, PageConfigGlobalRuntime, PageConfigRuntime, PageConfigRuntimeLoaded } from '../../types/PageConfig.js';
 import { type ConfigDefinedAtOptional } from './getConfigDefinedAt.js';
-import type { ConfigResolved } from '../../types/Config/PageContextConfig.js';
+import type { ConfigResolved } from '../../types/Config/ConfigResolved.js';
 import type { Route } from '../../types/Config.js';
 type ExportsAll = Record<string, {
     exportValue: unknown;
@@ -35,17 +34,6 @@ type ConfigEntries = Record<string, {
     configDefinedAt: ConfigDefinedAtOptional;
     configDefinedByFile: string | null;
 }[]>;
-type VikeConfigPublicPageLazyLoaded = {
-    config: ConfigResolved;
-    source: Source;
-    sources: Sources;
-    from: From;
-    configEntries: ConfigEntries;
-    exports: Record<string, unknown>;
-    exportsAll: ExportsAll;
-    /** @deprecated */
-    pageExports: Record<string, unknown>;
-};
 type From = {
     configsStandard: Record<string, // configName
     SourceConfigsStandard>;
@@ -77,11 +65,34 @@ type SourceConfigsComputed = {
     definedAt: 'Vike';
     value: unknown;
 };
-type VikeConfigPublic = {
+type PageContextConfig = {
+    /** The page's configuration values.
+     *
+     * https://vike.dev/config
+     * https://vike.dev/pageContext#config
+     */
     config: ConfigResolved;
-    _source: Source;
-    _sources: Sources;
-    _from: From;
+    source: Source;
+    sources: Sources;
+    from: From;
+    /** The page's configuration, including the configs origin and overridden configs.
+     *
+     * https://vike.dev/config
+     */
+    configEntries: ConfigEntries;
+    /** Custom Exports/Hooks.
+     *
+     * https://vike.dev/exports
+     */
+    exports: Record<string, unknown>;
+    /**
+     * Same as `pageContext.exports` but cumulative.
+     *
+     * https://vike.dev/exports
+     */
+    exportsAll: ExportsAll;
+    /** @deprecated */
+    pageExports: Record<string, unknown>;
 };
 type WithRoute = {
     route: Route;
@@ -90,12 +101,61 @@ type WithRoute = {
     route?: undefined;
     isErrorPage: true;
 };
-type VikeConfigPublicPageEagerLoaded = VikeConfigPublic & WithRoute;
-type VikeConfigPublicGlobal = VikeConfigPublic;
-declare function resolveVikeConfigPublicPageEagerLoaded(pageConfigGlobalValues: ConfigValues, pageConfig: PageConfigRuntime | PageConfigBuildTime, pageConfigValues: ConfigValues): [string, VikeConfigPublicPageEagerLoaded];
-declare function resolveVikeConfigPublicGlobal({ pageConfigGlobalValues, }: {
-    pageConfigGlobalValues: ConfigValues;
-}): VikeConfigPublicGlobal;
-declare function resolveVikeConfigPublicPageLazyLoaded(pageFiles: PageFile[], // V0.4 design
+type PageConfigPublicWithRoute = ConfigPublic & WithRoute;
+type ConfigPublic = ReturnType<typeof getPublicCopy>;
+declare function getPublicCopy(configInternal: ReturnType<typeof resolveConfigPublic_V1Design>): {
+    config: ConfigResolved;
+    _source: Source;
+    _sources: Sources;
+    _from: From;
+};
+declare function resolvePageContextConfig(pageFiles: PageFile[], // V0.4 design
 pageConfig: PageConfigRuntimeLoaded | null, // V1 design
-pageConfigGlobal: PageConfigGlobalRuntime): VikeConfigPublicPageLazyLoaded;
+pageConfigGlobal: PageConfigGlobalRuntime): PageContextConfig;
+declare function resolveGlobalContextConfig(pageConfigs: PageConfigRuntime[], pageConfigGlobal: PageConfigGlobalRuntime): {
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: PageConfigPublicWithRoute;
+        };
+        config: ConfigResolved;
+        _source: Source;
+        _sources: Sources;
+        _from: From;
+    };
+    pages: {
+        [k: string]: PageConfigPublicWithRoute;
+    };
+    config: ConfigResolved;
+    _source: Source;
+    _sources: Sources;
+    _from: From;
+};
+type GlobalConfigPublic = Omit<ReturnType<typeof resolveGlobalConfigPublic>, '_globalConfigPublic'>;
+declare function resolveGlobalConfigPublic<PageConfig extends PageConfigRuntime | PageConfigBuildTime, PageConfigGlobal extends PageConfigGlobalRuntime | PageConfigGlobalBuildTime>(pageConfigs: PageConfig[], pageConfigGlobal: PageConfigGlobal, getConfigValues: (config: PageConfig | PageConfigGlobal, isGlobalConfig?: true) => ConfigValues): {
+    _globalConfigPublic: {
+        pages: {
+            [k: string]: PageConfigPublicWithRoute;
+        };
+        config: ConfigResolved;
+        _source: Source;
+        _sources: Sources;
+        _from: From;
+    };
+    pages: {
+        [k: string]: PageConfigPublicWithRoute;
+    };
+    config: ConfigResolved;
+    _source: Source;
+    _sources: Sources;
+    _from: From;
+};
+declare function resolveConfigPublic_V1Design(pageConfig: {
+    configValues: ConfigValues;
+}): {
+    config: ConfigResolved;
+    configEntries: ConfigEntries;
+    exportsAll: ExportsAll;
+    source: Source;
+    sources: Sources;
+    from: From;
+};