vike 0.4.232-commit-ec54a7e → 0.4.232-commit-1690f53

package/dist/esm/node/runtime/renderPage.js

@@ -16,7 +16,7 @@ import pc from '@brillout/picocolors';
 import { getPageContextClientSerializedAbort, getPageContextClientSerialized } from './html/serializeContext.js';
 import { getErrorPageId } from '../../shared/error-page.js';
 import { handleErrorWithoutErrorPage } from './renderPage/handleErrorWithoutErrorPage.js';
-import { loadPageConfigsLazyServerSide } from './renderPage/loadPageConfigsLazyServerSide.js';
+import { loadPageConfigsLazyServerSideAndExecHook } from './renderPage/loadPageConfigsLazyServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
 import { getVikeConfigError } from '../shared/getVikeConfigError.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', { httpRequestsCount: 0 });
@@ -419,7 +419,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
             objectAssign(pageContext, pageContextErrorPageInit, true);
-            augmentType(pageContext, await loadPageConfigsLazyServerSide(pageContext));
+            augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = getPageContextClientSerialized(pageContext);
         }

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

@@ -19,8 +19,6 @@ const configDefinitionsBuiltIn = {
     },
     onCreatePageContext: {
         env: { server: true, client: true },
-        // Required because `onCreatePageContext()` is called before routing
-        global: true,
         cumulative: true,
     },
     onCreateGlobalContext: {

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

@@ -1,15 +1,14 @@
 export { execHook };
-export { execHookSingle };
-export { execHookSingleWithReturn };
-export { execHookErrorHandling };
-export { execHooksErrorHandling };
-export { execHookWithoutPageContext };
 export { execHookGlobal };
-export { execHookSync };
+export { execHookDirect };
+export { execHookDirectSingle };
+export { execHookDirectSingleWithReturn };
+export { execHookDirectWithoutPageContext };
+export { execHookDirectSync };
 export { getPageContext };
 export { providePageContext };
 export { isUserHookError };
-export type { PageContextExecuteHook };
+export type { PageContextExecHook };
 import type { PageContextClient, PageContextServer } from '../../types/PageContext.js';
 import type { Hook, HookLoc } from './getHook.js';
 import type { VikeConfigPublicPageLazy } from '../getPageFiles.js';
@@ -19,35 +18,21 @@ import type { PageContextForPublicUsageServer } from '../../node/runtime/renderP
 import type { PageContextForPublicUsageClientShared } from '../../client/shared/preparePageContextForPublicUsageClientShared.js';
 import { type PageContextPrepareMinimum } from '../preparePageContextForPublicUsage.js';
 import type { GlobalContextPrepareMinimum } from '../prepareGlobalContextForPublicUsage.js';
-type PageContextPrepareMinimum2 = PageContextPrepareMinimum & VikeConfigPublicPageLazy;
-type PageContextExecuteHook = VikeConfigPublicPageLazy & PageContextForPublicUsage;
+type PageContextExecHook = VikeConfigPublicPageLazy & PageContextForPublicUsage;
 type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
 type HookWithResult = Hook & {
     hookReturn: unknown;
 };
-declare function execHookSingle<PageContext extends PageContextExecuteHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<void>;
-declare function execHookSingleWithReturn<PageContext extends PageContextExecuteHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
+declare function execHook<PageContext extends PageContextExecHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookGlobal<HookArg extends PageContextPrepareMinimum | GlobalContextPrepareMinimum>(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: PageContextPrepareMinimum | null, hookArg: HookArg, prepareForPublicUsage: (hookArg: HookArg) => HookArg): Promise<void>;
+declare function execHookDirect<PageContext extends PageContextPrepareMinimum>(hooks: Hook[], pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookDirectSingle<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<void>;
+declare function execHookDirectSingleWithReturn<PageContext extends PageContextExecHook>(hook: Hook, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
     hookReturn: unknown;
 }>;
-declare function execHook<PageContext extends PageContextPrepareMinimum2>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
-declare function execHookErrorHandling<PageContext extends PageContextPrepareMinimum2>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
-    hooks: HookWithResult[];
-    err?: undefined;
-} | {
-    hooks: Hook[];
-    err: unknown;
-}>;
-declare function execHooksErrorHandling<PageContext extends PageContextPrepareMinimum>(hooks: Hook[], pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<{
-    hooks: HookWithResult[];
-    err?: undefined;
-} | {
-    hooks: Hook[];
-    err: unknown;
-}>;
-declare function execHookGlobal<HookArg extends PageContextPrepareMinimum | GlobalContextPrepareMinimum>(hookName: HookNameGlobal, pageConfigGlobal: PageConfigGlobalRuntime, pageContext: PageContextPrepareMinimum | null, hookArg: HookArg, prepareForPublicUsage: (hookArg: HookArg) => HookArg): Promise<void>;
 declare function isUserHookError(err: unknown): false | HookLoc;
-declare function execHookWithoutPageContext<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookFn'>): Promise<HookReturn>;
-declare function execHookSync<PageContext extends PageContextPrepareMinimum>(hook: Omit<Hook, 'hookTimeout'>, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): {
+declare function execHookDirectWithoutPageContext<HookReturn>(hookFnCaller: () => HookReturn, hook: Omit<Hook, 'hookFn'>): Promise<HookReturn>;
+declare function execHookDirectSync<PageContext extends PageContextPrepareMinimum>(hook: Omit<Hook, 'hookTimeout'>, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): {
     hookReturn: unknown;
 };
 /**

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

@@ -1,11 +1,10 @@
 export { execHook };
-export { execHookSingle };
-export { execHookSingleWithReturn };
-export { execHookErrorHandling };
-export { execHooksErrorHandling };
-export { execHookWithoutPageContext };
 export { execHookGlobal };
-export { execHookSync };
+export { execHookDirect };
+export { execHookDirectSingle };
+export { execHookDirectSingleWithReturn };
+export { execHookDirectWithoutPageContext };
+export { execHookDirectSync };
 export { getPageContext };
 export { providePageContext };
 export { isUserHookError };
@@ -19,70 +18,48 @@ const globalObject = getGlobalObject('utils/execHook.ts', {
     userHookErrors: new WeakMap(),
     pageContext: null,
 });
-async function execHookSingle(hook, pageContext, preparePageContextForPublicUsage) {
-    const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
-    if ('err' in res)
-        throw res.err;
-    const { hookReturn } = res.hooks[0];
-    assertUsage(hookReturn === undefined, `The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
-}
-async function execHookSingleWithReturn(hook, pageContext, preparePageContextForPublicUsage) {
-    const res = await execHooksErrorHandling([hook], pageContext, preparePageContextForPublicUsage);
-    if ('err' in res)
-        throw res.err;
-    const { hookReturn } = res.hooks[0];
-    return { hookReturn };
-}
 async function execHook(hookName, pageContext, preparePageContextForPublicUsage) {
-    const res = await execHookErrorHandling(hookName, pageContext, preparePageContextForPublicUsage);
-    if ('err' in res)
-        throw res.err;
-    return res.hooks;
-}
-async function execHookErrorHandling(hookName, pageContext, preparePageContextForPublicUsage) {
     const hooks = getHookFromPageContextNew(hookName, pageContext);
-    return execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsage);
-}
-async function execHooksErrorHandling(hooks, pageContext, preparePageContextForPublicUsage) {
-    if (!hooks.length)
-        return { hooks: [] };
-    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
-    let hooksWithResult;
-    let err;
-    try {
-        hooksWithResult = await Promise.all(hooks.map(async (hook) => {
-            const hookReturn = await execHookAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContextForPublicUsage);
-            return { ...hook, hookReturn };
-        }));
-    }
-    catch (err_) {
-        err = err_;
-    }
-    if (hooksWithResult) {
-        return { hooks: hooksWithResult };
-    }
-    else {
-        return { hooks, err };
-    }
+    return await execHookDirect(hooks, pageContext, preparePageContextForPublicUsage);
 }
 async function execHookGlobal(hookName, pageConfigGlobal, pageContext, hookArg, prepareForPublicUsage) {
     const hooks = getHookFromPageConfigGlobalCumulative(pageConfigGlobal, hookName);
     const hookArgForPublicUsage = prepareForPublicUsage(hookArg);
     await Promise.all(hooks.map(async (hook) => {
-        await execHookAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
+        await execHookDirectAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
     }));
 }
+async function execHookDirect(hooks, pageContext, preparePageContextForPublicUsage) {
+    if (!hooks.length)
+        return [];
+    const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
+    const hooksWithResult = await Promise.all(hooks.map(async (hook) => {
+        const hookReturn = await execHookDirectAsync(() => hook.hookFn(pageContextForPublicUsage), hook, pageContextForPublicUsage);
+        return { ...hook, hookReturn };
+    }));
+    return hooksWithResult;
+}
+async function execHookDirectSingle(hook, pageContext, preparePageContextForPublicUsage) {
+    const hooksWithResult = await execHookDirect([hook], pageContext, preparePageContextForPublicUsage);
+    const { hookReturn } = hooksWithResult[0];
+    assertUsage(hookReturn === undefined, `The ${hook.hookName}() hook defined by ${hook.hookFilePath} isn't allowed to return a value`);
+}
+async function execHookDirectSingleWithReturn(hook, pageContext, preparePageContextForPublicUsage) {
+    const hooksWithResult = await execHookDirect([hook], pageContext, preparePageContextForPublicUsage);
+    const { hookReturn } = hooksWithResult[0];
+    return { hookReturn };
+}
 function isUserHookError(err) {
     if (!isObject(err))
         return false;
     return globalObject.userHookErrors.get(err) ?? false;
 }
-async function execHookWithoutPageContext(hookFnCaller, hook) {
+async function execHookDirectWithoutPageContext(hookFnCaller, hook) {
     const { hookName, hookFilePath, hookTimeout } = hook;
-    const hookReturn = await execHookAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
+    const hookReturn = await execHookDirectAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
     return hookReturn;
 }
-function execHookAsync(hookFnCaller, hook, pageContextForPublicUsage) {
+function execHookDirectAsync(hookFnCaller, hook, pageContextForPublicUsage) {
     const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn }, } = hook;
     let resolve;
     let reject;
@@ -126,7 +103,7 @@ function execHookAsync(hookFnCaller, hook, pageContextForPublicUsage) {
     })();
     return promise;
 }
-function execHookSync(hook, pageContext, preparePageContextForPublicUsage) {
+function execHookDirectSync(hook, pageContext, preparePageContextForPublicUsage) {
     const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
     providePageContextInternal(pageContextForPublicUsage);
     const hookReturn = hook.hookFn(pageContextForPublicUsage);

package/dist/esm/shared/route/execHookGuard.d.ts

@@ -0,0 +1,8 @@
+export { execHookGuard };
+import { type PageContextExecHook } from '../hooks/execHook.js';
+import type { GlobalContextInternal } from '../createGlobalContextShared.js';
+declare function execHookGuard<PageContext extends {
+    pageId: string;
+} & {
+    _globalContext: GlobalContextInternal;
+} & PageContextExecHook>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

package/dist/esm/shared/route/{executeGuardHook.js → execHookGuard.js}

@@ -1,9 +1,9 @@
-export { executeGuardHook };
+export { execHookGuard };
 import { getHookFromPageContext, getHookTimeoutDefault } from '../hooks/getHook.js';
 import { assert, assertUsage, isCallable } from './utils.js';
-import { execHookSingle } from '../hooks/execHook.js';
+import { execHookDirectSingle } from '../hooks/execHook.js';
 const errIntro = 'The guard() hook defined by';
-async function executeGuardHook(pageContext, prepareForPublicUsage) {
+async function execHookGuard(pageContext, prepareForPublicUsage) {
     let hook;
     if (pageContext._globalContext._pageFilesAll.length > 0) {
         // TODO/v1-release: remove
@@ -17,7 +17,7 @@ async function executeGuardHook(pageContext, prepareForPublicUsage) {
     }
     if (!hook)
         return;
-    await execHookSingle(hook, pageContext, prepareForPublicUsage);
+    await execHookDirectSingle(hook, pageContext, prepareForPublicUsage);
 }
 function findPageGuard(pageId, pageFilesAll) {
     const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');

package/dist/esm/shared/route/{executeOnBeforeRouteHook.d.ts → execHookOnBeforeRoute.d.ts}

@@ -1,6 +1,6 @@
-export { executeOnBeforeRouteHook };
+export { execHookOnBeforeRoute };
 import type { PageContextForRoute, PageContextFromRoute } from './index.js';
-declare function executeOnBeforeRouteHook(pageContext: PageContextForRoute): Promise<null | ({
+declare function execHookOnBeforeRoute(pageContext: PageContextForRoute): Promise<null | ({
     _routingProvidedByOnBeforeRouteHook: true;
 } & PageContextFromRoute) | {
     _routingProvidedByOnBeforeRouteHook: false;

package/dist/esm/shared/route/{executeOnBeforeRouteHook.js → execHookOnBeforeRoute.js}

@@ -1,11 +1,11 @@
-export { executeOnBeforeRouteHook };
+export { execHookOnBeforeRoute };
 import { assertPageContextProvidedByUser } from '../assertPageContextProvidedByUser.js';
 import { assertUsage, hasProp, isObjectWithKeys, objectAssign, assertWarning, assertUsageUrlPathnameAbsolute, joinEnglish, assert, } from './utils.js';
 import { assertRouteParams, assertSyncRouting } from './resolveRouteFunction.js';
 import pc from '@brillout/picocolors';
-import { execHookSync } from '../hooks/execHook.js';
+import { execHookDirectSync } from '../hooks/execHook.js';
 import { preparePageContextForPublicUsage, } from '../preparePageContextForPublicUsage.js';
-async function executeOnBeforeRouteHook(pageContext) {
+async function execHookOnBeforeRoute(pageContext) {
     const pageContextFromOnBeforeRouteHook = {};
     if (!pageContext._globalContext._onBeforeRouteHook)
         return null;
@@ -34,9 +34,9 @@ async function executeOnBeforeRouteHook(pageContext) {
     return pageContextFromOnBeforeRouteHook;
 }
 async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
-    let { hookReturn } = execHookSync(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage);
+    let { hookReturn } = execHookDirectSync(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage);
     assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
-    // TODO/v1-release: make executeOnBeforeRouteHook() and route() sync
+    // TODO/v1-release: make execHookOnBeforeRoute() and route() sync
     hookReturn = await hookReturn;
     const errPrefix = `The onBeforeRoute() hook defined by ${onBeforeRouteHook.hookFilePath}`;
     assertUsage(hookReturn === null ||

package/dist/esm/shared/route/index.js

@@ -9,7 +9,7 @@ import { assert, assertUsage, isPlainObject, objectAssign } from './utils.js';
 import { resolvePrecedence } from './resolvePrecedence.js';
 import { resolveRouteString } from './resolveRouteString.js';
 import { resolveRouteFunction } from './resolveRouteFunction.js';
-import { executeOnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
+import { execHookOnBeforeRoute } from './execHookOnBeforeRoute.js';
 import { debug } from './debug.js';
 import pc from '@brillout/picocolors';
 // TODO/next-major-release: make it sync
@@ -18,7 +18,7 @@ async function route(pageContext, skipOnBeforeRouteHook) {
     const pageContextFromRoute = {};
     // onBeforeRoute()
     if (!skipOnBeforeRouteHook) {
-        const pageContextFromOnBeforeRouteHook = await executeOnBeforeRouteHook(pageContext);
+        const pageContextFromOnBeforeRouteHook = await execHookOnBeforeRoute(pageContext);
         if (pageContextFromOnBeforeRouteHook) {
             if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
                 assert(pageContextFromOnBeforeRouteHook.pageId);

package/dist/esm/shared/route/resolveRouteFunction.js

@@ -2,12 +2,12 @@ export { resolveRouteFunction };
 export { assertRouteParams };
 export { assertSyncRouting };
 export { warnDeprecatedAllowKey };
-import { execHookSync } from '../hooks/execHook.js';
+import { execHookDirectSync } from '../hooks/execHook.js';
 import { preparePageContextForPublicUsage } from '../preparePageContextForPublicUsage.js';
 import { assert, assertUsage, assertWarning, hasProp, isPlainObject, isPromise } from './utils.js';
 import pc from '@brillout/picocolors';
 async function resolveRouteFunction(routeFunction, pageContext, routeFunctionFilePath) {
-    let { hookReturn: result } = execHookSync({
+    let { hookReturn: result } = execHookDirectSync({
         hookFn: routeFunction,
         hookFilePath: routeFunctionFilePath,
         hookName: 'route',

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

@@ -1 +1 @@
-export declare const PROJECT_VERSION: "0.4.232-commit-ec54a7e";
+export declare const PROJECT_VERSION: "0.4.232-commit-1690f53";

package/dist/esm/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.232-commit-ec54a7e';
+export const PROJECT_VERSION = '0.4.232-commit-1690f53';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.232-commit-ec54a7e",
+  "version": "0.4.232-commit-1690f53",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {

package/dist/esm/node/runtime/renderPage/executeOnBeforeRenderAndDataHooks.d.ts

@@ -1,6 +0,0 @@
-export { executeOnBeforeRenderAndDataHooks };
-import { type PageContextExecuteHookServer } from './execHookServer.js';
-declare function executeOnBeforeRenderAndDataHooks(pageContext: {
-    pageId: string;
-    _pageContextAlreadyProvidedByOnPrerenderHook?: true;
-} & PageContextExecuteHookServer): Promise<void>;

package/dist/esm/shared/route/executeGuardHook.d.ts

@@ -1,8 +0,0 @@
-export { executeGuardHook };
-import { type PageContextExecuteHook } from '../hooks/execHook.js';
-import type { GlobalContextInternal } from '../createGlobalContextShared.js';
-declare function executeGuardHook<PageContext extends {
-    pageId: string;
-} & {
-    _globalContext: GlobalContextInternal;
-} & PageContextExecuteHook>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;