vike 0.4.232-commit-1690f53 → 0.4.232

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

@@ -3,7 +3,7 @@ export { renderPage_addAsyncHookwrapper };
 import { renderPageAlreadyRouted } from './renderPage/renderPageAlreadyRouted.js';
 import { createPageContextServerSide, createPageContextServerSideWithoutGlobalContext, } from './renderPage/createPageContextServerSide.js';
 import { route } from '../../shared/route/index.js';
-import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, augmentType, } from './utils.js';
+import { assert, hasProp, objectAssign, isUrl, parseUrl, onSetupRuntime, assertWarning, getGlobalObject, checkType, assertUsage, normalizeUrlPathname, removeBaseServer, modifyUrlPathname, prependBase, removeUrlOrigin, setUrlOrigin, isUri, getUrlPretty, } from './utils.js';
 import { assertNoInfiniteAbortLoop, getPageContextFromAllRewrites, isAbortError, logAbortErrorHandled, } from '../../shared/route/abort.js';
 import { getGlobalContextServerInternal, initGlobalContext_renderPage, } from './globalContext.js';
 import { handlePageContextRequestUrl } from './renderPage/handlePageContextRequestUrl.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 { loadPageConfigsLazyServerSideAndExecHook } from './renderPage/loadPageConfigsLazyServerSide.js';
+import { loadPageConfigsLazyServerSide } from './renderPage/loadPageConfigsLazyServerSide.js';
 import { resolveRedirects } from './renderPage/resolveRedirects.js';
 import { getVikeConfigError } from '../shared/getVikeConfigError.js';
 const globalObject = getGlobalObject('runtime/renderPage.ts', { httpRequestsCount: 0 });
@@ -138,66 +138,59 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
     else {
         assert(errNominalPage);
         assert(pageContextNominalPageSuccess === undefined);
-        return await renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite);
-    }
-}
-// When the normal page threw an error
-// - Can be a URL rewrite upon `throw render('/some-url')`
-// - Can be rendering the error page
-// - Can be rendering Vike's generic error page (if no error page is defined, or if the error page throws an error)
-async function renderPageOnError(errNominalPage, pageContextBegin, pageContextNominalPageBegin, globalContext, httpRequestId, pageContextsFromRewrite) {
-    assert(pageContextNominalPageBegin);
-    assert(hasProp(pageContextNominalPageBegin, 'urlOriginal', 'string'));
-    const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
-    // Handle `throw redirect()` and `throw render()` while rendering nominal page
-    if (isAbortError(errNominalPage)) {
-        const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-        if (handled.pageContextReturn) {
-            // - throw redirect()
-            // - throw render(url)
-            // - throw render(abortStatusCode) if .pageContext.json request
-            return handled.pageContextReturn;
-        }
-        else {
-            // - throw render(abortStatusCode) if not .pageContext.json request
+        assert(pageContextNominalPageBegin);
+        assert(hasProp(pageContextNominalPageBegin, 'urlOriginal', 'string'));
+        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
+        // Handle `throw redirect()` and `throw render()` while rendering nominal page
+        if (isAbortError(errNominalPage)) {
+            const handled = await handleAbortError(errNominalPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+            if (handled.pageContextReturn) {
+                // - throw redirect()
+                // - throw render(url)
+                // - throw render(abortStatusCode) if .pageContext.json request
+                return handled.pageContextReturn;
+            }
+            else {
+                // - throw render(abortStatusCode) if not .pageContext.json request
+            }
+            Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
         }
-        Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
-    }
-    {
-        const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
-        if (!errorPageId) {
-            objectAssign(pageContextErrorPageInit, { pageId: null });
-            return handleErrorWithoutErrorPage(pageContextErrorPageInit);
+        {
+            const errorPageId = getErrorPageId(globalContext._pageFilesAll, globalContext._pageConfigs);
+            if (!errorPageId) {
+                objectAssign(pageContextErrorPageInit, { pageId: null });
+                return handleErrorWithoutErrorPage(pageContextErrorPageInit);
+            }
+            else {
+                objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
+            }
         }
-        else {
-            objectAssign(pageContextErrorPageInit, { pageId: errorPageId });
+        let pageContextErrorPage;
+        try {
+            pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
         }
-    }
-    let pageContextErrorPage;
-    try {
-        pageContextErrorPage = await renderPageAlreadyRouted(pageContextErrorPageInit);
-    }
-    catch (errErrorPage) {
-        // Handle `throw redirect()` and `throw render()` while rendering error page
-        if (isAbortError(errErrorPage)) {
-            const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-            // throw render(abortStatusCode)
-            if (!handled.pageContextReturn) {
-                const pageContextAbort = errErrorPage._pageContextAbort;
-                assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
-                const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-                return pageContextHttpWithError;
+        catch (errErrorPage) {
+            // Handle `throw redirect()` and `throw render()` while rendering error page
+            if (isAbortError(errErrorPage)) {
+                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+                // throw render(abortStatusCode)
+                if (!handled.pageContextReturn) {
+                    const pageContextAbort = errErrorPage._pageContextAbort;
+                    assertWarning(false, `Failed to render error page because ${pc.cyan(pageContextAbort._abortCall)} was called: make sure ${pc.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
+                    const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+                    return pageContextHttpWithError;
+                }
+                // `throw redirect()` / `throw render(url)`
+                return handled.pageContextReturn;
             }
-            // `throw redirect()` / `throw render(url)`
-            return handled.pageContextReturn;
-        }
-        if (isNewError(errErrorPage, errNominalPage)) {
-            logRuntimeError(errErrorPage, httpRequestId);
+            if (isNewError(errErrorPage, errNominalPage)) {
+                logRuntimeError(errErrorPage, httpRequestId);
+            }
+            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+            return pageContextWithError;
         }
-        const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-        return pageContextWithError;
+        return pageContextErrorPage;
     }
-    return pageContextErrorPage;
 }
 function logHttpRequest(urlOriginal, httpRequestId) {
     logRuntimeInfo?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info');
@@ -419,7 +412,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             objectAssign(pageContext, { pageId: errorPageId });
             objectAssign(pageContext, pageContextAbort);
             objectAssign(pageContext, pageContextErrorPageInit, true);
-            augmentType(pageContext, await loadPageConfigsLazyServerSideAndExecHook(pageContext));
+            objectAssign(pageContext, await loadPageConfigsLazyServerSide(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,6 +19,8 @@ const configDefinitionsBuiltIn = {
     },
     onCreatePageContext: {
         env: { server: true, client: true },
+        // Required because `onCreatePageContext()` is called before routing
+        global: true,
         cumulative: true,
     },
     onCreateGlobalContext: {

package/dist/esm/shared/createPageContextShared.js

@@ -1,9 +1,11 @@
 export { createPageContextShared };
 export { createPageContextObject };
+import { execHookGlobal } from './hooks/execHook.js';
+import { preparePageContextForPublicUsage } from './preparePageContextForPublicUsage.js';
 import { changeEnumerable, objectAssign } from './utils.js';
-// TODO/now: make this and parents sync
 async function createPageContextShared(pageContextCreated, pageConfigGlobal, vikeConfigPublicGlobal) {
     objectAssign(pageContextCreated, vikeConfigPublicGlobal);
+    await execHookGlobal('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage);
     return pageContextCreated;
 }
 function createPageContextObject() {

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

@@ -1,14 +1,15 @@
 export { execHook };
+export { execHookSingle };
+export { execHookSingleWithReturn };
+export { execHookErrorHandling };
+export { execHooksErrorHandling };
+export { execHookWithoutPageContext };
 export { execHookGlobal };
-export { execHookDirect };
-export { execHookDirectSingle };
-export { execHookDirectSingleWithReturn };
-export { execHookDirectWithoutPageContext };
-export { execHookDirectSync };
+export { execHookSync };
 export { getPageContext };
 export { providePageContext };
 export { isUserHookError };
-export type { PageContextExecHook };
+export type { PageContextExecuteHook };
 import type { PageContextClient, PageContextServer } from '../../types/PageContext.js';
 import type { Hook, HookLoc } from './getHook.js';
 import type { VikeConfigPublicPageLazy } from '../getPageFiles.js';
@@ -18,21 +19,34 @@ 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 PageContextExecHook = VikeConfigPublicPageLazy & PageContextForPublicUsage;
+type PageContextExecuteHook = VikeConfigPublicPageLazy & PageContextForPublicUsage;
 type PageContextForPublicUsage = PageContextForPublicUsageServer | PageContextForPublicUsageClientShared;
 type HookWithResult = Hook & {
     hookReturn: unknown;
 };
-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<{
+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<{
     hookReturn: unknown;
 }>;
+declare function execHook<PageContext extends PageContextExecuteHook>(hookName: HookName, pageContext: PageContext, preparePageContextForPublicUsage: (pageContext: PageContext) => PageContext): Promise<HookWithResult[]>;
+declare function execHookErrorHandling<PageContext extends PageContextExecuteHook>(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 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): {
+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): {
     hookReturn: unknown;
 };
 /**

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

@@ -1,10 +1,11 @@
 export { execHook };
+export { execHookSingle };
+export { execHookSingleWithReturn };
+export { execHookErrorHandling };
+export { execHooksErrorHandling };
+export { execHookWithoutPageContext };
 export { execHookGlobal };
-export { execHookDirect };
-export { execHookDirectSingle };
-export { execHookDirectSingleWithReturn };
-export { execHookDirectWithoutPageContext };
-export { execHookDirectSync };
+export { execHookSync };
 export { getPageContext };
 export { providePageContext };
 export { isUserHookError };
@@ -18,48 +19,70 @@ 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 await execHookDirect(hooks, pageContext, preparePageContextForPublicUsage);
+    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 };
+    }
 }
 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 execHookDirectAsync(() => hook.hookFn(hookArgForPublicUsage), hook, pageContext);
+        await execHookAsync(() => 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 execHookDirectWithoutPageContext(hookFnCaller, hook) {
+async function execHookWithoutPageContext(hookFnCaller, hook) {
     const { hookName, hookFilePath, hookTimeout } = hook;
-    const hookReturn = await execHookDirectAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
+    const hookReturn = await execHookAsync(hookFnCaller, { hookName, hookFilePath, hookTimeout }, null);
     return hookReturn;
 }
-function execHookDirectAsync(hookFnCaller, hook, pageContextForPublicUsage) {
+function execHookAsync(hookFnCaller, hook, pageContextForPublicUsage) {
     const { hookName, hookFilePath, hookTimeout: { error: timeoutErr, warning: timeoutWarn }, } = hook;
     let resolve;
     let reject;
@@ -103,7 +126,7 @@ function execHookDirectAsync(hookFnCaller, hook, pageContextForPublicUsage) {
     })();
     return promise;
 }
-function execHookDirectSync(hook, pageContext, preparePageContextForPublicUsage) {
+function execHookSync(hook, pageContext, preparePageContextForPublicUsage) {
     const pageContextForPublicUsage = preparePageContextForPublicUsage(pageContext);
     providePageContextInternal(pageContextForPublicUsage);
     const hookReturn = hook.hookFn(pageContextForPublicUsage);

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

@@ -0,0 +1,8 @@
+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>;

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

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

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

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

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

@@ -1,11 +1,11 @@
-export { execHookOnBeforeRoute };
+export { executeOnBeforeRouteHook };
 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 { execHookDirectSync } from '../hooks/execHook.js';
+import { execHookSync } from '../hooks/execHook.js';
 import { preparePageContextForPublicUsage, } from '../preparePageContextForPublicUsage.js';
-async function execHookOnBeforeRoute(pageContext) {
+async function executeOnBeforeRouteHook(pageContext) {
     const pageContextFromOnBeforeRouteHook = {};
     if (!pageContext._globalContext._onBeforeRouteHook)
         return null;
@@ -34,9 +34,9 @@ async function execHookOnBeforeRoute(pageContext) {
     return pageContextFromOnBeforeRouteHook;
 }
 async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
-    let { hookReturn } = execHookDirectSync(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage);
+    let { hookReturn } = execHookSync(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage);
     assertSyncRouting(hookReturn, `The onBeforeRoute() hook ${onBeforeRouteHook.hookFilePath}`);
-    // TODO/v1-release: make execHookOnBeforeRoute() and route() sync
+    // TODO/v1-release: make executeOnBeforeRouteHook() 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,16 +9,15 @@ import { assert, assertUsage, isPlainObject, objectAssign } from './utils.js';
 import { resolvePrecedence } from './resolvePrecedence.js';
 import { resolveRouteString } from './resolveRouteString.js';
 import { resolveRouteFunction } from './resolveRouteFunction.js';
-import { execHookOnBeforeRoute } from './execHookOnBeforeRoute.js';
+import { executeOnBeforeRouteHook } from './executeOnBeforeRouteHook.js';
 import { debug } from './debug.js';
 import pc from '@brillout/picocolors';
-// TODO/next-major-release: make it sync
 async function route(pageContext, skipOnBeforeRouteHook) {
     debug('Pages routes:', pageContext._globalContext._pageRoutes);
     const pageContextFromRoute = {};
     // onBeforeRoute()
     if (!skipOnBeforeRouteHook) {
-        const pageContextFromOnBeforeRouteHook = await execHookOnBeforeRoute(pageContext);
+        const pageContextFromOnBeforeRouteHook = await executeOnBeforeRouteHook(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 { execHookDirectSync } from '../hooks/execHook.js';
+import { execHookSync } 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 } = execHookDirectSync({
+    let { hookReturn: result } = execHookSync({
         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-1690f53";
+export declare const PROJECT_VERSION: "0.4.232";

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-1690f53';
+export const PROJECT_VERSION = '0.4.232';

package/dist/esm/utils/styleFileRE.js

@@ -1,3 +1,2 @@
 // Copied from https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/css.ts#L90-L91
-// spellcheck-ignore
 export const styleFileRE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\?)/;

package/package.json

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

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

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

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

@@ -1,8 +0,0 @@
-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>;