npm - vike - Versions diffs - 0.4.232 → 0.4.233 - Mend

vike 0.4.232 → 0.4.233

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (56) hide show

package/dist/cjs/node/prerender/runPrerender.js CHANGED Viewed

@@ -67,6 +67,7 @@ const getOutDirs_js_1 = require("../vite/shared/getOutDirs.js");
 const node_fs_1 = __importDefault(require("node:fs"));
 const getProxyForPublicUsage_js_1 = require("../../shared/getProxyForPublicUsage.js");
 const resolveRedirects_js_1 = require("../runtime/renderPage/resolveRedirects.js");
+const utils_js_2 = require("../runtime/utils.js");
 const docLink = 'https://vike.dev/i18n#pre-rendering';
 async function runPrerender(options = {}, trigger) {
     (0, context_js_1.setWasPrerenderRun)(trigger);
@@ -253,7 +254,7 @@ async function callOnBeforePrerenderStartHooks(prerenderContext, globalContext,
         if (doNotPrerenderList.find((p) => p.pageId === pageId))
             return;
         const { hookName, hookFilePath } = hook;
-        const prerenderResult = await (0, execHook_js_1.execHookWithoutPageContext)(() => hook.hookFn(), hook);
+        const prerenderResult = await (0, execHook_js_1.execHookDirectWithoutPageContext)(() => hook.hookFn(), hook);
         const result = normalizeOnPrerenderHookResult(prerenderResult, hookFilePath, hookName);
         // Handle result
         await Promise.all(result.map(async ({ url, pageContext }) => {
@@ -360,7 +361,7 @@ async function createPageContextPrerendering(urlOriginal, prerenderContext, glob
             routeParams: {},
         });
     }
-    (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+    (0, utils_js_2.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSideAndExecHook)(pageContext));
     let usesClientRouter;
     {
         const { pageId } = pageContext;
@@ -481,7 +482,7 @@ async function callOnPrerenderStartHook(prerenderContext, globalContext, concurr
         (0, utils_js_1.preservePropertyGetters)(pageContext);
     });
     const prerenderContextPublic = preparePrerenderContextForPublicUsage(prerenderContext);
-    let result = await (0, execHook_js_1.execHookWithoutPageContext)(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
+    let result = await (0, execHook_js_1.execHookDirectWithoutPageContext)(() => hookFn(prerenderContextPublic), onPrerenderStartHook);
     // Before applying result
     prerenderContext.pageContexts.forEach((pageContext) => {
         ;
@@ -763,9 +764,13 @@ function getRedirectHtml(urlTarget) {
   <meta charset="UTF-8">
   <meta http-equiv="refresh" content="0;url=${urlTargetSafe}">
   <title>Redirect ${urlTargetSafe}</title>
+  <style>body{opacity:0}</style>
+  <noscript>
+  <style>body{opacity:1}</style>
+  </noscript>
 </head>
 <body style="min-height: 100vh; margin: 0; font-family: sans-serif; display: flex; justify-content: center; align-items: center; transition: opacity 0.3s;">
-  <script>document.body.style.opacity=0; setTimeout(()=>{document.body.style.opacity=1},1000);</script>
+  <script>setTimeout(()=>{document.body.style.opacity=1},2000)</script>
   <div>
     <h1>Redirect <a href="${urlTargetSafe}"><code style="background-color: #eaeaea; padding: 3px 5px; border-radius: 4px;">${urlTargetSafe}</code></a></h1>
     <p>If you aren't redirected, click the link above.</p>

package/dist/cjs/node/runtime/renderPage/{executeOnBeforeRenderAndDataHooks.js → execHookDataAndOnBeforeRender.js} RENAMED Viewed

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeOnBeforeRenderAndDataHooks = executeOnBeforeRenderAndDataHooks;
+exports.execHookDataAndOnBeforeRender = execHookDataAndOnBeforeRender;
 const assertOnBeforeRenderHookReturn_js_1 = require("../../../shared/assertOnBeforeRenderHookReturn.js");
 const execHookServer_js_1 = require("./execHookServer.js");
-async function executeOnBeforeRenderAndDataHooks(pageContext) {
+async function execHookDataAndOnBeforeRender(pageContext) {
     if (pageContext._pageContextAlreadyProvidedByOnPrerenderHook) {
         return;
     }

package/dist/cjs/node/runtime/renderPage/{executeOnRenderHtmlHook.js → execHookOnRenderHtml.js} RENAMED Viewed

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeOnRenderHtmlHook = executeOnRenderHtmlHook;
+exports.execHookOnRenderHtml = execHookOnRenderHtml;
 const renderHtml_js_1 = require("../html/renderHtml.js");
 const getHook_js_1 = require("../../../shared/hooks/getHook.js");
 const utils_js_1 = require("../utils.js");
@@ -14,10 +14,10 @@ const assertHookReturnedObject_js_1 = require("../../../shared/assertHookReturne
 const loggerRuntime_js_1 = require("../loggerRuntime.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const execHook_js_1 = require("../../../shared/hooks/execHook.js");
-async function executeOnRenderHtmlHook(pageContext) {
+async function execHookOnRenderHtml(pageContext) {
     const hook = getRenderHook(pageContext);
     (0, utils_js_1.objectAssign)(pageContext, { _renderHook: hook });
-    const { hookReturn } = await (0, execHook_js_1.execHookSingleWithReturn)(hook, pageContext, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer);
+    const { hookReturn } = await (0, execHook_js_1.execHookDirectSingleWithReturn)(hook, pageContext, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer);
     const { documentHtml, pageContextProvidedByRenderHook, pageContextPromise, injectFilter } = processHookReturnValue(hookReturn, hook);
     Object.assign(pageContext, pageContextProvidedByRenderHook);
     (0, utils_js_1.objectAssign)(pageContext, { _pageContextPromise: pageContextPromise });

package/dist/cjs/node/runtime/renderPage/execHookServer.js CHANGED Viewed

@@ -4,8 +4,5 @@ exports.execHookServer = execHookServer;
 const execHook_js_1 = require("../../../shared/hooks/execHook.js");
 const preparePageContextForPublicUsageServer_js_1 = require("./preparePageContextForPublicUsageServer.js");
 async function execHookServer(hookName, pageContext) {
-    return await (0, execHook_js_1.execHook)(hookName, pageContext, (p) => {
-        (0, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer)(p);
-        return p;
-    });
+    return await (0, execHook_js_1.execHook)(hookName, pageContext, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer);
 }

package/dist/cjs/node/runtime/renderPage/loadPageConfigsLazyServerSide.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadPageConfigsLazyServerSide = loadPageConfigsLazyServerSide;
+exports.loadPageConfigsLazyServerSideAndExecHook = loadPageConfigsLazyServerSideAndExecHook;
 const getPageFiles_js_1 = require("../../../shared/getPageFiles.js");
 const resolveVikeConfigPublic_js_1 = require("../../../shared/page-configs/resolveVikeConfigPublic.js");
 const analyzePageClientSide_js_1 = require("../../../shared/getPageFiles/analyzePageClientSide.js");
@@ -10,6 +10,13 @@ const debugPageFiles_js_1 = require("./debugPageFiles.js");
 const findPageConfig_js_1 = require("../../../shared/page-configs/findPageConfig.js");
 const analyzePage_js_1 = require("./analyzePage.js");
 const loadConfigValues_js_1 = require("../../../shared/page-configs/loadConfigValues.js");
+const execHookServer_js_1 = require("./execHookServer.js");
+async function loadPageConfigsLazyServerSideAndExecHook(pageContext) {
+    const pageContextAddendum = await loadPageConfigsLazyServerSide(pageContext);
+    (0, utils_js_1.objectAssign)(pageContext, pageContextAddendum);
+    await (0, execHookServer_js_1.execHookServer)('onCreatePageContext', pageContext);
+    return pageContext;
+}
 async function loadPageConfigsLazyServerSide(pageContext) {
     const pageConfig = (0, findPageConfig_js_1.findPageConfig)(pageContext._globalContext._pageConfigs, pageContext.pageId); // Make pageConfig globally available as pageContext._pageConfig ?
     const globalContext = pageContext._globalContext;
@@ -86,18 +93,16 @@ async function loadPageConfigsLazyServerSide(pageContext) {
             return pageAssetsOldFormat;
         },
     });
-    {
-        (0, debugPageFiles_js_1.debugPageFiles)({
-            pageContext,
-            isHtmlOnly,
-            isClientRouting,
-            pageFilesLoaded,
-            pageFilesClientSide,
-            pageFilesServerSide,
-            clientEntries,
-            clientDependencies,
-        });
-    }
+    (0, debugPageFiles_js_1.debugPageFiles)({
+        pageContext,
+        isHtmlOnly,
+        isClientRouting,
+        pageFilesLoaded,
+        pageFilesClientSide,
+        pageFilesServerSide,
+        clientEntries,
+        clientDependencies,
+    });
     return pageContextAddendum;
 }
 async function loadPageUserFiles(pageFilesAll, pageConfig, pageConfigGlobal, pageId, isDev) {

package/dist/cjs/node/runtime/renderPage/renderPageAlreadyRouted.js CHANGED Viewed

@@ -11,12 +11,12 @@ const utils_js_1 = require("../utils.js");
 const serializeContext_js_1 = require("../html/serializeContext.js");
 const createHttpResponse_js_1 = require("./createHttpResponse.js");
 const loadPageConfigsLazyServerSide_js_1 = require("./loadPageConfigsLazyServerSide.js");
-const executeOnRenderHtmlHook_js_1 = require("./executeOnRenderHtmlHook.js");
-const executeOnBeforeRenderAndDataHooks_js_1 = require("./executeOnBeforeRenderAndDataHooks.js");
+const execHookOnRenderHtml_js_1 = require("./execHookOnRenderHtml.js");
+const execHookDataAndOnBeforeRender_js_1 = require("./execHookDataAndOnBeforeRender.js");
 const loggerRuntime_js_1 = require("../loggerRuntime.js");
 const isNewError_js_1 = require("./isNewError.js");
 const preparePageContextForPublicUsageServer_js_1 = require("./preparePageContextForPublicUsageServer.js");
-const executeGuardHook_js_1 = require("../../../shared/route/executeGuardHook.js");
+const execHookGuard_js_1 = require("../../../shared/route/execHookGuard.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const isServerSideError_js_1 = require("../../../shared/misc/isServerSideError.js");
 async function renderPageAlreadyRouted(pageContext) {
@@ -28,16 +28,16 @@ async function renderPageAlreadyRouted(pageContext) {
     (0, utils_js_1.assert)(isError ===
         (pageContext.pageId ===
             (0, error_page_js_1.getErrorPageId)(pageContext._globalContext._pageFilesAll, pageContext._globalContext._pageConfigs)));
-    (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+    (0, utils_js_1.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSideAndExecHook)(pageContext));
     if (!isError) {
-        await (0, executeGuardHook_js_1.executeGuardHook)(pageContext, (pageContext) => (0, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer)(pageContext));
+        await (0, execHookGuard_js_1.execHookGuard)(pageContext, (pageContext) => (0, preparePageContextForPublicUsageServer_js_1.preparePageContextForPublicUsageServer)(pageContext));
     }
     if (!isError) {
-        await (0, executeOnBeforeRenderAndDataHooks_js_1.executeOnBeforeRenderAndDataHooks)(pageContext);
+        await (0, execHookDataAndOnBeforeRender_js_1.execHookDataAndOnBeforeRender)(pageContext);
     }
     else {
         try {
-            await (0, executeOnBeforeRenderAndDataHooks_js_1.executeOnBeforeRenderAndDataHooks)(pageContext);
+            await (0, execHookDataAndOnBeforeRender_js_1.execHookDataAndOnBeforeRender)(pageContext);
         }
         catch (err) {
             if ((0, isNewError_js_1.isNewError)(err, pageContext.errorWhileRendering)) {
@@ -54,7 +54,7 @@ async function renderPageAlreadyRouted(pageContext) {
         (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
         return pageContext;
     }
-    const renderHookResult = await (0, executeOnRenderHtmlHook_js_1.executeOnRenderHtmlHook)(pageContext);
+    const renderHookResult = await (0, execHookOnRenderHtml_js_1.execHookOnRenderHtml)(pageContext);
     const { htmlRender, renderHook } = renderHookResult;
     const httpResponse = await (0, createHttpResponse_js_1.createHttpResponsePage)(htmlRender, renderHook, pageContext);
     (0, utils_js_1.objectAssign)(pageContext, { httpResponse });
@@ -67,10 +67,10 @@ async function prerenderPage(pageContext) {
     });
     /* Should we execute the guard() hook upon pre-rendering? Is there a use case for this?
      *  - It isn't trivial to implement, as it requires to duplicate / factor out the isAbortError() handling
-    await executeGuardHook(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext))
+    await execHookGuard(pageContext, (pageContext) => preparePageContextForPublicUsageServer(pageContext))
     */
-    await (0, executeOnBeforeRenderAndDataHooks_js_1.executeOnBeforeRenderAndDataHooks)(pageContext);
-    const { htmlRender, renderHook } = await (0, executeOnRenderHtmlHook_js_1.executeOnRenderHtmlHook)(pageContext);
+    await (0, execHookDataAndOnBeforeRender_js_1.execHookDataAndOnBeforeRender)(pageContext);
+    const { htmlRender, renderHook } = await (0, execHookOnRenderHtml_js_1.execHookOnRenderHtml)(pageContext);
     (0, utils_js_1.assertUsage)(htmlRender !== null, `Cannot pre-render ${picocolors_1.default.cyan(pageContext.urlOriginal)} because the ${renderHook.hookName}() hook defined by ${renderHook.hookFilePath} didn't return an HTML string.`);
     (0, utils_js_1.assert)(pageContext.isClientSideNavigation === false);
     const documentHtml = await (0, renderHtml_js_1.getHtmlString)(htmlRender);

package/dist/cjs/node/runtime/renderPage.js CHANGED Viewed

@@ -143,59 +143,66 @@ async function renderPageAlreadyPrepared(pageContextBegin, globalContext, httpRe
     else {
         (0, utils_js_1.assert)(errNominalPage);
         (0, utils_js_1.assert)(pageContextNominalPageSuccess === undefined);
-        (0, utils_js_1.assert)(pageContextNominalPageBegin);
-        (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextNominalPageBegin, 'urlOriginal', 'string'));
-        const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
-        // Handle `throw redirect()` and `throw render()` while rendering nominal page
-        if ((0, abort_js_1.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);
+        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) {
+    (0, utils_js_1.assert)(pageContextNominalPageBegin);
+    (0, utils_js_1.assert)((0, utils_js_1.hasProp)(pageContextNominalPageBegin, 'urlOriginal', 'string'));
+    const pageContextErrorPageInit = await getPageContextErrorPageInit(pageContextBegin, errNominalPage, pageContextNominalPageBegin);
+    // Handle `throw redirect()` and `throw render()` while rendering nominal page
+    if ((0, abort_js_1.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;
         }
-        {
-            const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
-            if (!errorPageId) {
-                (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: null });
-                return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContextErrorPageInit);
-            }
-            else {
-                (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: errorPageId });
-            }
+        else {
+            // - throw render(abortStatusCode) if not .pageContext.json request
         }
-        let pageContextErrorPage;
-        try {
-            pageContextErrorPage = await (0, renderPageAlreadyRouted_js_1.renderPageAlreadyRouted)(pageContextErrorPageInit);
+        Object.assign(pageContextErrorPageInit, handled.pageContextAbort);
+    }
+    {
+        const errorPageId = (0, error_page_js_1.getErrorPageId)(globalContext._pageFilesAll, globalContext._pageConfigs);
+        if (!errorPageId) {
+            (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: null });
+            return (0, handleErrorWithoutErrorPage_js_1.handleErrorWithoutErrorPage)(pageContextErrorPageInit);
         }
-        catch (errErrorPage) {
-            // Handle `throw redirect()` and `throw render()` while rendering error page
-            if ((0, abort_js_1.isAbortError)(errErrorPage)) {
-                const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
-                // throw render(abortStatusCode)
-                if (!handled.pageContextReturn) {
-                    const pageContextAbort = errErrorPage._pageContextAbort;
-                    (0, utils_js_1.assertWarning)(false, `Failed to render error page because ${picocolors_1.default.cyan(pageContextAbort._abortCall)} was called: make sure ${picocolors_1.default.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;
-            }
-            if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
-                (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
+        else {
+            (0, utils_js_1.objectAssign)(pageContextErrorPageInit, { pageId: errorPageId });
+        }
+    }
+    let pageContextErrorPage;
+    try {
+        pageContextErrorPage = await (0, renderPageAlreadyRouted_js_1.renderPageAlreadyRouted)(pageContextErrorPageInit);
+    }
+    catch (errErrorPage) {
+        // Handle `throw redirect()` and `throw render()` while rendering error page
+        if ((0, abort_js_1.isAbortError)(errErrorPage)) {
+            const handled = await handleAbortError(errErrorPage, pageContextsFromRewrite, pageContextBegin, pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalContext);
+            // throw render(abortStatusCode)
+            if (!handled.pageContextReturn) {
+                const pageContextAbort = errErrorPage._pageContextAbort;
+                (0, utils_js_1.assertWarning)(false, `Failed to render error page because ${picocolors_1.default.cyan(pageContextAbort._abortCall)} was called: make sure ${picocolors_1.default.cyan(pageContextAbort._abortCaller)} doesn't occur while the error page is being rendered.`, { onlyOnce: false });
+                const pageContextHttpWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+                return pageContextHttpWithError;
             }
-            const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
-            return pageContextWithError;
+            // `throw redirect()` / `throw render(url)`
+            return handled.pageContextReturn;
         }
-        return pageContextErrorPage;
+        if ((0, isNewError_js_1.isNewError)(errErrorPage, errNominalPage)) {
+            (0, loggerRuntime_js_1.logRuntimeError)(errErrorPage, httpRequestId);
+        }
+        const pageContextWithError = getPageContextHttpResponseError(errNominalPage, pageContextBegin);
+        return pageContextWithError;
     }
+    return pageContextErrorPage;
 }
 function logHttpRequest(urlOriginal, httpRequestId) {
     (0, loggerRuntime_js_1.logRuntimeInfo)?.(getRequestInfoMessage(urlOriginal), httpRequestId, 'info');
@@ -417,7 +424,7 @@ pageContextNominalPageBegin, httpRequestId, pageContextErrorPageInit, globalCont
             (0, utils_js_1.objectAssign)(pageContext, { pageId: errorPageId });
             (0, utils_js_1.objectAssign)(pageContext, pageContextAbort);
             (0, utils_js_1.objectAssign)(pageContext, pageContextErrorPageInit, true);
-            (0, utils_js_1.objectAssign)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSide)(pageContext));
+            (0, utils_js_1.augmentType)(pageContext, await (0, loadPageConfigsLazyServerSide_js_1.loadPageConfigsLazyServerSideAndExecHook)(pageContext));
             // We include pageContextInit: we don't only serialize pageContextAbort because the error page may need to access pageContextInit
             pageContextSerialized = (0, serializeContext_js_1.getPageContextClientSerialized)(pageContext);
         }

package/dist/cjs/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js CHANGED Viewed

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

package/dist/cjs/shared/createPageContextShared.js CHANGED Viewed

@@ -2,12 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPageContextShared = createPageContextShared;
 exports.createPageContextObject = createPageContextObject;
-const execHook_js_1 = require("./hooks/execHook.js");
-const preparePageContextForPublicUsage_js_1 = require("./preparePageContextForPublicUsage.js");
 const utils_js_1 = require("./utils.js");
+// TODO/now: make this and parents sync
 async function createPageContextShared(pageContextCreated, pageConfigGlobal, vikeConfigPublicGlobal) {
     (0, utils_js_1.objectAssign)(pageContextCreated, vikeConfigPublicGlobal);
-    await (0, execHook_js_1.execHookGlobal)('onCreatePageContext', pageConfigGlobal, pageContextCreated, pageContextCreated, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
     return pageContextCreated;
 }
 function createPageContextObject() {

package/dist/cjs/shared/hooks/execHook.js CHANGED Viewed

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.execHook = execHook;
-exports.execHookSingle = execHookSingle;
-exports.execHookSingleWithReturn = execHookSingleWithReturn;
-exports.execHookErrorHandling = execHookErrorHandling;
-exports.execHooksErrorHandling = execHooksErrorHandling;
-exports.execHookWithoutPageContext = execHookWithoutPageContext;
 exports.execHookGlobal = execHookGlobal;
-exports.execHookSync = execHookSync;
+exports.execHookDirect = execHookDirect;
+exports.execHookDirectSingle = execHookDirectSingle;
+exports.execHookDirectSingleWithReturn = execHookDirectSingleWithReturn;
+exports.execHookDirectWithoutPageContext = execHookDirectWithoutPageContext;
+exports.execHookDirectSync = execHookDirectSync;
 exports.getPageContext = getPageContext;
 exports.providePageContext = providePageContext;
 exports.isUserHookError = isUserHookError;
@@ -21,70 +20,48 @@ const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/execHook.t
     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];
-    (0, assert_js_1.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 = (0, getHook_js_1.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 = (0, getHook_js_1.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];
+    (0, assert_js_1.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 (!(0, isObject_js_1.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;
@@ -128,7 +105,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/cjs/shared/route/{executeGuardHook.js → execHookGuard.js} RENAMED Viewed

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeGuardHook = executeGuardHook;
+exports.execHookGuard = execHookGuard;
 const getHook_js_1 = require("../hooks/getHook.js");
 const utils_js_1 = require("./utils.js");
 const execHook_js_1 = require("../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
@@ -19,7 +19,7 @@ async function executeGuardHook(pageContext, prepareForPublicUsage) {
     }
     if (!hook)
         return;
-    await (0, execHook_js_1.execHookSingle)(hook, pageContext, prepareForPublicUsage);
+    await (0, execHook_js_1.execHookDirectSingle)(hook, pageContext, prepareForPublicUsage);
 }
 function findPageGuard(pageId, pageFilesAll) {
     const pageRouteFile = pageFilesAll.find((p) => p.pageId === pageId && p.fileType === '.page.route');

package/dist/cjs/shared/route/{executeOnBeforeRouteHook.js → execHookOnBeforeRoute.js} RENAMED Viewed

@@ -3,14 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeOnBeforeRouteHook = executeOnBeforeRouteHook;
+exports.execHookOnBeforeRoute = execHookOnBeforeRoute;
 const assertPageContextProvidedByUser_js_1 = require("../assertPageContextProvidedByUser.js");
 const utils_js_1 = require("./utils.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 const execHook_js_1 = require("../hooks/execHook.js");
 const preparePageContextForPublicUsage_js_1 = require("../preparePageContextForPublicUsage.js");
-async function executeOnBeforeRouteHook(pageContext) {
+async function execHookOnBeforeRoute(pageContext) {
     const pageContextFromOnBeforeRouteHook = {};
     if (!pageContext._globalContext._onBeforeRouteHook)
         return null;
@@ -39,9 +39,9 @@ async function executeOnBeforeRouteHook(pageContext) {
     return pageContextFromOnBeforeRouteHook;
 }
 async function getPageContextFromHook(onBeforeRouteHook, pageContext) {
-    let { hookReturn } = (0, execHook_js_1.execHookSync)(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
+    let { hookReturn } = (0, execHook_js_1.execHookDirectSync)(onBeforeRouteHook, pageContext, preparePageContextForPublicUsage_js_1.preparePageContextForPublicUsage);
     (0, resolveRouteFunction_js_1.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}`;
     (0, utils_js_1.assertUsage)(hookReturn === null ||

package/dist/cjs/shared/route/index.js CHANGED Viewed

@@ -14,15 +14,16 @@ const utils_js_1 = require("./utils.js");
 const resolvePrecedence_js_1 = require("./resolvePrecedence.js");
 const resolveRouteString_js_1 = require("./resolveRouteString.js");
 const resolveRouteFunction_js_1 = require("./resolveRouteFunction.js");
-const executeOnBeforeRouteHook_js_1 = require("./executeOnBeforeRouteHook.js");
+const execHookOnBeforeRoute_js_1 = require("./execHookOnBeforeRoute.js");
 const debug_js_1 = require("./debug.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+// TODO/next-major-release: make it sync
 async function route(pageContext, skipOnBeforeRouteHook) {
     (0, debug_js_1.debug)('Pages routes:', pageContext._globalContext._pageRoutes);
     const pageContextFromRoute = {};
     // onBeforeRoute()
     if (!skipOnBeforeRouteHook) {
-        const pageContextFromOnBeforeRouteHook = await (0, executeOnBeforeRouteHook_js_1.executeOnBeforeRouteHook)(pageContext);
+        const pageContextFromOnBeforeRouteHook = await (0, execHookOnBeforeRoute_js_1.execHookOnBeforeRoute)(pageContext);
         if (pageContextFromOnBeforeRouteHook) {
             if (pageContextFromOnBeforeRouteHook._routingProvidedByOnBeforeRouteHook) {
                 (0, utils_js_1.assert)(pageContextFromOnBeforeRouteHook.pageId);

package/dist/cjs/shared/route/resolveRouteFunction.js CHANGED Viewed

@@ -12,7 +12,7 @@ const preparePageContextForPublicUsage_js_1 = require("../preparePageContextForP
 const utils_js_1 = require("./utils.js");
 const picocolors_1 = __importDefault(require("@brillout/picocolors"));
 async function resolveRouteFunction(routeFunction, pageContext, routeFunctionFilePath) {
-    let { hookReturn: result } = (0, execHook_js_1.execHookSync)({
+    let { hookReturn: result } = (0, execHook_js_1.execHookDirectSync)({
         hookFn: routeFunction,
         hookFilePath: routeFunctionFilePath,
         hookName: 'route',

package/dist/cjs/utils/PROJECT_VERSION.js CHANGED Viewed

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROJECT_VERSION = void 0;
 // Automatically updated by @brillout/release-me
-exports.PROJECT_VERSION = '0.4.232';
+exports.PROJECT_VERSION = '0.4.233';

package/dist/cjs/utils/styleFileRE.js CHANGED Viewed

@@ -2,4 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.styleFileRE = void 0;
 // Copied from https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/css.ts#L90-L91
+// spellcheck-ignore
 exports.styleFileRE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\?)/;

package/dist/esm/client/runtime-client-routing/getPageContextFromHooks.d.ts CHANGED Viewed

@@ -421,8 +421,8 @@ declare function getPageContextFromClientHooks(pageContext: {
 } & {
     urlOriginal: string;
 }>;
-type PageContextExecuteHookClient = VikeConfigPublicPageLazy & PageContextForPublicUsageClient;
-declare function execHookClient(hookName: HookName, pageContext: PageContextExecuteHookClient): Promise<(import("../../shared/hooks/getHook.js").HookLoc & {
+type PageContextExecHookClient = VikeConfigPublicPageLazy & PageContextForPublicUsageClient;
+declare function execHookClient(hookName: HookName, pageContext: PageContextExecHookClient): Promise<(import("../../shared/hooks/getHook.js").HookLoc & {
     hookFn: (arg: import("../../shared/preparePageContextForPublicUsage.js").PageContextPrepareMinimum | import("../../shared/prepareGlobalContextForPublicUsage.js").GlobalContextPrepareMinimum) => unknown;
     hookTimeout: import("../../shared/hooks/getHook.js").HookTimeout;
 } & {