vike 0.4.229-commit-845a4e0 → 0.4.229-commit-7056ef0

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

@@ -2,6 +2,8 @@ export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
 export type { GlobalContextShared };
 export type { GlobalContextSharedPublic };
+import type { PageFile } from './getPageFiles.js';
+import type { PageConfigRuntime } from './page-configs/PageConfig.js';
 declare const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
 declare function createGlobalContextShared<GlobalContextAddendum extends object>(virtualFileExports: unknown, globalObject: {
     globalContext?: Record<string, unknown>;
@@ -13,12 +15,21 @@ declare function createGlobalContextShared<GlobalContextAddendum extends object>
      */
     isGlobalContext: true;
     _virtualFileExports: unknown;
-    _pageFilesAll: import("./getPageFiles.js").PageFile[];
-    _pageConfigs: import("./page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("./page-configs/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
+    _userFriendlyConfigsGlobal: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
     config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
-    pages: import("./page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    pages: {
+        [k: string]: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
+            route: import("./page-configs/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
 } & Awaited<GlobalContextAddendum>>;
 type GlobalContextSharedPublic = Pick<GlobalContextShared, 'config' | 'pages' | 'isGlobalContext'>;
 type GlobalContextShared = ReturnType<typeof createGlobalContextBase>;
@@ -30,10 +41,19 @@ declare function createGlobalContextBase(virtualFileExports: unknown): {
      */
     isGlobalContext: true;
     _virtualFileExports: unknown;
-    _pageFilesAll: import("./getPageFiles.js").PageFile[];
-    _pageConfigs: import("./page-configs/PageConfig.js").PageConfigRuntime[];
+    _pageFilesAll: PageFile[];
+    _pageConfigs: PageConfigRuntime[];
     _pageConfigGlobal: import("./page-configs/PageConfig.js").PageConfigGlobalRuntime;
     _allPageIds: string[];
+    _userFriendlyConfigsGlobal: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly;
     config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
-    pages: import("./page-configs/getPageConfigUserFriendly.js").PageConfigsUserFriendly;
+    pages: {
+        [k: string]: import("./page-configs/getUserFriendlyConfigs.js").PageConfigUserFriendly & ({
+            route: import("./page-configs/Config.js").Route;
+            isErrorPage?: undefined;
+        } | {
+            route?: undefined;
+            isErrorPage: true;
+        });
+    };
 };

package/dist/esm/shared/createGlobalContextShared.js

@@ -1,9 +1,10 @@
 export { createGlobalContextShared };
 export { getGlobalContextSyncErrMsg };
+import { objectAssign, unique } from './utils.js';
+import { parseGlobResults } from './getPageFiles/parseGlobResults.js';
+import { getUserFriendlyConfigsGlobal, getUserFriendlyConfigsPageEager } from './page-configs/getUserFriendlyConfigs.js';
+import { executeHookGlobalCumulative } from './hooks/executeHook.js';
 const getGlobalContextSyncErrMsg = "The global context isn't set yet, call getGlobalContextSync() later or use getGlobalContext() instead.";
-import { getPageConfigsRuntime } from './getPageConfigsRuntime.js';
-import { executeHookGenericGlobalCumulative } from './hooks/executeHookGeneric.js';
-import { objectAssign } from './utils.js';
 async function createGlobalContextShared(virtualFileExports, globalObject, addGlobalContext) {
     const globalContext = createGlobalContextBase(virtualFileExports);
     const globalContextAddendum = await addGlobalContext?.(globalContext);
@@ -21,7 +22,7 @@ async function createGlobalContextShared(virtualFileExports, globalObject, addGl
         //      - globalContext._viteDevServer.hot.send()
         //        - Send 'full-server-reload' signal whenever a onCreateGlobalContext() function is modified => we need a globalObject to track all hooks and see if one of them is new/modified.
         //        - Seems less idiomatic
-        await executeHookGenericGlobalCumulative('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext);
+        await executeHookGlobalCumulative('onCreateGlobalContext', globalContext._pageConfigGlobal, null, globalContext);
     }
     else {
         // Singleton: ensure all `globalContext` user-land references are preserved & updated.
@@ -31,7 +32,7 @@ async function createGlobalContextShared(virtualFileExports, globalObject, addGl
     return globalObject.globalContext;
 }
 function createGlobalContextBase(virtualFileExports) {
-    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly } = getPageConfigsRuntime(virtualFileExports);
+    const { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, userFriendlyConfigsGlobal, userFriendlyConfigsPageEager } = getConfigsAll(virtualFileExports);
     const globalContext = {
         /**
          * Useful for distinguishing `globalContext` from other objects and narrowing down TypeScript unions.
@@ -44,8 +45,33 @@ function createGlobalContextBase(virtualFileExports) {
         _pageConfigs: pageConfigs,
         _pageConfigGlobal: pageConfigGlobal,
         _allPageIds: allPageIds,
-        config: globalConfig.config,
-        pages: pageConfigsUserFriendly
+        _userFriendlyConfigsGlobal: userFriendlyConfigsGlobal,
+        config: userFriendlyConfigsGlobal.config,
+        pages: userFriendlyConfigsPageEager
     };
     return globalContext;
 }
+function getConfigsAll(virtualFileExports) {
+    const { pageFilesAll, pageConfigs, pageConfigGlobal } = parseGlobResults(virtualFileExports);
+    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
+    const userFriendlyConfigsGlobal = getUserFriendlyConfigsGlobal({
+        pageConfigGlobalValues: pageConfigGlobal.configValues
+    });
+    const userFriendlyConfigsPageEager = Object.fromEntries(pageConfigs.map((pageConfig) => {
+        return getUserFriendlyConfigsPageEager(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
+    }));
+    return {
+        pageFilesAll,
+        allPageIds,
+        pageConfigs,
+        pageConfigGlobal,
+        userFriendlyConfigsGlobal,
+        userFriendlyConfigsPageEager
+    };
+}
+function getAllPageIds(pageFilesAll, pageConfigs) {
+    const fileIds = pageFilesAll.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
+    const allPageIds = unique(fileIds);
+    const allPageIds2 = pageConfigs.map((p) => p.pageId);
+    return [...allPageIds, ...allPageIds2];
+}

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

@@ -1,9 +1,6 @@
 export { createPageContextShared };
+import type { PageConfigUserFriendly } from './page-configs/getUserFriendlyConfigs.js';
 import type { PageConfigGlobalRuntime } from './page-configs/PageConfig.js';
-declare function createPageContextShared<T extends object>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime): Promise<T & {
-    config: import("./page-configs/Config/PageContextConfig.js").ConfigResolved;
-    _source: import("./page-configs/getPageConfigUserFriendly.js").Source;
-    _sources: import("./page-configs/getPageConfigUserFriendly.js").Sources;
-    _from: import("./page-configs/getPageConfigUserFriendly.js").From;
+declare function createPageContextShared<T extends object>(pageContextCreated: T, pageConfigGlobal: PageConfigGlobalRuntime, userFriendlyConfigsGlobal: PageConfigUserFriendly): Promise<T & {
     isPageContext: true;
-}>;
+} & PageConfigUserFriendly>;

package/dist/esm/shared/createPageContextShared.js

@@ -1,15 +1,9 @@
 export { createPageContextShared };
-import { executeHookGenericGlobalCumulative } from './hooks/executeHookGeneric.js';
-import { getPageConfigGlobalUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
+import { executeHookGlobalCumulative } from './hooks/executeHook.js';
 import { objectAssign } from './utils.js';
-async function createPageContextShared(pageContextCreated, pageConfigGlobal) {
-    const pageConfigGlobalUserFriendly = getPageConfigGlobalUserFriendly({
-        pageConfigGlobalValues: pageConfigGlobal.configValues
-    });
-    objectAssign(pageContextCreated, {
-        isPageContext: true,
-        ...pageConfigGlobalUserFriendly
-    }, true);
-    await executeHookGenericGlobalCumulative('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated);
+async function createPageContextShared(pageContextCreated, pageConfigGlobal, userFriendlyConfigsGlobal) {
+    objectAssign(pageContextCreated, { isPageContext: true }, true);
+    objectAssign(pageContextCreated, userFriendlyConfigsGlobal);
+    await executeHookGlobalCumulative('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated);
     return pageContextCreated;
 }

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

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

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

@@ -1,10 +1,23 @@
 export { executeHook };
+export { executeHookNew };
+export { executeHookGlobalCumulative };
 export { getPageContext };
 export { providePageContext };
 export { isUserHookError };
 import type { PageContextClient, PageContextServer } from '../types.js';
 import type { Hook, HookLoc } from './getHook.js';
-type PageContextUnknown = null | Record<string, any>;
+import type { PageConfigUserFriendlyOld } from '../getPageFiles.js';
+import type { HookName, HookNameGlobal } from '../page-configs/Config.js';
+import type { PageConfigGlobalRuntime } from '../page-configs/PageConfig.js';
+declare function executeHookNew<PageContext extends PageConfigUserFriendlyOld>(hookName: HookName, pageContext: PageContext, prepare: (pageContext: PageContext) => PageContext): Promise<{
+    hookResult: unknown;
+    hookName: import("../page-configs/Config.js").HookNameOld;
+    hookFilePath: string;
+    hookFn: (arg: object) => unknown;
+    hookTimeout: import("./getHook.js").HookTimeout;
+}[]>;
+declare function executeHookGlobalCumulative(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: PageContextUnknown | null, arg: object): Promise<void>;
+type PageContextUnknown = null | Record<string, unknown>;
 declare function isUserHookError(err: unknown): false | HookLoc;
 declare function executeHook<T = unknown>(hookFnCaller: () => T, hook: Omit<Hook, 'hookFn'>, pageContext: PageContextUnknown): Promise<T>;
 /**

package/dist/esm/shared/hooks/executeHook.js

@@ -1,4 +1,6 @@
 export { executeHook };
+export { executeHookNew };
+export { executeHookGlobalCumulative };
 export { getPageContext };
 export { providePageContext };
 export { isUserHookError };
@@ -6,10 +8,29 @@ import { getProjectError, assertWarning } from '../../utils/assert.js';
 import { getGlobalObject } from '../../utils/getGlobalObject.js';
 import { humanizeTime } from '../../utils/humanizeTime.js';
 import { isObject } from '../../utils/isObject.js';
+import { getHookFromPageConfigGlobalCumulative, getHookFromPageContextNew } from './getHook.js';
 const globalObject = getGlobalObject('utils/executeHook.ts', {
     userHookErrors: new WeakMap(),
     pageContext: null
 });
+// TO-DO/eventually: use this variant more prominently
+async function executeHookNew(hookName, pageContext, prepare) {
+    const hooks = getHookFromPageContextNew(hookName, pageContext);
+    if (!hooks.length)
+        return [];
+    const pageContextPrepared = prepare(pageContext);
+    const hooksWithResult = await Promise.all(hooks.map(async (hook) => {
+        const hookResult = await executeHook(() => hook.hookFn(pageContextPrepared), hook, pageContext);
+        return { ...hook, hookResult };
+    }));
+    return hooksWithResult;
+}
+async function executeHookGlobalCumulative(hookName, pageConfigGlobal, pageContext, arg) {
+    const hooks = getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName);
+    await Promise.all(hooks.map(async (hook) => {
+        await executeHook(() => hook.hookFn(arg), hook, pageContext);
+    }));
+}
 function isUserHookError(err) {
     if (!isObject(err))
         return false;

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

@@ -1,24 +1,23 @@
 export { getHookFromPageContext };
+export { getHookFromPageContextNew };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
 export { getHookFromPageConfigGlobalCumulative };
-export { assertHook };
 export { getHook_setIsPrerenderering };
 export type { Hook };
-export type { HookName };
 export type { HookLoc };
 export type { HookTimeout };
 export type { HooksTimeoutProvidedByUser };
 export { getHookTimeoutDefault };
 import type { PageConfigUserFriendlyOld } from '../getPageFiles.js';
-import type { HookName, HookNamePage, HookNameGlobal } from '../page-configs/Config.js';
+import type { HookNameOld, HookNamePage, HookNameGlobal, HookName } from '../page-configs/Config.js';
 import type { PageConfigGlobalRuntime, PageConfigRuntime } from '../page-configs/PageConfig.js';
 type Hook = HookLoc & {
     hookFn: HookFn;
     hookTimeout: HookTimeout;
 };
 type HookLoc = {
-    hookName: HookName;
+    hookName: HookNameOld;
     hookFilePath: string;
 };
 type HookFn = (arg: object) => unknown;
@@ -26,13 +25,11 @@ type HookTimeout = {
     error: number | false;
     warning: number | false;
 };
-type HooksTimeoutProvidedByUser = false | Partial<Record<HookName, false | Partial<HookTimeout>>>;
-declare function getHookFromPageContext(pageContext: PageConfigUserFriendlyOld, hookName: HookName): null | Hook;
+type HooksTimeoutProvidedByUser = false | Partial<Record<HookNameOld, false | Partial<HookTimeout>>>;
+declare function getHookFromPageContext(pageContext: PageConfigUserFriendlyOld, hookName: HookNameOld): null | Hook;
+declare function getHookFromPageContextNew(hookName: HookName, pageContext: PageConfigUserFriendlyOld): 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[];
-declare function assertHook<TPageContext extends PageConfigUserFriendlyOld, THookName extends PropertyKey & HookName>(pageContext: TPageContext, hookName: THookName): asserts pageContext is TPageContext & {
-    exports: Record<THookName, Function | undefined>;
-};
-declare function getHookTimeoutDefault(hookName: HookName): HookTimeout;
+declare function getHookTimeoutDefault(hookName: HookNameOld): HookTimeout;
 declare function getHook_setIsPrerenderering(): void;

package/dist/esm/shared/hooks/getHook.js

@@ -1,8 +1,8 @@
 export { getHookFromPageContext };
+export { getHookFromPageContextNew };
 export { getHookFromPageConfig };
 export { getHookFromPageConfigGlobal };
 export { getHookFromPageConfigGlobalCumulative };
-export { assertHook };
 export { getHook_setIsPrerenderering };
 // TODO/v1-release: remove
 // We export for old V0.4 design which doesn't support config.hooksTimeout
@@ -22,12 +22,34 @@ function getHookFromPageContext(pageContext, hookName) {
     const hookFn = pageContext.exports[hookName];
     if (hookFn === null)
         return null;
+    // TO-DO/eventually: use pageContext.configEntries in favor of pageContext.exportsAll once V0.4 is removed
     const file = pageContext.exportsAll[hookName][0];
     assert(file.exportValue === hookFn);
     const hookFilePath = file.filePath;
     assert(hookFilePath);
     return getHook(hookFn, hookName, hookFilePath, hookTimeout);
 }
+// TO-DO/eventually: remove getHookFromPageContext() in favor of getHookFromPageContextNew()
+function getHookFromPageContextNew(hookName, pageContext) {
+    const { hooksTimeout } = pageContext.config;
+    const hookTimeout = getHookTimeout(hooksTimeout, hookName);
+    const hooks = [];
+    /* TO-DO/eventually: use pageContext.configEntries in favor of pageContext.exportsAll once V0.4 is removed
+    pageContext.configEntries[hookName]?.forEach((val) => {
+      const hookFn = val.configValue
+      if (hookFn === null) return
+      const hookFilePath = val.configDefinedByFile
+    */
+    pageContext.exportsAll[hookName]?.forEach((val) => {
+        const hookFn = val.exportValue;
+        if (hookFn === null)
+            return;
+        const hookFilePath = val.filePath;
+        assert(hookFilePath);
+        hooks.push(getHook(hookFn, hookName, hookFilePath, hookTimeout));
+    });
+    return hooks;
+}
 function getHookFromPageConfig(pageConfig, hookName) {
     const configValue = getConfigValueRuntime(pageConfig, hookName);
     if (!configValue?.value)
@@ -76,9 +98,6 @@ function getHookFromConfigValue(configValue) {
     const hookFilePath = getHookFilePathToShowToUser(configValue.definedAtData);
     return { hookFn, hookFilePath };
 }
-function assertHook(pageContext, hookName) {
-    getHookFromPageContext(pageContext, hookName);
-}
 function assertHookFn(hookFn, { hookName, hookFilePath }) {
     assert(hookName && hookFilePath);
     assert(!hookName.endsWith(')'));

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

@@ -5,6 +5,7 @@ export type { ConfigNameBuiltIn };
 export type { ConfigNameGlobal };
 export type { ConfigMeta };
 export type { HookName };
+export type { HookNameOld };
 export type { HookNamePage };
 export type { HookNameGlobal };
 export type { ImportString };
@@ -43,10 +44,11 @@ import type { Vike, VikePackages } from '../VikeNamespace.js';
 import type { HooksTimeoutProvidedByUser } from '../hooks/getHook.js';
 import type { GlobalContext, PageContextClient, PageContextServer } from '../types.js';
 import type { InlineConfig } from 'vite';
-type HookName = HookNamePage | HookNameGlobal | HookNameOldDesign;
+type HookNameOld = HookName | HookNameOldDesign;
+type HookName = HookNamePage | HookNameGlobal;
 type HookNamePage = 'onHydrationEnd' | 'onBeforePrerenderStart' | 'onBeforeRender' | 'onPageTransitionStart' | 'onPageTransitionEnd' | 'onRenderHtml' | 'onRenderClient' | 'guard' | 'data' | 'onData';
 type HookNameGlobal = 'onBeforePrerender' | 'onBeforeRoute' | 'onPrerenderStart' | 'onCreatePageContext' | 'onCreateGlobalContext';
-type HookNameOldDesign = 'render' | 'prerender';
+type HookNameOldDesign = 'render' | 'prerender' | 'onBeforePrerender';
 type ConfigNameBuiltIn = Exclude<keyof Config, keyof VikeVitePluginOptions | 'onBeforeRoute' | 'onPrerenderStart' | 'vite' | 'redirects'> | 'prerender' | 'isClientRuntimeLoaded' | 'onBeforeRenderEnv' | 'dataEnv' | 'hooksTimeout' | 'clientHooks' | 'middleware';
 type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization' | 'vite';
 type Config = ConfigBuiltIn & Vike.Config & (VikePackages.ConfigVikeReact | VikePackages.ConfigVikeVue | VikePackages.ConfigVikeSolid | VikePackages.ConfigVikeSvelte | VikePackages.ConfigVikeAngular);

package/dist/esm/shared/page-configs/{getPageConfigUserFriendly.d.ts → getUserFriendlyConfigs.d.ts}

@@ -1,6 +1,6 @@
-export { getPageConfigUserFriendly };
-export { getPageConfigUserFriendly_oldDesign };
-export { getPageConfigGlobalUserFriendly };
+export { getUserFriendlyConfigsGlobal };
+export { getUserFriendlyConfigsPageEager };
+export { getUserFriendlyConfigsPageLazy };
 export type { PageConfigsUserFriendly };
 export type { PageConfigUserFriendly };
 export type { PageConfigUserFriendlyOld };
@@ -92,8 +92,10 @@ type WithRoute = {
     isErrorPage: true;
 };
 type PageConfigUserFriendlyWithRoute = PageConfigUserFriendly & WithRoute;
-declare function getPageConfigUserFriendly(pageConfigGlobalValues: ConfigValues, pageConfig: PageConfigRuntime | PageConfigBuildTime, pageConfigValues: ConfigValues): [string, PageConfigUserFriendlyWithRoute];
-declare function getPageConfigGlobalUserFriendly({ pageConfigGlobalValues }: {
+declare function getUserFriendlyConfigsPageEager(pageConfigGlobalValues: ConfigValues, pageConfig: PageConfigRuntime | PageConfigBuildTime, pageConfigValues: ConfigValues): [string, PageConfigUserFriendlyWithRoute];
+declare function getUserFriendlyConfigsGlobal({ pageConfigGlobalValues }: {
     pageConfigGlobalValues: ConfigValues;
 }): PageConfigUserFriendly;
-declare function getPageConfigUserFriendly_oldDesign(pageFiles: PageFile[], pageConfig: PageConfigRuntimeLoaded | null, pageConfigGlobal: PageConfigGlobalRuntime): PageConfigUserFriendlyOld;
+declare function getUserFriendlyConfigsPageLazy(pageFiles: PageFile[], // V0.4 design
+pageConfig: PageConfigRuntimeLoaded | null, // V1 design
+pageConfigGlobal: PageConfigGlobalRuntime): PageConfigUserFriendlyOld;

package/dist/esm/shared/page-configs/{getPageConfigUserFriendly.js → getUserFriendlyConfigs.js}

@@ -1,13 +1,13 @@
-export { getPageConfigUserFriendly };
-export { getPageConfigUserFriendly_oldDesign };
-export { getPageConfigGlobalUserFriendly };
+export { getUserFriendlyConfigsGlobal };
+export { getUserFriendlyConfigsPageEager };
+export { getUserFriendlyConfigsPageLazy };
 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 } from '../utils.js';
 import pc from '@brillout/picocolors';
-function getPageConfigUserFriendly(pageConfigGlobalValues, pageConfig, pageConfigValues) {
-    const pageConfigUserFriendly = getPageConfigUserFriendly_public({ pageConfigGlobalValues, pageConfigValues });
+function getUserFriendlyConfigsPageEager(pageConfigGlobalValues, pageConfig, pageConfigValues) {
+    const pageConfigUserFriendly = getUserFriendlyConfigs_public({ pageConfigGlobalValues, pageConfigValues });
     let page;
     if (!pageConfig.isErrorPage) {
         const route = pageConfigUserFriendly.config.route ?? pageConfig.routeFilesystem.routeString;
@@ -24,8 +24,8 @@ function getPageConfigUserFriendly(pageConfigGlobalValues, pageConfig, pageConfi
     }
     return [pageConfig.pageId, page];
 }
-function getPageConfigUserFriendly_public({ pageConfigGlobalValues, pageConfigValues }) {
-    const pageConfigUserFriendly = getPageConfigUserFriendly_base({ pageConfigGlobalValues, pageConfigValues });
+function getUserFriendlyConfigs_public({ pageConfigGlobalValues, pageConfigValues }) {
+    const pageConfigUserFriendly = getUserFriendlyConfigs_base({ pageConfigGlobalValues, pageConfigValues });
     return getPublicCopy(pageConfigUserFriendly);
 }
 function getPublicCopy(pageConfigUserFriendly) {
@@ -37,15 +37,17 @@ function getPublicCopy(pageConfigUserFriendly) {
         _from: p.from
     };
 }
-function getPageConfigUserFriendly_base({ pageConfigGlobalValues, pageConfigValues }) {
+function getUserFriendlyConfigs_base({ pageConfigGlobalValues, pageConfigValues }) {
     const configValues = { ...pageConfigGlobalValues, ...pageConfigValues };
-    return getPageConfigUserFriendly_V1Design({ configValues });
+    return getUserFriendlyConfigs_V1Design({ configValues });
 }
-function getPageConfigGlobalUserFriendly({ pageConfigGlobalValues }) {
-    const pageConfigGlobalUserFriendly = getPageConfigUserFriendly_V1Design({ configValues: pageConfigGlobalValues });
+function getUserFriendlyConfigsGlobal({ pageConfigGlobalValues }) {
+    const pageConfigGlobalUserFriendly = getUserFriendlyConfigs_V1Design({ configValues: pageConfigGlobalValues });
     return getPublicCopy(pageConfigGlobalUserFriendly);
 }
-function getPageConfigUserFriendly_oldDesign(pageFiles, pageConfig, pageConfigGlobal) {
+function getUserFriendlyConfigsPageLazy(pageFiles, // V0.4 design
+pageConfig, // V1 design
+pageConfigGlobal) {
     const config = {};
     const configEntries = {}; // TODO/v1-release: remove
     const exportsAll = {}; // TODO/v1-release: remove
@@ -70,7 +72,7 @@ function getPageConfigUserFriendly_oldDesign(pageFiles, pageConfig, pageConfigGl
     let sources;
     let from;
     if (pageConfig) {
-        const res = getPageConfigUserFriendly_base({
+        const res = getUserFriendlyConfigs_base({
             pageConfigGlobalValues: pageConfigGlobal.configValues,
             pageConfigValues: pageConfig.configValues
         });
@@ -119,7 +121,7 @@ function getPageConfigUserFriendly_oldDesign(pageFiles, pageConfig, pageConfigGl
     return pageContextExports;
 }
 // V1 design
-function getPageConfigUserFriendly_V1Design(pageConfig) {
+function getUserFriendlyConfigs_V1Design(pageConfig) {
     const config = {};
     const configEntries = {};
     const exportsAll = {};
@@ -135,19 +137,30 @@ function getPageConfigUserFriendly_V1Design(pageConfig) {
         sources[configName] ?? (sources[configName] = []);
         sources[configName].push(src);
     };
-    Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
-        const { value } = configValue;
-        const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(configValue.definedAtData);
-        const configDefinedAt = getConfigDefinedAtOptional('Config', configName, configValue.definedAtData);
-        config[configName] = config[configName] ?? value;
+    const addLegacy = (configName, value, definedAtData) => {
+        const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser(definedAtData);
+        const configDefinedAt = getConfigDefinedAtOptional('Config', configName, definedAtData);
         configEntries[configName] = configEntries[configName] ?? [];
-        // Currently each configName has only one entry. Adding an entry for each overriden config value isn't implemented yet. (This is an isomorphic file and it isn't clear whether this can/should be implemented on the client-side. We should load a minimum amount of code on the client-side.)
-        assert(configEntries[configName].length === 0);
         configEntries[configName].push({
             configValue: value,
             configDefinedAt,
             configDefinedByFile: configValueFilePathToShowToUser
         });
+        // TODO/v1-release: remove
+        const exportName = configName;
+        exportsAll[exportName] = exportsAll[exportName] ?? [];
+        exportsAll[exportName].push({
+            exportValue: value,
+            exportSource: configDefinedAt,
+            filePath: configValueFilePathToShowToUser,
+            _filePath: configValueFilePathToShowToUser,
+            _fileType: null,
+            _isFromDefaultExport: null
+        });
+    };
+    Object.entries(pageConfig.configValues).forEach(([configName, configValue]) => {
+        const { value } = configValue;
+        config[configName] = config[configName] ?? value;
         if (configValue.type === 'standard') {
             const src = {
                 type: 'configsStandard',
@@ -156,6 +169,7 @@ function getPageConfigUserFriendly_V1Design(pageConfig) {
             };
             addSrc(src, configName);
             from.configsStandard[configName] = src;
+            addLegacy(configName, value, configValue.definedAtData);
         }
         if (configValue.type === 'cumulative') {
             const src = {
@@ -164,6 +178,7 @@ function getPageConfigUserFriendly_V1Design(pageConfig) {
                     const definedAtFile = configValue.definedAtData[i];
                     assert(definedAtFile);
                     const definedAt = getDefinedAtString(definedAtFile, configName);
+                    addLegacy(configName, value, definedAtFile);
                     return {
                         value,
                         definedAt
@@ -180,18 +195,8 @@ function getPageConfigUserFriendly_V1Design(pageConfig) {
             };
             addSrc(src, configName);
             from.configsComputed[configName] = src;
+            addLegacy(configName, value, configValue.definedAtData);
         }
-        // TODO/v1-release: remove
-        const exportName = configName;
-        exportsAll[exportName] = exportsAll[exportName] ?? [];
-        exportsAll[exportName].push({
-            exportValue: value,
-            exportSource: configDefinedAt,
-            filePath: configValueFilePathToShowToUser,
-            _filePath: configValueFilePathToShowToUser,
-            _fileType: null,
-            _isFromDefaultExport: null
-        });
     });
     return {
         config: config,

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

@@ -12,7 +12,7 @@ export type { PageContextBuiltInServer_deprecated as PageContextBuiltInServer };
 export type { PageContextBuiltInClientWithClientRouting_deprecated as PageContextBuiltInClientWithClientRouting };
 export type { PageContextBuiltInClientWithServerRouting_deprecated as PageContextBuiltInClientWithServerRouting };
 import type { PageContextUrlInternal, PageContextUrlClient, PageContextUrlServer } from './getPageContextUrlComputed.js';
-import type { ConfigEntries, ExportsAll, From, Source, Sources } from './page-configs/getPageConfigUserFriendly.js';
+import type { ConfigEntries, ExportsAll, From, Source, Sources } from './page-configs/getUserFriendlyConfigs.js';
 import type { Config } from './page-configs/Config.js';
 import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
 import type { AbortStatusCode } from './route/abort.js';

package/dist/esm/types/index.d.ts

@@ -6,7 +6,7 @@ export type { Config, ConfigMeta as Meta, ImportString, DataAsync, DataSync, Gua
 export type { ConfigResolved } from '../shared/page-configs/Config/PageContextConfig.js';
 export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
 export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
-export type { ConfigEntries } from '../shared/page-configs/getPageConfigUserFriendly.js';
+export type { ConfigEntries } from '../shared/page-configs/getUserFriendlyConfigs.js';
 export type { VikeConfigPublic as VikeConfig } from '../node/plugin/plugins/commonConfig.js';
 export type { UrlPublic as Url } from '../utils/parseUrl.js';
 export type { InjectFilterEntry } from '../node/runtime/html/injectAssets/getHtmlTags.js';

package/dist/esm/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.229-commit-845a4e0";
+export declare const PROJECT_VERSION: "0.4.229-commit-7056ef0";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.229-commit-845a4e0';
+export const PROJECT_VERSION = '0.4.229-commit-7056ef0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.229-commit-845a4e0",
+  "version": "0.4.229-commit-7056ef0",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

package/dist/cjs/shared/getPageConfigsRuntime.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPageConfigsRuntime = getPageConfigsRuntime;
-exports.getAllPageIds = getAllPageIds;
-const parseGlobResults_js_1 = require("./getPageFiles/parseGlobResults.js");
-const getPageConfigUserFriendly_js_1 = require("./page-configs/getPageConfigUserFriendly.js");
-const utils_js_1 = require("./utils.js");
-function getPageConfigsRuntime(virtualFileExports) {
-    const { pageFilesAll, pageConfigs, pageConfigGlobal } = (0, parseGlobResults_js_1.parseGlobResults)(virtualFileExports);
-    const allPageIds = getAllPageIds(pageFilesAll, pageConfigs);
-    // TODO/now: re-use this call, instead of calling it twice
-    const globalConfig = (0, getPageConfigUserFriendly_js_1.getPageConfigGlobalUserFriendly)({ pageConfigGlobalValues: pageConfigGlobal.configValues });
-    const pageConfigsUserFriendly = Object.fromEntries(pageConfigs.map((pageConfig) => {
-        return (0, getPageConfigUserFriendly_js_1.getPageConfigUserFriendly)(pageConfigGlobal.configValues, pageConfig, pageConfig.configValues);
-    }));
-    return { pageFilesAll, allPageIds, pageConfigs, pageConfigGlobal, globalConfig, pageConfigsUserFriendly };
-}
-function getAllPageIds(pageFilesAll, pageConfigs) {
-    const fileIds = pageFilesAll.filter(({ isDefaultPageFile }) => !isDefaultPageFile).map(({ pageId }) => pageId);
-    const allPageIds = (0, utils_js_1.unique)(fileIds);
-    const allPageIds2 = pageConfigs.map((p) => p.pageId);
-    return [...allPageIds, ...allPageIds2];
-}

package/dist/cjs/shared/hooks/executeHookGeneric.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeHookGeneric = executeHookGeneric;
-exports.executeHookGenericGlobalCumulative = executeHookGenericGlobalCumulative;
-const executeHook_js_1 = require("./executeHook.js");
-const getHook_js_1 = require("./getHook.js");
-async function executeHookGeneric(hookName, pageContext) {
-    const hook = (0, getHook_js_1.getHookFromPageContext)(pageContext, hookName);
-    if (!hook)
-        return;
-    await (0, executeHook_js_1.executeHook)(() => hook.hookFn(pageContext), hook, pageContext);
-}
-async function executeHookGenericGlobalCumulative(hookName, pageConfigGlobal, pageContext, arg) {
-    const hooks = (0, getHook_js_1.getHookFromPageConfigGlobalCumulative)(pageConfigGlobal, hookName);
-    await Promise.all(hooks.map(async (hook) => {
-        await (0, executeHook_js_1.executeHook)(() => hook.hookFn(arg), hook, pageContext);
-    }));
-}

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

@@ -1,14 +0,0 @@
-export { getPageConfigsRuntime };
-export { getAllPageIds };
-import type { PageFile } from './getPageFiles.js';
-import { type PageConfigUserFriendly, type PageConfigsUserFriendly } from './page-configs/getPageConfigUserFriendly.js';
-import type { PageConfigGlobalRuntime, PageConfigRuntime } from './page-configs/PageConfig.js';
-declare function getPageConfigsRuntime(virtualFileExports: unknown): {
-    pageFilesAll: PageFile[];
-    allPageIds: string[];
-    pageConfigs: PageConfigRuntime[];
-    pageConfigGlobal: PageConfigGlobalRuntime;
-    globalConfig: PageConfigUserFriendly;
-    pageConfigsUserFriendly: PageConfigsUserFriendly;
-};
-declare function getAllPageIds(pageFilesAll: PageFile[], pageConfigs: PageConfigRuntime[]): string[];